Merge pilot.blaudden:/home/msvensson/mysql/mysql-5.0

into  pilot.blaudden:/home/msvensson/mysql/mysql-5.0-maint


BitKeeper/etc/ignore:
  auto-union
client/mysqltest.c:
  Auto merged
extra/comp_err.c:
  Auto merged
include/my_time.h:
  Auto merged
mysql-test/r/innodb.result:
  Auto merged
mysql-test/r/mysqltest.result:
  Auto merged
mysql-test/r/type_blob.result:
  Auto merged
mysql-test/t/mysqltest.test:
  Auto merged
sql/item.cc:
  Auto merged
sql/item_cmpfunc.cc:
  Auto merged
sql/item_cmpfunc.h:
  Auto merged
sql/item_strfunc.cc:
  Auto merged
sql/log.cc:
  Auto merged
sql/mysql_priv.h:
  Auto merged
sql/mysqld.cc:
  Auto merged
sql/set_var.cc:
  Auto merged
sql/sql_class.cc:
  Auto merged
sql/sql_class.h:
  Auto merged
sql/sql_load.cc:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_select.cc:
  Auto merged
sql/tztime.cc:
  Auto merged
client/mysql_upgrade.c:
  Manual merge
mysql-test/mysql-test-run.pl:
  Manual merge
mysql-test/r/ctype_cp932.result:
  Manual merge
mysql-test/r/mysqlbinlog.result:
  Manual merge
mysql-test/t/ctype_cp932.test:
  Manual merge
mysql-test/t/mysql.test:
  Manual merge
mysql-test/t/mysqlbinlog.test:
  Manual merge

77 files changed, 1881 insertions, 1236 deletions

diff --git a/sql/field.cc b/sql/field.cc
index 74a5e742c06..367cbdaa0e5 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -1393,12 +1393,12 @@ my_decimal* Field_num::val_decimal(my_decimal *decimal_value)
 Field_str::Field_str(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
                      uchar null_bit_arg, utype unireg_check_arg,
                      const char *field_name_arg,
-                     struct st_table *table_arg,CHARSET_INFO *charset)
+                     struct st_table *table_arg, CHARSET_INFO *charset_arg)
   :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
          unireg_check_arg, field_name_arg, table_arg)
 {
-  field_charset=charset;
-  if (charset->state & MY_CS_BINSORT)
+  field_charset= charset_arg;
+  if (charset_arg->state & MY_CS_BINSORT)
     flags|=BINARY_FLAG;
   field_derivation= DERIVATION_IMPLICIT;
 }
@@ -1503,7 +1503,7 @@ bool Field::get_time(TIME *ltime)
     Needs to be changed if/when we want to support different time formats
 */
 
-int Field::store_time(TIME *ltime, timestamp_type type)
+int Field::store_time(TIME *ltime, timestamp_type type_arg)
 {
   char buff[MAX_DATE_STRING_REP_LENGTH];
   uint length= (uint) my_TIME_to_str(ltime, buff);
@@ -2199,13 +2199,13 @@ Field_new_decimal::Field_new_decimal(char *ptr_arg,
 
 
 Field_new_decimal::Field_new_decimal(uint32 len_arg,
-                                     bool maybe_null,
+                                     bool maybe_null_arg,
                                      const char *name,
                                      struct st_table *t_arg,
                                      uint8 dec_arg,
                                      bool unsigned_arg)
   :Field_num((char*) 0, len_arg,
-             maybe_null ? (uchar*) "": 0, 0,
+             maybe_null_arg ? (uchar*) "": 0, 0,
              NONE, name, t_arg,
              dec_arg,
              0, unsigned_arg)
@@ -2309,7 +2309,7 @@ bool Field_new_decimal::store_value(const my_decimal *decimal_value)
 
 
 int Field_new_decimal::store(const char *from, uint length,
-                             CHARSET_INFO *charset)
+                             CHARSET_INFO *charset_arg)
 {
   int err;
   my_decimal decimal_value;
@@ -2317,7 +2317,7 @@ int Field_new_decimal::store(const char *from, uint length,
 
   if ((err= str2my_decimal(E_DEC_FATAL_ERROR &
                       ~(E_DEC_OVERFLOW | E_DEC_BAD_NUM),
-                      from, length, charset,  &decimal_value)) &&
+                      from, length, charset_arg,  &decimal_value)) &&
       table->in_use->abort_on_warning)
   {
     /* Because "from" is not NUL-terminated and we use %s in the ER() */
@@ -3201,25 +3201,6 @@ void Field_medium::sql_type(String &res) const
 ** long int
 ****************************************************************************/
 
-/*
-  A helper function to check whether the next character
-  in the string "s" is MINUS SIGN. 
-*/
-#ifdef HAVE_CHARSET_ucs2
-static bool test_if_minus(CHARSET_INFO *cs,
-                          const char *s, const char *e)
-{
-  my_wc_t wc;
-  return cs->cset->mb_wc(cs, &wc, (uchar*) s, (uchar*) e) > 0 && wc == '-';
-}
-#else
-/*
-  If not UCS2 support is compiled then it is easier
-*/
-#define test_if_minus(cs, s, e)  (*s == '-')
-#endif
-
-
 int Field_long::store(const char *from,uint len,CHARSET_INFO *cs)
 {
   long store_tmp;
@@ -4810,7 +4791,7 @@ int Field_time::store(const char *from,uint len,CHARSET_INFO *cs)
 }
 
 
-int Field_time::store_time(TIME *ltime, timestamp_type type)
+int Field_time::store_time(TIME *ltime, timestamp_type time_type)
 {
   long tmp= ((ltime->month ? 0 : ltime->day * 24L) + ltime->hour) * 10000L +
             (ltime->minute * 100 + ltime->second);
@@ -5405,11 +5386,12 @@ int Field_newdate::store(longlong nr, bool unsigned_val)
 }
 
 
-int Field_newdate::store_time(TIME *ltime,timestamp_type type)
+int Field_newdate::store_time(TIME *ltime, timestamp_type time_type)
 {
   long tmp;
   int error= 0;
-  if (type == MYSQL_TIMESTAMP_DATE || type == MYSQL_TIMESTAMP_DATETIME)
+  if (time_type == MYSQL_TIMESTAMP_DATE ||
+      time_type == MYSQL_TIMESTAMP_DATETIME)
   {
     tmp=ltime->year*16*32+ltime->month*32+ltime->day;
     if (check_date(ltime, tmp != 0,
@@ -5624,7 +5606,7 @@ int Field_datetime::store(longlong nr, bool unsigned_val)
 }
 
 
-int Field_datetime::store_time(TIME *ltime,timestamp_type type)
+int Field_datetime::store_time(TIME *ltime,timestamp_type time_type)
 {
   longlong tmp;
   int error= 0;
@@ -5632,7 +5614,8 @@ int Field_datetime::store_time(TIME *ltime,timestamp_type type)
     We don't perform range checking here since values stored in TIME
     structure always fit into DATETIME range.
   */
-  if (type == MYSQL_TIMESTAMP_DATE || type == MYSQL_TIMESTAMP_DATETIME)
+  if (time_type == MYSQL_TIMESTAMP_DATE ||
+      time_type == MYSQL_TIMESTAMP_DATETIME)
   {
     tmp=((ltime->year*10000L+ltime->month*100+ltime->day)*LL(1000000)+
 	 (ltime->hour*10000L+ltime->minute*100+ltime->second));
@@ -6007,32 +5990,32 @@ int Field_str::store(double nr)
   char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
   uint length;
   bool use_scientific_notation= TRUE;
-  uint char_length= field_length / charset()->mbmaxlen;
+  uint local_char_length= field_length / charset()->mbmaxlen;
   /*
     Check fabs(nr) against longest value that can be stored in field,
     which depends on whether the value is < 1 or not, and negative or not
   */
   double anr= fabs(nr);
   int neg= (nr < 0.0) ? 1 : 0;
-  if (char_length > 4 && char_length < 32 &&
-      (anr < 1.0 ? anr > 1/(log_10[max(0,(int) char_length-neg-2)]) /* -2 for "0." */
-                 : anr < log_10[char_length-neg]-1))
+  if (local_char_length > 4 && local_char_length < 32 &&
+      (anr < 1.0 ? anr > 1/(log_10[max(0,(int) local_char_length-neg-2)]) /* -2 for "0." */
+                 : anr < log_10[local_char_length-neg]-1))
     use_scientific_notation= FALSE;
 
   length= (uint) my_sprintf(buff, (buff, "%-.*g",
                                    (use_scientific_notation ?
-                                    max(0, (int)char_length-neg-5) :
-                                    char_length),
+                                    max(0, (int)local_char_length-neg-5) :
+                                    local_char_length),
                                    nr));
   /*
     +1 below is because "precision" in %g above means the
     max. number of significant digits, not the output width.
     Thus the width can be larger than number of significant digits by 1
     (for decimal point)
-    the test for char_length < 5 is for extreme cases,
+    the test for local_char_length < 5 is for extreme cases,
     like inserting 500.0 in char(1)
   */
-  DBUG_ASSERT(char_length < 5 || length <= char_length+1);
+  DBUG_ASSERT(local_char_length < 5 || length <= local_char_length+1);
   return store((const char *) buff, length, charset());
 }
 
@@ -6161,9 +6144,9 @@ int Field_string::cmp(const char *a_ptr, const char *b_ptr)
 
 void Field_string::sort_string(char *to,uint length)
 {
-  uint tmp=my_strnxfrm(field_charset,
-		       (unsigned char *) to, length,
-		       (unsigned char *) ptr, field_length);
+  IF_DBUG(uint tmp=) my_strnxfrm(field_charset,
+                                 (unsigned char *) to, length,
+                                 (unsigned char *) ptr, field_length);
   DBUG_ASSERT(tmp == length);
 }
 
@@ -6191,10 +6174,11 @@ void Field_string::sql_type(String &res) const
 char *Field_string::pack(char *to, const char *from, uint max_length)
 {
   uint length=      min(field_length,max_length);
-  uint char_length= max_length/field_charset->mbmaxlen;
-  if (length > char_length)
-    char_length= my_charpos(field_charset, from, from+length, char_length);
-  set_if_smaller(length, char_length);
+  uint local_char_length= max_length/field_charset->mbmaxlen;
+  if (length > local_char_length)
+    local_char_length= my_charpos(field_charset, from, from+length,
+                                  local_char_length);
+  set_if_smaller(length, local_char_length);
   while (length && from[length-1] == ' ')
     length--;
   *to++= (char) (uchar) length;
@@ -6278,15 +6262,15 @@ int Field_string::pack_cmp(const char *a, const char *b, uint length,
 int Field_string::pack_cmp(const char *key, uint length,
                            my_bool insert_or_update)
 {
-  uint row_length, key_length;
+  uint row_length, local_key_length;
   char *end;
   if (length > 255)
   {
-    key_length= uint2korr(key);
+    local_key_length= uint2korr(key);
     key+= 2;
   }
   else
-    key_length= (uint) (uchar) *key++;
+    local_key_length= (uint) (uchar) *key++;
   
   /* Only use 'length' of key, not field_length */
   end= ptr + length;
@@ -6296,7 +6280,7 @@ int Field_string::pack_cmp(const char *key, uint length,
 
   return field_charset->coll->strnncollsp(field_charset,
                                           (const uchar*) ptr, row_length,
-                                          (const uchar*) key, key_length,
+                                          (const uchar*) key, local_key_length,
                                           insert_or_update);
 }
 
@@ -6318,10 +6302,10 @@ uint Field_string::max_packed_col_length(uint max_length)
 Field *Field_string::new_field(MEM_ROOT *root, struct st_table *new_table,
                                bool keep_type)
 {
-  Field *new_field;
+  Field *field;
 
   if (type() != MYSQL_TYPE_VAR_STRING || keep_type)
-    new_field= Field::new_field(root, new_table, keep_type);
+    field= Field::new_field(root, new_table, keep_type);
   else
   {
 
@@ -6330,7 +6314,7 @@ Field *Field_string::new_field(MEM_ROOT *root, struct st_table *new_table,
       This is done to ensure that ALTER TABLE will convert old VARCHAR fields
       to now VARCHAR fields.
     */
-    new_field= new Field_varstring(field_length, maybe_null(),
+    field= new Field_varstring(field_length, maybe_null(),
                                    field_name, new_table, charset());
     /*
       Normally orig_table is different from table only if field was created
@@ -6338,9 +6322,9 @@ Field *Field_string::new_field(MEM_ROOT *root, struct st_table *new_table,
       not applicable. But we still need to preserve the original field
       metadata for the client-server protocol.
     */
-    new_field->orig_table= orig_table;
+    field->orig_table= orig_table;
   }
-  return new_field;
+  return field;
 }
 
 /****************************************************************************
@@ -6481,11 +6465,11 @@ int Field_varstring::cmp(const char *a_ptr, const char *b_ptr)
 int Field_varstring::key_cmp(const byte *key_ptr, uint max_key_length)
 {
   uint length=  length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
-  uint char_length= max_key_length / field_charset->mbmaxlen;
+  uint local_char_length= max_key_length / field_charset->mbmaxlen;
 
-  char_length= my_charpos(field_charset, ptr + length_bytes,
-                          ptr + length_bytes + length, char_length);
-  set_if_smaller(length, char_length);
+  local_char_length= my_charpos(field_charset, ptr + length_bytes,
+                          ptr + length_bytes + length, local_char_length);
+  set_if_smaller(length, local_char_length);
   return field_charset->coll->strnncollsp(field_charset, 
                                           (const uchar*) ptr + length_bytes,
                                           length,
@@ -6595,13 +6579,14 @@ char *Field_varstring::pack(char *to, const char *from, uint max_length)
 char *Field_varstring::pack_key(char *to, const char *key, uint max_length)
 {
   uint length=  length_bytes == 1 ? (uint) (uchar) *key : uint2korr(key);
-  uint char_length= ((field_charset->mbmaxlen > 1) ?
+  uint local_char_length= ((field_charset->mbmaxlen > 1) ?
                      max_length/field_charset->mbmaxlen : max_length);
   key+= length_bytes;
-  if (length > char_length)
+  if (length > local_char_length)
   {
-    char_length= my_charpos(field_charset, key, key+length, char_length);
-    set_if_smaller(length, char_length);
+    local_char_length= my_charpos(field_charset, key, key+length,
+                                  local_char_length);
+    set_if_smaller(length, local_char_length);
   }
   *to++= (char) (length & 255);
   if (max_length > 255)
@@ -6697,11 +6682,12 @@ const char *Field_varstring::unpack(char *to, const char *from)
 }
 
 
-int Field_varstring::pack_cmp(const char *a, const char *b, uint key_length,
+int Field_varstring::pack_cmp(const char *a, const char *b,
+                              uint key_length_arg,
                               my_bool insert_or_update)
 {
   uint a_length, b_length;
-  if (key_length > 255)
+  if (key_length_arg > 255)
   {
     a_length=uint2korr(a); a+= 2;
     b_length=uint2korr(b); b+= 2;
@@ -6718,26 +6704,28 @@ int Field_varstring::pack_cmp(const char *a, const char *b, uint key_length,
 }
 
 
-int Field_varstring::pack_cmp(const char *b, uint key_length,
+int Field_varstring::pack_cmp(const char *b, uint key_length_arg,
                               my_bool insert_or_update)
 {
   char *a= ptr+ length_bytes;
   uint a_length=  length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
   uint b_length;
-  uint char_length= ((field_charset->mbmaxlen > 1) ?
-                     key_length / field_charset->mbmaxlen : key_length);
+  uint local_char_length= ((field_charset->mbmaxlen > 1) ?
+                           key_length_arg / field_charset->mbmaxlen :
+                           key_length_arg);
 
-  if (key_length > 255)
+  if (key_length_arg > 255)
   {
     b_length=uint2korr(b); b+= HA_KEY_BLOB_LENGTH;
   }
   else
     b_length= (uint) (uchar) *b++;
 
-  if (a_length > char_length)
+  if (a_length > local_char_length)
   {
-    char_length= my_charpos(field_charset, a, a+a_length, char_length);
-    set_if_smaller(a_length, char_length);
+    local_char_length= my_charpos(field_charset, a, a+a_length,
+                                  local_char_length);
+    set_if_smaller(a_length, local_char_length);
   }
 
   return field_charset->coll->strnncollsp(field_charset,
@@ -6762,13 +6750,15 @@ uint Field_varstring::max_packed_col_length(uint max_length)
 }
 
 
-void Field_varstring::get_key_image(char *buff, uint length, imagetype type)
+void Field_varstring::get_key_image(char *buff, uint length,
+                                    imagetype type_arg)
 {
   uint f_length=  length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
-  uint char_length= length / field_charset->mbmaxlen;
+  uint local_char_length= length / field_charset->mbmaxlen;
   char *pos= ptr+length_bytes;
-  char_length= my_charpos(field_charset, pos, pos + f_length, char_length);
-  set_if_smaller(f_length, char_length);
+  local_char_length= my_charpos(field_charset, pos, pos + f_length,
+                                local_char_length);
+  set_if_smaller(f_length, local_char_length);
   /* Key is always stored with 2 bytes */
   int2store(buff,f_length);
   memcpy(buff+HA_KEY_BLOB_LENGTH, pos, f_length);
@@ -7024,7 +7014,7 @@ int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
                               cannot_convert_error_pos, from + length))
     return 2;
 
-  if (copy_length < length)
+  if (from_end_pos < from + length)
   {
     report_data_too_long(this);
     return 2;
@@ -7151,13 +7141,13 @@ int Field_blob::cmp_binary(const char *a_ptr, const char *b_ptr,
 
 /* The following is used only when comparing a key */
 
-void Field_blob::get_key_image(char *buff, uint length, imagetype type)
+void Field_blob::get_key_image(char *buff, uint length, imagetype type_arg)
 {
   uint32 blob_length= get_length(ptr);
   char *blob;
 
 #ifdef HAVE_SPATIAL
-  if (type == itMBR)
+  if (type_arg == itMBR)
   {
     const char *dummy;
     MBR mbr;
@@ -7185,10 +7175,10 @@ void Field_blob::get_key_image(char *buff, uint length, imagetype type)
 #endif /*HAVE_SPATIAL*/
 
   get_ptr(&blob);
-  uint char_length= length / field_charset->mbmaxlen;
-  char_length= my_charpos(field_charset, blob, blob + blob_length,
-                          char_length);
-  set_if_smaller(blob_length, char_length);
+  uint local_char_length= length / field_charset->mbmaxlen;
+  local_char_length= my_charpos(field_charset, blob, blob + blob_length,
+                          local_char_length);
+  set_if_smaller(blob_length, local_char_length);
 
   if ((uint32) length > blob_length)
   {
@@ -7217,9 +7207,10 @@ int Field_blob::key_cmp(const byte *key_ptr, uint max_key_length)
   uint blob_length=get_length(ptr);
   memcpy_fixed(&blob1,ptr+packlength,sizeof(char*));
   CHARSET_INFO *cs= charset();
-  uint char_length= max_key_length / cs->mbmaxlen;
-  char_length= my_charpos(cs, blob1, blob1+blob_length, char_length);
-  set_if_smaller(blob_length, char_length);
+  uint local_char_length= max_key_length / cs->mbmaxlen;
+  local_char_length= my_charpos(cs, blob1, blob1+blob_length,
+                                local_char_length);
+  set_if_smaller(blob_length, local_char_length);
   return Field_blob::cmp(blob1, blob_length,
 			 (char*) key_ptr+HA_KEY_BLOB_LENGTH,
 			 uint2korr(key_ptr));
@@ -7341,11 +7332,11 @@ const char *Field_blob::unpack(char *to, const char *from)
 
 /* Keys for blobs are like keys on varchars */
 
-int Field_blob::pack_cmp(const char *a, const char *b, uint key_length,
+int Field_blob::pack_cmp(const char *a, const char *b, uint key_length_arg,
                          my_bool insert_or_update)
 {
   uint a_length, b_length;
-  if (key_length > 255)
+  if (key_length_arg > 255)
   {
     a_length=uint2korr(a); a+=2;
     b_length=uint2korr(b); b+=2;
@@ -7362,19 +7353,19 @@ int Field_blob::pack_cmp(const char *a, const char *b, uint key_length,
 }
 
 
-int Field_blob::pack_cmp(const char *b, uint key_length,
+int Field_blob::pack_cmp(const char *b, uint key_length_arg,
                          my_bool insert_or_update)
 {
   char *a;
+  uint a_length, b_length;
   memcpy_fixed(&a,ptr+packlength,sizeof(char*));
   if (!a)
-    return key_length > 0 ? -1 : 0;
-  uint a_length=get_length(ptr);
-  uint b_length;
+    return key_length_arg > 0 ? -1 : 0;
 
-  if (key_length > 255)
+  a_length= get_length(ptr);
+  if (key_length_arg > 255)
   {
-    b_length=uint2korr(b); b+=2;
+    b_length= uint2korr(b); b+=2;
   }
   else
     b_length= (uint) (uchar) *b++;
@@ -7391,13 +7382,14 @@ char *Field_blob::pack_key(char *to, const char *from, uint max_length)
   char *save=ptr;
   ptr=(char*) from;
   uint32 length=get_length();			// Length of from string
-  uint char_length= ((field_charset->mbmaxlen > 1) ?
+  uint local_char_length= ((field_charset->mbmaxlen > 1) ?
                      max_length/field_charset->mbmaxlen : max_length);
   if (length)
     get_ptr((char**) &from);
-  if (length > char_length)
-    char_length= my_charpos(field_charset, from, from+length, char_length);
-  set_if_smaller(length, char_length);
+  if (length > local_char_length)
+    local_char_length= my_charpos(field_charset, from, from+length,
+                                  local_char_length);
+  set_if_smaller(length, local_char_length);
   *to++= (uchar) length;
   if (max_length > 255)				// 2 byte length
     *to++= (uchar) (length >> 8);
@@ -7484,7 +7476,7 @@ uint Field_blob::max_packed_col_length(uint max_length)
 
 #ifdef HAVE_SPATIAL
 
-void Field_geom::get_key_image(char *buff, uint length, imagetype type)
+void Field_geom::get_key_image(char *buff, uint length, imagetype type_arg)
 {
   char *blob;
   const char *dummy;
@@ -7582,7 +7574,7 @@ int Field_geom::store(const char *from, uint length, CHARSET_INFO *cs)
       goto err;
     wkb_type= uint4korr(from + SRID_SIZE + 1);
     if (wkb_type < (uint32) Geometry::wkb_point ||
-	wkb_type > (uint32) Geometry::wkb_end)
+	wkb_type > (uint32) Geometry::wkb_last)
       goto err;
     Field_blob::store_length(length);
     if (table->copy_blobs || length <= MAX_FIELD_WIDTH)
@@ -8217,7 +8209,7 @@ int Field_bit::cmp_offset(uint row_offset)
 }
 
 
-void Field_bit::get_key_image(char *buff, uint length, imagetype type)
+void Field_bit::get_key_image(char *buff, uint length, imagetype type_arg)
 {
   if (bit_len)
   {
@@ -8380,7 +8372,7 @@ void create_field::create_length_to_internal_length(void)
 
 
 void create_field::init_for_tmp_table(enum_field_types sql_type_arg,
-                                      uint32 length_arg, uint32 decimals,
+                                      uint32 length_arg, uint32 decimals_arg,
                                       bool maybe_null, bool is_unsigned)
 {
   field_name= "";
@@ -8391,7 +8383,7 @@ void create_field::init_for_tmp_table(enum_field_types sql_type_arg,
   charset= &my_charset_bin;
   geom_type= Field::GEOM_GEOMETRY;
   pack_flag= (FIELDFLAG_NUMBER |
-              ((decimals & FIELDFLAG_MAX_DEC) << FIELDFLAG_DEC_SHIFT) |
+              ((decimals_arg & FIELDFLAG_MAX_DEC) << FIELDFLAG_DEC_SHIFT) |
               (maybe_null ? FIELDFLAG_MAYBE_NULL : 0) |
               (is_unsigned ? 0 : FIELDFLAG_DECIMAL));
 }
@@ -9096,12 +9088,13 @@ create_field::create_field(Field *old_field,Field *orig_field)
   maximum possible display length for blob
 
   SYNOPSIS
-    Field_blob::max_length()
+    Field_blob::max_display_length()
 
   RETURN
     length
 */
-uint32 Field_blob::max_length()
+
+uint32 Field_blob::max_display_length()
 {
   switch (packlength)
   {
diff --git a/sql/field.h b/sql/field.h
index fe3c59c89f5..524380800f3 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -153,12 +153,12 @@ public:
   virtual void reset_fields() {}
   virtual void set_default()
   {
-    my_ptrdiff_t offset = (my_ptrdiff_t) (table->s->default_values -
+    my_ptrdiff_t l_offset= (my_ptrdiff_t) (table->s->default_values -
 					  table->record[0]);
-    memcpy(ptr, ptr + offset, pack_length());
+    memcpy(ptr, ptr + l_offset, pack_length());
     if (null_ptr)
       *null_ptr= ((*null_ptr & (uchar) ~null_bit) |
-		  null_ptr[offset] & null_bit);
+		  null_ptr[l_offset] & null_bit);
   }
   virtual bool binary() const { return 1; }
   virtual bool zero_pack() const { return 1; }
@@ -235,7 +235,7 @@ public:
     { memcpy(buff,ptr,length); }
   inline void set_image(char *buff,uint length, CHARSET_INFO *cs)
     { memcpy(ptr,buff,length); }
-  virtual void get_key_image(char *buff, uint length, imagetype type)
+  virtual void get_key_image(char *buff, uint length, imagetype type_arg)
     { get_image(buff,length, &my_charset_bin); }
   virtual void set_key_image(char *buff,uint length)
     { set_image(buff,length, &my_charset_bin); }
@@ -300,10 +300,10 @@ public:
   virtual CHARSET_INFO *charset(void) const { return &my_charset_bin; }
   virtual CHARSET_INFO *sort_charset(void) const { return charset(); }
   virtual bool has_charset(void) const { return FALSE; }
-  virtual void set_charset(CHARSET_INFO *charset) { }
+  virtual void set_charset(CHARSET_INFO *charset_arg) { }
   virtual enum Derivation derivation(void) const
   { return DERIVATION_IMPLICIT; }
-  virtual void set_derivation(enum Derivation derivation) { }
+  virtual void set_derivation(enum Derivation derivation_arg) { }
   bool set_warning(MYSQL_ERROR::enum_warning_level, unsigned int code,
                    int cuted_increment);
   bool check_int(const char *str, int length, const char *int_end,
@@ -322,7 +322,7 @@ public:
   }
   int warn_if_overflow(int op_result);
   /* maximum possible display length */
-  virtual uint32 max_length()= 0;
+  virtual uint32 max_display_length()= 0;
   /* convert decimal to longlong with overflow check */
   longlong convert_decimal2longlong(const my_decimal *val, bool unsigned_flag,
                                     int *err);
@@ -389,12 +389,12 @@ public:
   int  store(const char *to,uint length,CHARSET_INFO *cs)=0;
   uint size_of() const { return sizeof(*this); }
   CHARSET_INFO *charset(void) const { return field_charset; }
-  void set_charset(CHARSET_INFO *charset) { field_charset=charset; }
+  void set_charset(CHARSET_INFO *charset_arg) { field_charset= charset_arg; }
   enum Derivation derivation(void) const { return field_derivation; }
   virtual void set_derivation(enum Derivation derivation_arg)
   { field_derivation= derivation_arg; }
   bool binary() const { return field_charset == &my_charset_bin; }
-  uint32 max_length() { return field_length; }
+  uint32 max_display_length() { return field_length; }
   friend class create_field;
   my_decimal *val_decimal(my_decimal *);
 };
@@ -408,9 +408,9 @@ public:
   Field_longstr(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
                 uchar null_bit_arg, utype unireg_check_arg,
                 const char *field_name_arg,
-                struct st_table *table_arg,CHARSET_INFO *charset)
+                struct st_table *table_arg, CHARSET_INFO *charset_arg)
     :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
-               field_name_arg, table_arg, charset)
+               field_name_arg, table_arg, charset_arg)
     {}
 
   int store_decimal(const my_decimal *d);
@@ -461,7 +461,7 @@ public:
   void overflow(bool negative);
   bool zero_pack() const { return 0; }
   void sql_type(String &str) const;
-  uint32 max_length() { return field_length; }
+  uint32 max_display_length() { return field_length; }
 };
 
 
@@ -505,7 +505,7 @@ public:
   void sort_string(char *buff, uint length);
   bool zero_pack() const { return 0; }
   void sql_type(String &str) const;
-  uint32 max_length() { return field_length; }
+  uint32 max_display_length() { return field_length; }
   uint size_of() const { return sizeof(*this); } 
   uint32 pack_length() const { return (uint32) bin_size; }
 };
@@ -538,7 +538,7 @@ public:
   void sort_string(char *buff,uint length);
   uint32 pack_length() const { return 1; }
   void sql_type(String &str) const;
-  uint32 max_length() { return 4; }
+  uint32 max_display_length() { return 4; }
 };
 
 
@@ -574,7 +574,7 @@ public:
   void sort_string(char *buff,uint length);
   uint32 pack_length() const { return 2; }
   void sql_type(String &str) const;
-  uint32 max_length() { return 6; }
+  uint32 max_display_length() { return 6; }
 };
 
 
@@ -605,7 +605,7 @@ public:
   void sort_string(char *buff,uint length);
   uint32 pack_length() const { return 3; }
   void sql_type(String &str) const;
-  uint32 max_length() { return 8; }
+  uint32 max_display_length() { return 8; }
 };
 
 
@@ -641,7 +641,7 @@ public:
   void sort_string(char *buff,uint length);
   uint32 pack_length() const { return 4; }
   void sql_type(String &str) const;
-  uint32 max_length() { return 11; }
+  uint32 max_display_length() { return 11; }
 };
 
 
@@ -684,7 +684,7 @@ public:
   uint32 pack_length() const { return 8; }
   void sql_type(String &str) const;
   bool can_be_compared_as_longlong() const { return TRUE; }
-  uint32 max_length() { return 20; }
+  uint32 max_display_length() { return 20; }
 };
 #endif
 
@@ -719,7 +719,7 @@ public:
   void sort_string(char *buff,uint length);
   uint32 pack_length() const { return sizeof(float); }
   void sql_type(String &str) const;
-  uint32 max_length() { return 24; }
+  uint32 max_display_length() { return 24; }
 };
 
 
@@ -762,7 +762,7 @@ public:
   void sort_string(char *buff,uint length);
   uint32 pack_length() const { return sizeof(double); }
   void sql_type(String &str) const;
-  uint32 max_length() { return 53; }
+  uint32 max_display_length() { return 53; }
   uint size_of() const { return sizeof(*this); }
 };
 
@@ -795,7 +795,7 @@ public:
   uint32 pack_length() const { return 0; }
   void sql_type(String &str) const;
   uint size_of() const { return sizeof(*this); }
-  uint32 max_length() { return 4; }
+  uint32 max_display_length() { return 4; }
 };
 
 
@@ -1175,10 +1175,10 @@ public:
     packlength= 4;
     if (set_packlength)
     {
-      uint32 char_length= len_arg/cs->mbmaxlen;
-      packlength= char_length <= 255 ? 1 :
-                  char_length <= 65535 ? 2 :
-                  char_length <= 16777215 ? 3 : 4;
+      uint32 l_char_length= len_arg/cs->mbmaxlen;
+      packlength= l_char_length <= 255 ? 1 :
+                  l_char_length <= 65535 ? 2 :
+                  l_char_length <= 16777215 ? 3 : 4;
     }
   }
   enum_field_types type() const { return FIELD_TYPE_BLOB;}
@@ -1256,7 +1256,7 @@ public:
   uint size_of() const { return sizeof(*this); }
   bool has_charset(void) const
   { return charset() == &my_charset_bin ? FALSE : TRUE; }
-  uint32 max_length();
+  uint32 max_display_length();
 };
 
 
@@ -1374,7 +1374,7 @@ public:
   enum_field_types type() const { return FIELD_TYPE_BIT; }
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_BIT; }
   uint32 key_length() const { return (uint32) (field_length + 7) / 8; }
-  uint32 max_length() { return field_length; }
+  uint32 max_display_length() { return field_length; }
   uint size_of() const { return sizeof(*this); }
   Item_result result_type () const { return INT_RESULT; }
   int reset(void) { bzero(ptr, bytes_in_rec); return 0; }
diff --git a/sql/filesort.cc b/sql/filesort.cc
index 73f480aad02..e40c492fe8e 100644
--- a/sql/filesort.cc
+++ b/sql/filesort.cc
@@ -98,7 +98,7 @@ ha_rows filesort(THD *thd, TABLE *table, SORT_FIELD *sortorder, uint s_length,
   uint maxbuffer;
   BUFFPEK *buffpek;
   ha_rows records= HA_POS_ERROR;
-  uchar **sort_keys;
+  uchar **sort_keys= 0;
   IO_CACHE tempfile, buffpek_pointers, *selected_records_file, *outfile; 
   SORTPARAM param;
   bool multi_byte_charset;
@@ -857,12 +857,14 @@ static void make_sortkey(register SORTPARAM *param,
       }
       else
       {
-        uchar *end= (uchar*) field->pack((char *) to, field->ptr);
 #ifdef HAVE_purify
+        uchar *end= (uchar*) field->pack((char *) to, field->ptr);
 	uint length= (uint) ((to + addonf->length) - end);
 	DBUG_ASSERT((int) length >= 0);
 	if (length)
 	  bzero(end, length);
+#else
+        (void) field->pack((char *) to, field->ptr);
 #endif
       }
       to+= addonf->length;
diff --git a/sql/ha_archive.cc b/sql/ha_archive.cc
index 0f714cc2008..2ee514f29c9 100644
--- a/sql/ha_archive.cc
+++ b/sql/ha_archive.cc
@@ -379,10 +379,8 @@ int ha_archive::write_meta_file(File meta_file, ha_rows rows, bool dirty)
 
   See ha_example.cc for a longer description.
 */
-ARCHIVE_SHARE *ha_archive::get_share(const char *table_name, 
-                                     TABLE *table, int *rc)
+ARCHIVE_SHARE *ha_archive::get_share(const char *table_name, int *rc)
 {
-  ARCHIVE_SHARE *share;
   char meta_file_name[FN_REFLEN];
   uint length;
   char *tmp_name;
@@ -410,8 +408,10 @@ ARCHIVE_SHARE *ha_archive::get_share(const char *table_name,
     share->table_name= tmp_name;
     share->crashed= FALSE;
     share->archive_write_open= FALSE;
-    fn_format(share->data_file_name,table_name,"",ARZ,MY_REPLACE_EXT|MY_UNPACK_FILENAME);
-    fn_format(meta_file_name,table_name,"",ARM,MY_REPLACE_EXT|MY_UNPACK_FILENAME);
+    fn_format(share->data_file_name,table_name,"",ARZ,
+              MY_REPLACE_EXT|MY_UNPACK_FILENAME);
+    fn_format(meta_file_name,table_name,"",ARM,
+              MY_REPLACE_EXT|MY_UNPACK_FILENAME);
     strmov(share->table_name,table_name);
     /*
       We will use this lock for rows.
@@ -447,7 +447,7 @@ ARCHIVE_SHARE *ha_archive::get_share(const char *table_name,
   Free the share.
   See ha_example.cc for a description.
 */
-int ha_archive::free_share(ARCHIVE_SHARE *share)
+int ha_archive::free_share()
 {
   int rc= 0;
   DBUG_ENTER("ha_archive::free_share");
@@ -527,12 +527,14 @@ int ha_archive::open(const char *name, int mode, uint open_options)
 
   DBUG_PRINT("info", ("archive table was opened for crash %s", 
                       (open_options & HA_OPEN_FOR_REPAIR) ? "yes" : "no"));
-  share= get_share(name, table, &rc);
+  share= get_share(name, &rc);
 
   if (rc == HA_ERR_CRASHED_ON_USAGE && !(open_options & HA_OPEN_FOR_REPAIR))
   {
-    free_share(share);
+    /* purecov: begin inspected */
+    free_share();
     DBUG_RETURN(rc);
+    /* purecov: end */    
   }
   else if (rc == HA_ERR_OUT_OF_MEM)
   {
@@ -585,7 +587,7 @@ int ha_archive::close(void)
   if (gzclose(archive) == Z_ERRNO)
     rc= 1;
   /* then also close share */
-  rc|= free_share(share);
+  rc|= free_share();
 
   DBUG_RETURN(rc);
 }
@@ -747,10 +749,12 @@ int ha_archive::write_row(byte *buf)
     DBUG_PRINT("archive",("MyPack is %d\n", (*field)->data_length((char*) buf + (*field)->offset())));
     if ((*field)->real_type() == MYSQL_TYPE_VARCHAR) 
     {
+#ifndef DBUG_OFF
       uint actual_length= (*field)->data_length((char*) buf + (*field)->offset());
       uint offset= (*field)->offset() + actual_length + 
         (actual_length > 255 ? 2 : 1);
       DBUG_PRINT("archive",("Offset is %d -> %d\n", actual_length, offset));
+#endif
       /*
       if ((*field)->pack_length() + (*field)->offset() != offset)
         bzero(buf + offset, (size_t)((*field)->pack_length() + (actual_length > 255 ? 2 : 1) - (*field)->data_length));
diff --git a/sql/ha_archive.h b/sql/ha_archive.h
index 54d0be69441..76765b98bc9 100644
--- a/sql/ha_archive.h
+++ b/sql/ha_archive.h
@@ -86,8 +86,8 @@ public:
   int get_row(gzFile file_to_read, byte *buf);
   int read_meta_file(File meta_file, ha_rows *rows);
   int write_meta_file(File meta_file, ha_rows rows, bool dirty);
-  ARCHIVE_SHARE *get_share(const char *table_name, TABLE *table, int *rc);
-  int free_share(ARCHIVE_SHARE *share);
+  ARCHIVE_SHARE *get_share(const char *table_name, int *rc);
+  int free_share();
   int init_archive_writer();
   bool auto_repair() const { return 1; } // For the moment we just do this
   int read_data_header(gzFile file_to_read);
diff --git a/sql/ha_berkeley.cc b/sql/ha_berkeley.cc
index d63935f1a9c..2a5fe775ca6 100644
--- a/sql/ha_berkeley.cc
+++ b/sql/ha_berkeley.cc
@@ -233,6 +233,7 @@ static int berkeley_close_connection(THD *thd)
   return 0;
 }
 
+
 bool berkeley_flush_logs()
 {
   int error;
@@ -439,6 +440,15 @@ ulong ha_berkeley::index_flags(uint idx, uint part, bool all_parts) const
 }
 
 
+void ha_berkeley::get_auto_primary_key(byte *to)
+{
+  pthread_mutex_lock(&share->mutex);
+  share->auto_ident++;
+  int5store(to,share->auto_ident);
+  pthread_mutex_unlock(&share->mutex);
+}
+
+
 static int
 berkeley_cmp_hidden_key(DB* file, const DBT *new_key, const DBT *saved_key)
 {
@@ -797,7 +807,7 @@ int ha_berkeley::pack_row(DBT *row, const byte *record, bool new_row)
     ptr+=BDB_HIDDEN_PRIMARY_KEY_LENGTH;
   }
   row->data=rec_buff;
-  row->size= (size_t) (ptr - rec_buff);
+  row->size= (u_int32_t) (ptr - rec_buff);
   return 0;
 }
 
@@ -892,7 +902,7 @@ DBT *ha_berkeley::create_key(DBT *key, uint keynr, char *buff,
 				   key_part->length);
     key_length-=key_part->length;
   }
-  key->size= (buff  - (char*) key->data);
+  key->size= (u_int32_t) (buff  - (char*) key->data);
   DBUG_DUMP("key",(char*) key->data, key->size);
   DBUG_RETURN(key);
 }
@@ -936,7 +946,7 @@ DBT *ha_berkeley::pack_key(DBT *key, uint keynr, char *buff,
     key_ptr+=key_part->store_length;
     key_length-=key_part->store_length;
   }
-  key->size= (buff  - (char*) key->data);
+  key->size= (u_int32_t) (buff  - (char*) key->data);
   DBUG_DUMP("key",(char*) key->data, key->size);
   DBUG_RETURN(key);
 }
diff --git a/sql/ha_berkeley.h b/sql/ha_berkeley.h
index 051990b0ee5..336c90f009a 100644
--- a/sql/ha_berkeley.h
+++ b/sql/ha_berkeley.h
@@ -141,13 +141,7 @@ class ha_berkeley: public handler
 			     enum thr_lock_type lock_type);
 
   void get_status();
-  inline void get_auto_primary_key(byte *to)
-  {
-    pthread_mutex_lock(&share->mutex);
-    share->auto_ident++;
-    int5store(to,share->auto_ident);
-    pthread_mutex_unlock(&share->mutex);
-  }
+  void get_auto_primary_key(byte *to);
   ulonglong get_auto_increment();
   void print_error(int error, myf errflag);
   uint8 table_cache_type() { return HA_CACHE_TBL_TRANSACT; }
diff --git a/sql/ha_blackhole.cc b/sql/ha_blackhole.cc
index 61a8658be53..3f4285ec595 100644
--- a/sql/ha_blackhole.cc
+++ b/sql/ha_blackhole.cc
@@ -180,7 +180,7 @@ int ha_blackhole::index_read(byte * buf, const byte * key,
                              uint key_len, enum ha_rkey_function find_flag)
 {
   DBUG_ENTER("ha_blackhole::index_read");
-  DBUG_RETURN(0);
+  DBUG_RETURN(HA_ERR_END_OF_FILE);
 }
 
 
diff --git a/sql/ha_federated.cc b/sql/ha_federated.cc
index 6508216e3d6..dd4dd725be4 100644
--- a/sql/ha_federated.cc
+++ b/sql/ha_federated.cc
@@ -1096,7 +1096,7 @@ bool ha_federated::create_where_from_key(String *to,
                                          KEY *key_info,
                                          const key_range *start_key,
                                          const key_range *end_key,
-                                         bool records_in_range)
+                                         bool from_records_in_range)
 {
   bool both_not_null= 
     (start_key != NULL && end_key != NULL) ? TRUE : FALSE;
@@ -1164,7 +1164,7 @@ bool ha_federated::create_where_from_key(String *to,
           if (emit_key_part_name(&tmp, key_part))
             DBUG_RETURN(1);
 
-          if (records_in_range)
+          if (from_records_in_range)
           {
             if (tmp.append(FEDERATED_GE))
               DBUG_RETURN(1);
@@ -1383,7 +1383,7 @@ static int free_share(FEDERATED_SHARE *share)
 
 
 ha_rows ha_federated::records_in_range(uint inx, key_range *start_key,
-                                   key_range *end_key)
+                                       key_range *end_key)
 {
   /*
 
@@ -2072,7 +2072,7 @@ int ha_federated::index_init(uint keynr)
 
 int ha_federated::read_range_first(const key_range *start_key,
                                    const key_range *end_key,
-                                   bool eq_range, bool sorted)
+                                   bool eq_range_arg, bool sorted)
 {
   char sql_query_buffer[FEDERATED_QUERY_BUFFER_SIZE];
   int retval;
diff --git a/sql/ha_heap.cc b/sql/ha_heap.cc
index fe5e8b76ec9..d1a931b07f2 100644
--- a/sql/ha_heap.cc
+++ b/sql/ha_heap.cc
@@ -317,11 +317,11 @@ int ha_heap::rnd_next(byte *buf)
 int ha_heap::rnd_pos(byte * buf, byte *pos)
 {
   int error;
-  HEAP_PTR position;
+  HEAP_PTR heap_position;
   statistic_increment(table->in_use->status_var.ha_read_rnd_count,
 		      &LOCK_status);
-  memcpy_fixed((char*) &position,pos,sizeof(HEAP_PTR));
-  error=heap_rrnd(file, buf, position);
+  memcpy_fixed((char*) &heap_position, pos, sizeof(HEAP_PTR));
+  error=heap_rrnd(file, buf, heap_position);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
@@ -333,19 +333,19 @@ void ha_heap::position(const byte *record)
 
 int ha_heap::info(uint flag)
 {
-  HEAPINFO info;
-  (void) heap_info(file,&info,flag);
-
-  records = info.records;
-  deleted = info.deleted;
-  errkey  = info.errkey;
-  mean_rec_length=info.reclength;
-  data_file_length=info.data_length;
-  index_file_length=info.index_length;
-  max_data_file_length= info.max_records* info.reclength;
-  delete_length= info.deleted * info.reclength;
+  HEAPINFO hp_info;
+  (void) heap_info(file,&hp_info,flag);
+
+  records= hp_info.records;
+  deleted= hp_info.deleted;
+  errkey=  hp_info.errkey;
+  mean_rec_length= hp_info.reclength;
+  data_file_length= hp_info.data_length;
+  index_file_length= hp_info.index_length;
+  max_data_file_length= hp_info.max_records* hp_info.reclength;
+  delete_length= hp_info.deleted * hp_info.reclength;
   if (flag & HA_STATUS_AUTO)
-    auto_increment_value= info.auto_increment;
+    auto_increment_value= hp_info.auto_increment;
   /*
     If info() is called for the first time after open(), we will still
     have to update the key statistics. Hoping that a table lock is now
diff --git a/sql/ha_innodb.cc b/sql/ha_innodb.cc
index d854c362df8..8a35ff000a8 100644
--- a/sql/ha_innodb.cc
+++ b/sql/ha_innodb.cc
@@ -2711,7 +2711,8 @@ ha_innobase::store_key_val_for_row(
 				true_len = (ulint) cs->cset->well_formed_len(cs,
 						(const char *) data,
 						(const char *) data + len,
-						key_len / cs->mbmaxlen,
+                                                (uint) (key_len /
+                                                        cs->mbmaxlen),
 						&error);
 			}
 
@@ -2780,7 +2781,8 @@ ha_innobase::store_key_val_for_row(
 						(const char *) blob_data,
 						(const char *) blob_data
 							+ blob_len,
-						key_len / cs->mbmaxlen,
+                                                (uint) (key_len /
+                                                        cs->mbmaxlen),
 						&error);
 			}
 
@@ -2852,7 +2854,8 @@ ha_innobase::store_key_val_for_row(
 							(const char *)src_start,
 							(const char *)src_start
 								+ key_len,
-							key_len / cs->mbmaxlen,
+                                                        (uint) (key_len /
+                                                                cs->mbmaxlen),
 							&error);
 				}
 			}
diff --git a/sql/ha_myisam.cc b/sql/ha_myisam.cc
index 39f8894ae89..dd00c91e4af 100644
--- a/sql/ha_myisam.cc
+++ b/sql/ha_myisam.cc
@@ -930,11 +930,11 @@ int ha_myisam::optimize(THD* thd, HA_CHECK_OPT *check_opt)
 }
 
 
-int ha_myisam::repair(THD *thd, MI_CHECK &param, bool optimize)
+int ha_myisam::repair(THD *thd, MI_CHECK &param, bool do_optimize)
 {
   int error=0;
   uint local_testflag=param.testflag;
-  bool optimize_done= !optimize, statistics_done=0;
+  bool optimize_done= !do_optimize, statistics_done=0;
   const char *old_proc_info=thd->proc_info;
   char fixed_name[FN_REFLEN];
   MYISAM_SHARE* share = file->s;
@@ -958,7 +958,7 @@ int ha_myisam::repair(THD *thd, MI_CHECK &param, bool optimize)
     DBUG_RETURN(HA_ADMIN_FAILED);
   }
 
-  if (!optimize ||
+  if (!do_optimize ||
       ((file->state->del || share->state.split != file->state->records) &&
        (!(param.testflag & T_QUICK) ||
 	!(share->state.changed & STATE_NOT_OPTIMIZED_KEYS))))
@@ -1593,47 +1593,47 @@ int ha_myisam::rnd_pos(byte * buf, byte *pos)
 
 void ha_myisam::position(const byte* record)
 {
-  my_off_t position=mi_position(file);
-  my_store_ptr(ref, ref_length, position);
+  my_off_t row_position= mi_position(file);
+  my_store_ptr(ref, ref_length, row_position);
 }
 
 int ha_myisam::info(uint flag)
 {
-  MI_ISAMINFO info;
+  MI_ISAMINFO misam_info;
   char name_buff[FN_REFLEN];
 
-  (void) mi_status(file,&info,flag);
+  (void) mi_status(file,&misam_info,flag);
   if (flag & HA_STATUS_VARIABLE)
   {
-    records = info.records;
-    deleted = info.deleted;
-    data_file_length=info.data_file_length;
-    index_file_length=info.index_file_length;
-    delete_length = info.delete_length;
-    check_time  = info.check_time;
-    mean_rec_length=info.mean_reclength;
+    records=           misam_info.records;
+    deleted=           misam_info.deleted;
+    data_file_length=  misam_info.data_file_length;
+    index_file_length= misam_info.index_file_length;
+    delete_length=     misam_info.delete_length;
+    check_time=        misam_info.check_time;
+    mean_rec_length= misam_info.mean_reclength;
   }
   if (flag & HA_STATUS_CONST)
   {
     TABLE_SHARE *share= table->s;
-    max_data_file_length=  info.max_data_file_length;
-    max_index_file_length= info.max_index_file_length;
-    create_time= info.create_time;
-    sortkey= info.sortkey;
-    ref_length= info.reflength;
-    share->db_options_in_use= info.options;
+    max_data_file_length=  misam_info.max_data_file_length;
+    max_index_file_length= misam_info.max_index_file_length;
+    create_time= misam_info.create_time;
+    sortkey= misam_info.sortkey;
+    ref_length= misam_info.reflength;
+    share->db_options_in_use= misam_info.options;
     block_size= myisam_block_size;
     share->keys_in_use.set_prefix(share->keys);
-    share->keys_in_use.intersect_extended(info.key_map);
+    share->keys_in_use.intersect_extended(misam_info.key_map);
     share->keys_for_keyread.intersect(share->keys_in_use);
-    share->db_record_offset= info.record_offset;
+    share->db_record_offset= misam_info.record_offset;
     if (share->key_parts)
       memcpy((char*) table->key_info[0].rec_per_key,
-	     (char*) info.rec_per_key,
+	     (char*) misam_info.rec_per_key,
 	     sizeof(table->key_info[0].rec_per_key)*share->key_parts);
-    raid_type= info.raid_type;
-    raid_chunks= info.raid_chunks;
-    raid_chunksize= info.raid_chunksize;
+    raid_type= misam_info.raid_type;
+    raid_chunks= misam_info.raid_chunks;
+    raid_chunksize= misam_info.raid_chunksize;
 
    /*
      Set data_file_name and index_file_name to point at the symlink value
@@ -1641,21 +1641,21 @@ int ha_myisam::info(uint flag)
    */
     data_file_name=index_file_name=0;
     fn_format(name_buff, file->filename, "", MI_NAME_DEXT, 2);
-    if (strcmp(name_buff, info.data_file_name))
-      data_file_name=info.data_file_name;
+    if (strcmp(name_buff, misam_info.data_file_name))
+      data_file_name= misam_info.data_file_name;
     strmov(fn_ext(name_buff),MI_NAME_IEXT);
-    if (strcmp(name_buff, info.index_file_name))
-      index_file_name=info.index_file_name;
+    if (strcmp(name_buff, misam_info.index_file_name))
+      index_file_name= misam_info.index_file_name;
   }
   if (flag & HA_STATUS_ERRKEY)
   {
-    errkey  = info.errkey;
-    my_store_ptr(dupp_ref, ref_length, info.dupp_key_pos);
+    errkey  = misam_info.errkey;
+    my_store_ptr(dupp_ref, ref_length, misam_info.dupp_key_pos);
   }
   if (flag & HA_STATUS_TIME)
-    update_time = info.update_time;
+    update_time = misam_info.update_time;
   if (flag & HA_STATUS_AUTO)
-    auto_increment_value= info.auto_increment;
+    auto_increment_value= misam_info.auto_increment;
 
   return 0;
 }
@@ -1725,7 +1725,7 @@ void ha_myisam::update_create_info(HA_CREATE_INFO *create_info)
 
 
 int ha_myisam::create(const char *name, register TABLE *table_arg,
-		      HA_CREATE_INFO *info)
+		      HA_CREATE_INFO *ha_create_info)
 {
   int error;
   uint create_flags= 0, records;
@@ -1742,20 +1742,22 @@ int ha_myisam::create(const char *name, register TABLE *table_arg,
   create_info.max_rows= share->max_rows;
   create_info.reloc_rows= share->min_rows;
   create_info.with_auto_increment= share->next_number_key_offset == 0;
-  create_info.auto_increment= (info->auto_increment_value ?
-                               info->auto_increment_value -1 :
+  create_info.auto_increment= (ha_create_info->auto_increment_value ?
+                               ha_create_info->auto_increment_value -1 :
                                (ulonglong) 0);
   create_info.data_file_length= ((ulonglong) share->max_rows *
                                  share->avg_row_length);
-  create_info.raid_type= info->raid_type;
-  create_info.raid_chunks= (info->raid_chunks ? info->raid_chunks :
+  create_info.raid_type= ha_create_info->raid_type;
+  create_info.raid_chunks= (ha_create_info->raid_chunks ?
+                            ha_create_info->raid_chunks :
                             RAID_DEFAULT_CHUNKS);
-  create_info.raid_chunksize= (info->raid_chunksize ? info->raid_chunksize :
+  create_info.raid_chunksize= (ha_create_info->raid_chunksize ?
+                               ha_create_info->raid_chunksize :
                                RAID_DEFAULT_CHUNKSIZE);
-  create_info.data_file_name= info->data_file_name;
-  create_info.index_file_name= info->index_file_name;
+  create_info.data_file_name= ha_create_info->data_file_name;
+  create_info.index_file_name= ha_create_info->index_file_name;
 
-  if (info->options & HA_LEX_CREATE_TMP_TABLE)
+  if (ha_create_info->options & HA_LEX_CREATE_TMP_TABLE)
     create_flags|= HA_CREATE_TMP_TABLE;
   if (options & HA_OPTION_PACK_RECORD)
     create_flags|= HA_PACK_RECORD;
diff --git a/sql/ha_myisammrg.cc b/sql/ha_myisammrg.cc
index 8e24164abc9..1202a733a16 100644
--- a/sql/ha_myisammrg.cc
+++ b/sql/ha_myisammrg.cc
@@ -299,8 +299,8 @@ int ha_myisammrg::rnd_pos(byte * buf, byte *pos)
 
 void ha_myisammrg::position(const byte *record)
 {
-  ulonglong position= myrg_position(file);
-  my_store_ptr(ref, ref_length, (my_off_t) position);
+  ulonglong row_position= myrg_position(file);
+  my_store_ptr(ref, ref_length, (my_off_t) row_position);
 }
 
 
@@ -313,25 +313,25 @@ ha_rows ha_myisammrg::records_in_range(uint inx, key_range *min_key,
 
 int ha_myisammrg::info(uint flag)
 {
-  MYMERGE_INFO info;
-  (void) myrg_status(file,&info,flag);
+  MYMERGE_INFO mrg_info;
+  (void) myrg_status(file,&mrg_info,flag);
   /*
     The following fails if one has not compiled MySQL with -DBIG_TABLES
     and one has more than 2^32 rows in the merge tables.
   */
-  records = (ha_rows) info.records;
-  deleted = (ha_rows) info.deleted;
+  records = (ha_rows) mrg_info.records;
+  deleted = (ha_rows) mrg_info.deleted;
 #if !defined(BIG_TABLES) || SIZEOF_OFF_T == 4
-  if ((info.records >= (ulonglong) 1 << 32) ||
-      (info.deleted >= (ulonglong) 1 << 32))
+  if ((mrg_info.records >= (ulonglong) 1 << 32) ||
+      (mrg_info.deleted >= (ulonglong) 1 << 32))
     table->s->crashed= 1;
 #endif
-  data_file_length=info.data_file_length;
-  errkey  = info.errkey;
+  data_file_length=mrg_info.data_file_length;
+  errkey  = mrg_info.errkey;
   table->s->keys_in_use.set_prefix(table->s->keys);
-  table->s->db_options_in_use= info.options;
+  table->s->db_options_in_use= mrg_info.options;
   table->s->is_view= 1;
-  mean_rec_length= info.reclength;
+  mean_rec_length= mrg_info.reclength;
   
   /* 
     The handler::block_size is used all over the code in index scan cost
@@ -361,7 +361,7 @@ int ha_myisammrg::info(uint flag)
 #endif
   if (flag & HA_STATUS_CONST)
   {
-    if (table->s->key_parts && info.rec_per_key)
+    if (table->s->key_parts && mrg_info.rec_per_key)
     {
 #ifdef HAVE_purify
       /*
@@ -374,7 +374,7 @@ int ha_myisammrg::info(uint flag)
             sizeof(table->key_info[0].rec_per_key) * table->s->key_parts);
 #endif
       memcpy((char*) table->key_info[0].rec_per_key,
-	     (char*) info.rec_per_key,
+	     (char*) mrg_info.rec_per_key,
              sizeof(table->key_info[0].rec_per_key) *
              min(file->keys, table->s->key_parts));
     }
diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc
index 4f753ccea79..7a9c7d0d021 100644
--- a/sql/ha_ndbcluster.cc
+++ b/sql/ha_ndbcluster.cc
@@ -361,11 +361,11 @@ int ha_ndbcluster::records_update()
   DBUG_ENTER("ha_ndbcluster::records_update");
   int result= 0;
 
-  struct Ndb_local_table_statistics *info= 
+  struct Ndb_local_table_statistics *local_info= 
     (struct Ndb_local_table_statistics *)m_table_info;
   DBUG_PRINT("info", ("id=%d, no_uncommitted_rows_count=%d",
                       ((const NDBTAB *)m_table)->getTableId(),
-                      info->no_uncommitted_rows_count));
+                      local_info->no_uncommitted_rows_count));
   //  if (info->records == ~(ha_rows)0)
   {
     Ndb *ndb= get_ndb();
@@ -376,16 +376,16 @@ int ha_ndbcluster::records_update()
     {
       mean_rec_length= stat.row_size;
       data_file_length= stat.fragment_memory;
-      info->records= stat.row_count;
+      local_info->records= stat.row_count;
     }
   }
   {
     THD *thd= current_thd;
     if (get_thd_ndb(thd)->error)
-      info->no_uncommitted_rows_count= 0;
+      local_info->no_uncommitted_rows_count= 0;
   }
   if(result==0)
-    records= info->records+ info->no_uncommitted_rows_count;
+    records= local_info->records+ local_info->no_uncommitted_rows_count;
   DBUG_RETURN(result);
 }
 
@@ -403,17 +403,17 @@ void ha_ndbcluster::no_uncommitted_rows_init(THD *thd)
   if (m_ha_not_exact_count)
     return;
   DBUG_ENTER("ha_ndbcluster::no_uncommitted_rows_init");
-  struct Ndb_local_table_statistics *info= 
+  struct Ndb_local_table_statistics *local_info= 
     (struct Ndb_local_table_statistics *)m_table_info;
   Thd_ndb *thd_ndb= get_thd_ndb(thd);
-  if (info->last_count != thd_ndb->count)
+  if (local_info->last_count != thd_ndb->count)
   {
-    info->last_count= thd_ndb->count;
-    info->no_uncommitted_rows_count= 0;
-    info->records= ~(ha_rows)0;
+    local_info->last_count= thd_ndb->count;
+    local_info->no_uncommitted_rows_count= 0;
+    local_info->records= ~(ha_rows)0;
     DBUG_PRINT("info", ("id=%d, no_uncommitted_rows_count=%d",
                         ((const NDBTAB *)m_table)->getTableId(),
-                        info->no_uncommitted_rows_count));
+                        local_info->no_uncommitted_rows_count));
   }
   DBUG_VOID_RETURN;
 }
@@ -423,12 +423,12 @@ void ha_ndbcluster::no_uncommitted_rows_update(int c)
   if (m_ha_not_exact_count)
     return;
   DBUG_ENTER("ha_ndbcluster::no_uncommitted_rows_update");
-  struct Ndb_local_table_statistics *info=
+  struct Ndb_local_table_statistics *local_info=
     (struct Ndb_local_table_statistics *)m_table_info;
-  info->no_uncommitted_rows_count+= c;
+  local_info->no_uncommitted_rows_count+= c;
   DBUG_PRINT("info", ("id=%d, no_uncommitted_rows_count=%d",
                       ((const NDBTAB *)m_table)->getTableId(),
-                      info->no_uncommitted_rows_count));
+                      local_info->no_uncommitted_rows_count));
   DBUG_VOID_RETURN;
 }
 
@@ -1736,7 +1736,7 @@ int ha_ndbcluster::unique_index_read(const byte *key,
 inline int ha_ndbcluster::fetch_next(NdbScanOperation* cursor)
 {
   DBUG_ENTER("fetch_next");
-  int check;
+  int local_check;
   NdbTransaction *trans= m_active_trans;
   
     if (m_lock_tuple)
@@ -1747,15 +1747,17 @@ inline int ha_ndbcluster::fetch_next(NdbScanOperation* cursor)
       LOCK WITH SHARE MODE) and row was not explictly unlocked 
       with unlock_row() call
     */
-      NdbConnection *trans= m_active_trans;
+      NdbConnection *con_trans= m_active_trans;
       NdbOperation *op;
       // Lock row
       DBUG_PRINT("info", ("Keeping lock on scanned row"));
       
       if (!(op= m_active_cursor->lockCurrentTuple()))
       {
+        /* purecov: begin inspected */
 	m_lock_tuple= false;
-	ERR_RETURN(trans->getNdbError());
+	ERR_RETURN(con_trans->getNdbError());
+        /* purecov: end */    
       }
       m_ops_pending++;
   }
@@ -1776,7 +1778,7 @@ inline int ha_ndbcluster::fetch_next(NdbScanOperation* cursor)
       m_blobs_pending= FALSE;
     }
     
-    if ((check= cursor->nextResult(contact_ndb, m_force_send)) == 0)
+    if ((local_check= cursor->nextResult(contact_ndb, m_force_send)) == 0)
     {
       /*
 	Explicitly lock tuple if "select for update" or
@@ -1787,7 +1789,7 @@ inline int ha_ndbcluster::fetch_next(NdbScanOperation* cursor)
 		     m_lock.type == TL_READ_WITH_SHARED_LOCKS);
       DBUG_RETURN(0);
     } 
-    else if (check == 1 || check == 2)
+    else if (local_check == 1 || local_check == 2)
     {
       // 1: No more records
       // 2: No more cached records
@@ -1817,13 +1819,13 @@ inline int ha_ndbcluster::fetch_next(NdbScanOperation* cursor)
         }
         m_ops_pending= 0;
       }
-      contact_ndb= (check == 2);
+      contact_ndb= (local_check == 2);
     }
     else
     {
       DBUG_RETURN(-1);
     }
-  } while (check == 2);
+  } while (local_check == 2);
 
   DBUG_RETURN(1);
 }
@@ -2189,8 +2191,7 @@ int ha_ndbcluster::write_row(byte *record)
   NdbTransaction *trans= m_active_trans;
   NdbOperation *op;
   int res;
-  THD *thd= current_thd;
-
+  THD *thd= table->in_use;
   DBUG_ENTER("write_row");
 
   has_auto_increment= (table->next_number_field && record == table->record[0]);
@@ -2201,7 +2202,6 @@ int ha_ndbcluster::write_row(byte *record)
      */
     if (has_auto_increment) 
     {
-      THD *thd= table->in_use;
       int error;
       
       m_skip_auto_increment= FALSE;
@@ -2263,8 +2263,6 @@ int ha_ndbcluster::write_row(byte *record)
   } 
   else 
   {
-    int res;
-
     if ((res= set_primary_key_from_record(op, record)))
       return res;  
   }
@@ -2333,10 +2331,12 @@ int ha_ndbcluster::write_row(byte *record)
   {
     Ndb *ndb= get_ndb();
     Uint64 next_val= (Uint64) table->next_number_field->val_int() + 1;
+#ifndef DBUG_OFF
     char buff[22];
     DBUG_PRINT("info", 
                ("Trying to set next auto increment value to %s",
                 llstr(next_val, buff)));
+#endif
     if (ndb->setAutoIncrementValue((const NDBTAB *) m_table, next_val, TRUE)
         == -1)
       ERR_RETURN(ndb->getNdbError());
@@ -2702,8 +2702,6 @@ void ha_ndbcluster::print_results()
   DBUG_ENTER("print_results");
 
 #ifndef DBUG_OFF
-  const NDBTAB *tab= (const NDBTAB*) m_table;
-
   if (!_db_on_)
     DBUG_VOID_RETURN;
 
@@ -3243,7 +3241,7 @@ int ha_ndbcluster::info(uint flag)
   if (flag & HA_STATUS_AUTO)
   {
     DBUG_PRINT("info", ("HA_STATUS_AUTO"));
-    if (m_table)
+    if (m_table && table->found_next_number_field)
     {
       Ndb *ndb= get_ndb();
       
@@ -3494,7 +3492,7 @@ int ha_ndbcluster::end_bulk_insert()
       }
       else
       {
-        int res= trans->restart();
+        IF_DBUG(int res=) trans->restart();
         DBUG_ASSERT(res == 0);
       }
     }
@@ -4261,7 +4259,9 @@ static int create_ndb_column(NDBCOL &col,
   // Set autoincrement
   if (field->flags & AUTO_INCREMENT_FLAG) 
   {
+#ifndef DBUG_OFF
     char buff[22];
+#endif
     col.setAutoIncrement(TRUE);
     ulonglong value= info->auto_increment_value ?
       info->auto_increment_value : (ulonglong) 1;
@@ -4335,14 +4335,14 @@ static void ndb_set_fragmentation(NDBTAB &tab, TABLE *form, uint pk_length)
 
 int ha_ndbcluster::create(const char *name, 
                           TABLE *form, 
-                          HA_CREATE_INFO *info)
+                          HA_CREATE_INFO *create_info)
 {
   NDBTAB tab;
   NDBCOL col;
   uint pack_length, length, i, pk_length= 0;
   const void *data, *pack_data;
   char name2[FN_HEADLEN];
-  bool create_from_engine= (info->table_options & HA_OPTION_CREATE_FROM_ENGINE);
+  bool create_from_engine= (create_info->table_options & HA_OPTION_CREATE_FROM_ENGINE);
 
   DBUG_ENTER("ha_ndbcluster::create");
   DBUG_PRINT("enter", ("name: %s", name));
@@ -4369,7 +4369,7 @@ int ha_ndbcluster::create(const char *name,
 
   DBUG_PRINT("table", ("name: %s", m_tabname));  
   tab.setName(m_tabname);
-  tab.setLogging(!(info->options & HA_LEX_CREATE_TMP_TABLE));    
+  tab.setLogging(!(create_info->options & HA_LEX_CREATE_TMP_TABLE));    
    
   // Save frm data for this table
   if (readfrm(name, &data, &length))
@@ -4388,7 +4388,7 @@ int ha_ndbcluster::create(const char *name,
     DBUG_PRINT("info", ("name: %s, type: %u, pack_length: %d", 
                         field->field_name, field->real_type(),
                         field->pack_length()));
-    if ((my_errno= create_ndb_column(col, field, info)))
+    if ((my_errno= create_ndb_column(col, field, create_info)))
       DBUG_RETURN(my_errno);
     tab.addColumn(col);
     if (col.getPrimaryKey())
@@ -4423,13 +4423,13 @@ int ha_ndbcluster::create(const char *name,
     case MYSQL_TYPE_MEDIUM_BLOB:   
     case MYSQL_TYPE_LONG_BLOB: 
     {
-      NdbDictionary::Column * col= tab.getColumn(i);
-      int size= pk_length + (col->getPartSize()+3)/4 + 7;
+      NdbDictionary::Column * column= tab.getColumn(i);
+      int size= pk_length + (column->getPartSize()+3)/4 + 7;
       if (size > NDB_MAX_TUPLE_SIZE_IN_WORDS && 
          (pk_length+7) < NDB_MAX_TUPLE_SIZE_IN_WORDS)
       {
         size= NDB_MAX_TUPLE_SIZE_IN_WORDS - pk_length - 7;
-        col->setPartSize(4*size);
+        column->setPartSize(4*size);
       }
       /**
        * If size > NDB_MAX and pk_length+7 >= NDB_MAX
@@ -5684,7 +5684,9 @@ uint ndb_get_commitcount(THD *thd, char *dbname, char *tabname,
     if (share->commit_count != 0)
     {
       *commit_count= share->commit_count;
+#ifndef DBUG_OFF
       char buff[22];
+#endif
       DBUG_PRINT("info", ("Getting commit_count: %s from share",
                           llstr(share->commit_count, buff)));
       pthread_mutex_unlock(&share->mutex);
@@ -5710,7 +5712,9 @@ uint ndb_get_commitcount(THD *thd, char *dbname, char *tabname,
   pthread_mutex_lock(&share->mutex);
   if (share->commit_count_lock == lock)
   {
+#ifndef DBUG_OFF
     char buff[22];
+#endif
     DBUG_PRINT("info", ("Setting commit_count to %s",
                         llstr(stat.commit_count, buff)));
     share->commit_count= stat.commit_count;
@@ -5766,7 +5770,9 @@ ndbcluster_cache_retrieval_allowed(THD *thd,
   bool is_autocommit= !(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN));
   char *dbname= full_name;
   char *tabname= dbname+strlen(dbname)+1;
+#ifndef DBUG_OFF
   char buff[22], buff2[22];
+#endif
   DBUG_ENTER("ndbcluster_cache_retrieval_allowed");
   DBUG_PRINT("enter", ("dbname: %s, tabname: %s, is_autocommit: %d",
                        dbname, tabname, is_autocommit));
@@ -5833,7 +5839,9 @@ ha_ndbcluster::register_query_cache_table(THD *thd,
                                           ulonglong *engine_data)
 {
   Uint64 commit_count;
+#ifndef DBUG_OFF
   char buff[22];
+#endif
   bool is_autocommit= !(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN));
   DBUG_ENTER("ha_ndbcluster::register_query_cache_table");
   DBUG_PRINT("enter",("dbname: %s, tabname: %s, is_autocommit: %d",
@@ -6040,7 +6048,9 @@ ndb_get_table_statistics(ha_ndbcluster* file, bool report_error, Ndb* ndb,
   int retries= 10;
   int reterr= 0;
   int retry_sleep= 30 * 1000; /* 30 milliseconds */
+#ifndef DBUG_OFF
   char buff[22], buff2[22], buff3[22], buff4[22];
+#endif
   DBUG_ENTER("ndb_get_table_statistics");
   DBUG_PRINT("enter", ("table: %s", table));
 
@@ -6054,7 +6064,6 @@ ndb_get_table_statistics(ha_ndbcluster* file, bool report_error, Ndb* ndb,
     Uint64 sum_row_size= 0;
     Uint64 sum_mem= 0;
     NdbScanOperation*pOp;
-    NdbResultSet *rs;
     int check;
 
     if ((pTrans= ndb->startTransaction()) == NULL)
@@ -6243,20 +6252,19 @@ ha_ndbcluster::read_multi_range_first(KEY_MULTI_RANGE **found_range_p,
                                       bool sorted, 
                                       HANDLER_BUFFER *buffer)
 {
-  DBUG_ENTER("ha_ndbcluster::read_multi_range_first");
-  
   int res;
   KEY* key_info= table->key_info + active_index;
-  NDB_INDEX_TYPE index_type= get_index_type(active_index);
+  NDB_INDEX_TYPE cur_index_type= get_index_type(active_index);
   ulong reclength= table->s->reclength;
   NdbOperation* op;
   Thd_ndb *thd_ndb= get_thd_ndb(current_thd);
+  DBUG_ENTER("ha_ndbcluster::read_multi_range_first");
 
   /**
    * blobs and unique hash index with NULL can't be batched currently
    */
   if (uses_blob_value(m_retrieve_all_fields) ||
-      (index_type ==  UNIQUE_INDEX &&
+      (cur_index_type == UNIQUE_INDEX &&
        has_null_in_unique_index(active_index) &&
        null_value_index_search(ranges, ranges+range_count, buffer)))
   {
@@ -6308,7 +6316,7 @@ ha_ndbcluster::read_multi_range_first(KEY_MULTI_RANGE **found_range_p,
   for (; multi_range_curr<multi_range_end && curr+reclength <= end_of_buffer; 
        multi_range_curr++)
   {
-    switch (index_type){
+    switch (cur_index_type) {
     case PRIMARY_KEY_ORDERED_INDEX:
       if (!(multi_range_curr->start_key.length == key_info->key_length &&
             multi_range_curr->start_key.flag == HA_READ_KEY_EXACT))
@@ -6666,6 +6674,9 @@ pthread_handler_t ndb_util_thread_func(void *arg __attribute__((unused)))
   for (;;)
   {
 
+    if (abort_loop)
+      break; /* Shutting down server */
+
     pthread_mutex_lock(&LOCK_ndb_util_thread);
     pthread_cond_timedwait(&COND_ndb_util_thread,
                            &LOCK_ndb_util_thread,
@@ -6728,7 +6739,9 @@ pthread_handler_t ndb_util_thread_func(void *arg __attribute__((unused)))
 
       if (ndb_get_table_statistics(NULL, false, ndb, tabname, &stat) == 0)
       {
+#ifndef DBUG_OFF
         char buff[22], buff2[22];
+#endif
         DBUG_PRINT("ndb_util_thread",
                    ("Table: %s  commit_count: %s  rows: %s",
                     share->table_name,
@@ -6896,14 +6909,14 @@ void ndb_serialize_cond(const Item *item, void *arg)
   
   if (context->supported)
   {
-    Ndb_rewrite_context *rewrite_context= context->rewrite_stack;
-    const Item_func *func_item;
+    Ndb_rewrite_context *rewrite_context2= context->rewrite_stack;
+    const Item_func *rewrite_func_item;
     // Check if we are rewriting some unsupported function call
-    if (rewrite_context &&
-        (func_item= rewrite_context->func_item) &&
-        rewrite_context->count++ == 0)
+    if (rewrite_context2 &&
+        (rewrite_func_item= rewrite_context2->func_item) &&
+        rewrite_context2->count++ == 0)
     {
-      switch (func_item->functype()) {
+      switch (rewrite_func_item->functype()) {
       case Item_func::BETWEEN:
         /*
           Rewrite 
@@ -6930,7 +6943,7 @@ void ndb_serialize_cond(const Item *item, void *arg)
         if (context->expecting(item->type()))
         {
           // This is the <field>|<const> item, save it in the rewrite context
-          rewrite_context->left_hand_item= item;
+          rewrite_context2->left_hand_item= item;
           if (item->type() == Item::FUNC_ITEM)
           {
             Item_func *func_item= (Item_func *) item;
@@ -7568,8 +7581,8 @@ void ndb_serialize_cond(const Item *item, void *arg)
           DBUG_PRINT("info", ("INT_ITEM"));
           if (context->expecting(Item::INT_ITEM)) 
           {
-            Item_int *int_item= (Item_int *) item;      
-            DBUG_PRINT("info", ("value %ld", (long) int_item->value));
+            DBUG_PRINT("info", ("value %ld",
+                                (long) ((Item_int*) item)->value));
             NDB_ITEM_QUALIFICATION q;
             q.value_type= Item::INT_ITEM;
             curr_cond->ndb_item= new Ndb_item(NDB_VALUE, q, item);
@@ -7595,8 +7608,7 @@ void ndb_serialize_cond(const Item *item, void *arg)
           DBUG_PRINT("info", ("REAL_ITEM"));
           if (context->expecting(Item::REAL_ITEM)) 
           {
-            Item_float *float_item= (Item_float *) item;      
-            DBUG_PRINT("info", ("value %f", float_item->value));
+            DBUG_PRINT("info", ("value %f", ((Item_float *) item)->value));
             NDB_ITEM_QUALIFICATION q;
             q.value_type= Item::REAL_ITEM;
             curr_cond->ndb_item= new Ndb_item(NDB_VALUE, q, item);
@@ -7643,8 +7655,8 @@ void ndb_serialize_cond(const Item *item, void *arg)
           DBUG_PRINT("info", ("DECIMAL_ITEM"));
           if (context->expecting(Item::DECIMAL_ITEM)) 
           {
-            Item_decimal *decimal_item= (Item_decimal *) item;      
-            DBUG_PRINT("info", ("value %f", decimal_item->val_real()));
+            DBUG_PRINT("info", ("value %f",
+                                ((Item_decimal*) item)->val_real()));
             NDB_ITEM_QUALIFICATION q;
             q.value_type= Item::DECIMAL_ITEM;
             curr_cond->ndb_item= new Ndb_item(NDB_VALUE, q, item);
@@ -7981,6 +7993,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond,
   DBUG_RETURN(1);
 }
 
+
 int
 ha_ndbcluster::build_scan_filter_group(Ndb_cond* &cond, NdbScanFilter *filter)
 {
@@ -8054,6 +8067,7 @@ ha_ndbcluster::build_scan_filter_group(Ndb_cond* &cond, NdbScanFilter *filter)
   DBUG_RETURN(0);
 }
 
+
 int
 ha_ndbcluster::build_scan_filter(Ndb_cond * &cond, NdbScanFilter *filter)
 {
@@ -8104,14 +8118,14 @@ ha_ndbcluster::generate_scan_filter(Ndb_cond_stack *ndb_cond_stack,
   DBUG_RETURN(0);
 }
 
+
 int
 ha_ndbcluster::generate_scan_filter_from_cond(Ndb_cond_stack *ndb_cond_stack,
 					      NdbScanFilter& filter)
 {
-  DBUG_ENTER("generate_scan_filter_from_cond");
   bool multiple_cond= FALSE;
-  
-  DBUG_PRINT("info", ("Generating scan filter"));
+  DBUG_ENTER("generate_scan_filter_from_cond");
+
   // Wrap an AND group around multiple conditions
   if (ndb_cond_stack->next) 
   {
@@ -8137,6 +8151,7 @@ ha_ndbcluster::generate_scan_filter_from_cond(Ndb_cond_stack *ndb_cond_stack,
   DBUG_RETURN(0);
 }
 
+
 int ha_ndbcluster::generate_scan_filter_from_key(NdbScanOperation *op,
 						 const KEY* key_info, 
 						 const byte *key, 
@@ -8147,15 +8162,14 @@ int ha_ndbcluster::generate_scan_filter_from_key(NdbScanOperation *op,
   KEY_PART_INFO* end= key_part+key_info->key_parts;
   NdbScanFilter filter(op);
   int res;
-
   DBUG_ENTER("generate_scan_filter_from_key");
+
   filter.begin(NdbScanFilter::AND);
   for (; key_part != end; key_part++) 
   {
     Field* field= key_part->field;
     uint32 pack_len= field->pack_length();
     const byte* ptr= key;
-    char buf[256];
     DBUG_PRINT("info", ("Filtering value for %s", field->field_name));
     DBUG_DUMP("key", (char*)ptr, pack_len);
     if (key_part->null_bit)
@@ -8190,7 +8204,6 @@ int
 ndbcluster_show_status(THD* thd)
 {
   Protocol *protocol= thd->protocol;
-  
   DBUG_ENTER("ndbcluster_show_status");
   
   if (have_ndbcluster != SHOW_OPTION_YES) 
diff --git a/sql/handler.cc b/sql/handler.cc
index c836c949f3a..5a27e470d70 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -121,11 +121,6 @@ handlerton isam_hton = { "ISAM", SHOW_OPTION_NO, "Obsolete storage engine",
   DB_TYPE_ISAM, NULL, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
   NULL, NULL, NULL, NULL, NULL, NULL, HTON_NO_FLAGS };
 
-
-/* static functions defined in this file */
-
-static SHOW_COMP_OPTION have_yes= SHOW_OPTION_YES;
-
 /* number of entries in handlertons[] */
 ulong total_ha;
 /* number of storage engines (from handlertons[]) that support 2pc */
@@ -713,7 +708,7 @@ int ha_commit_trans(THD *thd, bool all)
       }
       DBUG_EXECUTE_IF("crash_commit_after_prepare", abort(););
       if (error || (is_real_trans && xid &&
-                    (error= !(cookie= tc_log->log(thd, xid)))))
+                    (error= !(cookie= tc_log->log_xid(thd, xid)))))
       {
         ha_rollback_trans(thd, all);
         error= 1;
@@ -721,7 +716,7 @@ int ha_commit_trans(THD *thd, bool all)
       }
       DBUG_EXECUTE_IF("crash_commit_after_log", abort(););
     }
-    error=ha_commit_one_phase(thd, all) ? cookie ? 2 : 1 : 0;
+    error=ha_commit_one_phase(thd, all) ? (cookie ? 2 : 1) : 0;
     DBUG_EXECUTE_IF("crash_commit_before_unlog", abort(););
     if (cookie)
       tc_log->unlog(cookie, xid);
diff --git a/sql/item.cc b/sql/item.cc
index 050171b8fbe..92008a344ef 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -25,10 +25,6 @@
 #include "sql_trigger.h"
 #include "sql_select.h"
 
-static void mark_as_dependent(THD *thd,
-			      SELECT_LEX *last, SELECT_LEX *current,
-			      Item_ident *item);
-
 const String my_null_string("NULL", 4, default_charset_info);
 
 /****************************************************************************/
@@ -1525,6 +1521,8 @@ bool agg_item_charsets(DTCollation &coll, const char *fname,
       doesn't display each argument's characteristics.
     - if nargs is 1, then this error cannot happen.
   */
+  LINT_INIT(safe_args[0]);
+  LINT_INIT(safe_args[1]);
   if (nargs >=2 && nargs <= 3)
   {
     safe_args[0]= args[0];
@@ -1609,7 +1607,7 @@ void Item_ident_for_show::make_field(Send_field *tmp_field)
 Item_field::Item_field(Field *f)
   :Item_ident(0, NullS, *f->table_name, f->field_name),
   item_equal(0), no_const_subst(0),
-   have_privileges(0), any_privileges(0)
+   have_privileges(0), any_privileges(0), fixed_as_field(0)
 {
   set_field(f);
   /*
@@ -1623,7 +1621,7 @@ Item_field::Item_field(THD *thd, Name_resolution_context *context_arg,
                        Field *f)
   :Item_ident(context_arg, f->table->s->db, *f->table_name, f->field_name),
    item_equal(0), no_const_subst(0),
-   have_privileges(0), any_privileges(0)
+   have_privileges(0), any_privileges(0), fixed_as_field(0)
 {
   /*
     We always need to provide Item_field with a fully qualified field
@@ -1662,9 +1660,12 @@ Item_field::Item_field(Name_resolution_context *context_arg,
                        const char *field_name_arg)
   :Item_ident(context_arg, db_arg,table_name_arg,field_name_arg),
    field(0), result_field(0), item_equal(0), no_const_subst(0),
-   have_privileges(0), any_privileges(0)
+   have_privileges(0), any_privileges(0), fixed_as_field(0)
 {
+  SELECT_LEX *select= current_thd->lex->current_select;
   collation.set(DERIVATION_IMPLICIT);
+  if (select && select->parsing_place != IN_HAVING)
+      select->select_n_where_fields++;
 }
 
 // Constructor need to process subselect with temporary tables (see Item)
@@ -1675,7 +1676,8 @@ Item_field::Item_field(THD *thd, Item_field *item)
    item_equal(item->item_equal),
    no_const_subst(item->no_const_subst),
    have_privileges(item->have_privileges),
-   any_privileges(item->any_privileges)
+   any_privileges(item->any_privileges),
+   fixed_as_field(item->fixed_as_field)
 {
   collation.set(DERIVATION_IMPLICIT);
 }
@@ -1685,7 +1687,7 @@ void Item_field::set_field(Field *field_par)
   field=result_field=field_par;			// for easy coding with fields
   maybe_null=field->maybe_null();
   decimals= field->decimals();
-  max_length= field_par->max_length();
+  max_length= field_par->max_display_length();
   table_name= *field_par->table_name;
   field_name= field_par->field_name;
   db_name= field_par->table->s->db;
@@ -2394,21 +2396,22 @@ void Item_param::set_decimal(const char *str, ulong length)
     the fact that even wrong value sent over binary protocol fits into
     MAX_DATE_STRING_REP_LENGTH buffer.
 */
-void Item_param::set_time(TIME *tm, timestamp_type type, uint32 max_length_arg)
+void Item_param::set_time(TIME *tm, timestamp_type time_type,
+                          uint32 max_length_arg)
 { 
   DBUG_ENTER("Item_param::set_time");
 
   value.time= *tm;
-  value.time.time_type= type;
+  value.time.time_type= time_type;
 
   if (value.time.year > 9999 || value.time.month > 12 ||
       value.time.day > 31 ||
-      type != MYSQL_TIMESTAMP_TIME && value.time.hour > 23 ||
+      time_type != MYSQL_TIMESTAMP_TIME && value.time.hour > 23 ||
       value.time.minute > 59 || value.time.second > 59)
   {
     char buff[MAX_DATE_STRING_REP_LENGTH];
     uint length= my_TIME_to_str(&value.time, buff);
-    make_truncated_value_warning(current_thd, buff, length, type, 0);
+    make_truncated_value_warning(current_thd, buff, length, time_type, 0);
     set_zero_time(&value.time, MYSQL_TIMESTAMP_ERROR);
   }
 
@@ -2873,7 +2876,7 @@ bool Item_param::basic_const_item() const
 
 
 Item *
-Item_param::new_item()
+Item_param::clone_item()
 {
   /* see comments in the header file */
   switch (state) {
@@ -3484,34 +3487,73 @@ Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
         }
         if (*from_field != view_ref_found)
         {
+
           prev_subselect_item->used_tables_cache|= (*from_field)->table->map;
           prev_subselect_item->const_item_cache= 0;
+          if (!last_checked_context->select_lex->having_fix_field &&
+              !fixed_as_field)
+          {
+            Item_outer_ref *rf;
+            Query_arena *arena= 0, backup;
+            /*
+              Each outer field is replaced for an Item_outer_ref object.
+              This is done in order to get correct results when the outer
+              select employs a temporary table.
+              The original fields are saved in the inner_fields_list of the
+              outer select. This list is created by the following reasons:
+              1. We can't add field items to the outer select list directly
+                 because the outer select hasn't been fully fixed yet.
+              2. We need a location to refer to in the Item_ref object
+                 so the inner_fields_list is used as such temporary
+                 reference storage.
+              The new Item_outer_ref object replaces the original field and is
+              also saved in the inner_refs_list of the outer select. Here
+              it is only created. It can be fixed only after the original
+              field has been fixed and this is done in the fix_inner_refs()
+              function.
+            */
+            set_field(*from_field);
+            arena= thd->activate_stmt_arena_if_needed(&backup);
+            rf= new Item_outer_ref(context, this);
+            if (!rf)
+            {
+              if (arena)
+                thd->restore_active_arena(arena, &backup);
+              return -1;
+            }
+            *reference= rf;
+            select->inner_refs_list.push_back(rf);
+            if (arena)
+              thd->restore_active_arena(arena, &backup);
+            fixed_as_field= 1;
+          }
           if (thd->lex->in_sum_func &&
               thd->lex->in_sum_func->nest_level == 
               thd->lex->current_select->nest_level)
           {
-            Item::Type type= (*reference)->type();
+            Item::Type ref_type= (*reference)->type();
             set_if_bigger(thd->lex->in_sum_func->max_arg_level,
                           select->nest_level);
             set_field(*from_field);
             fixed= 1;
             mark_as_dependent(thd, last_checked_context->select_lex,
                               context->select_lex, this,
-                              ((type == REF_ITEM || type == FIELD_ITEM) ?
+                              ((ref_type == REF_ITEM ||
+                                ref_type == FIELD_ITEM) ?
                                (Item_ident*) (*reference) : 0));
             return 0;
           }
         }
         else
         {
-          Item::Type type= (*reference)->type();
+          Item::Type ref_type= (*reference)->type();
           prev_subselect_item->used_tables_cache|=
             (*reference)->used_tables();
           prev_subselect_item->const_item_cache&=
             (*reference)->const_item();
           mark_as_dependent(thd, last_checked_context->select_lex,
                             context->select_lex, this,
-                            ((type == REF_ITEM || type == FIELD_ITEM) ?
+                            ((ref_type == REF_ITEM || ref_type == FIELD_ITEM) ?
                              (Item_ident*) (*reference) :
                              0));
           /*
@@ -3612,7 +3654,7 @@ Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
   {
     mark_as_dependent(thd, last_checked_context->select_lex,
                       context->select_lex,
-                      this, this);
+                      this, (Item_ident*)*reference);
     if (last_checked_context->select_lex->having_fix_field)
     {
       Item_ref *rf;
@@ -4049,7 +4091,7 @@ Item *Item_field::replace_equal_field(byte *arg)
 
 
 void Item::init_make_field(Send_field *tmp_field,
-			   enum enum_field_types field_type)
+			   enum enum_field_types field_type_arg)
 {
   char *empty_name= (char*) "";
   tmp_field->db_name=		empty_name;
@@ -4061,7 +4103,7 @@ void Item::init_make_field(Send_field *tmp_field,
   tmp_field->flags=             (maybe_null ? 0 : NOT_NULL_FLAG) | 
                                 (my_binary_compare(collation.collation) ?
                                  BINARY_FLAG : 0);
-  tmp_field->type=field_type;
+  tmp_field->type=              field_type_arg;
   tmp_field->length=max_length;
   tmp_field->decimals=decimals;
   if (unsigned_flag)
@@ -4076,12 +4118,12 @@ void Item::make_field(Send_field *tmp_field)
 
 void Item_empty_string::make_field(Send_field *tmp_field)
 {
-  enum_field_types type= FIELD_TYPE_VAR_STRING;
+  enum_field_types f_type= FIELD_TYPE_VAR_STRING;
   if (max_length >= 16777216)
-    type= FIELD_TYPE_LONG_BLOB;
+    f_type= FIELD_TYPE_LONG_BLOB;
   else if (max_length >= 65536)
-    type= FIELD_TYPE_MEDIUM_BLOB;
-  init_make_field(tmp_field, type);
+    f_type= FIELD_TYPE_MEDIUM_BLOB;
+  init_make_field(tmp_field, f_type);
 }
 
 
@@ -4416,7 +4458,7 @@ bool Item_int::eq(const Item *arg, bool binary_cmp) const
 }
 
 
-Item *Item_int_with_ref::new_item()
+Item *Item_int_with_ref::clone_item()
 {
   DBUG_ASSERT(ref->const_item());
   /*
@@ -4694,10 +4736,10 @@ bool Item_null::send(Protocol *protocol, String *packet)
 bool Item::send(Protocol *protocol, String *buffer)
 {
   bool result;
-  enum_field_types type;
+  enum_field_types f_type;
   LINT_INIT(result);                     // Will be set if null_value == 0
 
-  switch ((type=field_type())) {
+  switch ((f_type=field_type())) {
   default:
   case MYSQL_TYPE_NULL:
   case MYSQL_TYPE_DECIMAL:
@@ -4776,7 +4818,7 @@ bool Item::send(Protocol *protocol, String *buffer)
     get_date(&tm, TIME_FUZZY_DATE);
     if (!null_value)
     {
-      if (type == MYSQL_TYPE_DATE)
+      if (f_type == MYSQL_TYPE_DATE)
 	return protocol->store_date(&tm);
       else
 	result= protocol->store(&tm);
@@ -4820,6 +4862,51 @@ void Item_field::update_null_value()
 }
 
 
+/*
+  Add the field to the select list and substitute it for the reference to
+  the field.
+
+  SYNOPSIS
+    Item_field::update_value_transformer()
+    select_arg      current select
+
+  DESCRIPTION
+    If the field doesn't belong to the table being inserted into then it is
+    added to the select list, pointer to it is stored in the ref_pointer_array
+    of the select and the field itself is substituted for the Item_ref object.
+    This is done in order to get correct values from update fields that
+    belongs to the SELECT part in the INSERT .. SELECT .. ON DUPLICATE KEY
+    UPDATE statement.
+
+  RETURN
+    0             if error occured
+    ref           if all conditions are met
+    this field    otherwise
+*/
+
+Item *Item_field::update_value_transformer(byte *select_arg)
+{
+  SELECT_LEX *select= (SELECT_LEX*)select_arg;
+  DBUG_ASSERT(fixed);
+
+  if (field->table != select->context.table_list->table &&
+      type() != Item::TRIGGER_FIELD_ITEM)
+  {
+    List<Item> *all_fields= &select->join->all_fields;
+    Item **ref_pointer_array= select->ref_pointer_array;
+    int el= all_fields->elements;
+    Item_ref *ref;
+
+    ref_pointer_array[el]= (Item*)this;
+    all_fields->push_front((Item*)this);
+    ref= new Item_ref(&select->context, ref_pointer_array + el,
+                      table_name, field_name);
+    return ref;
+  }
+  return this;
+}
+
+
 Item_ref::Item_ref(Name_resolution_context *context_arg,
                    Item **item, const char *table_name_arg,
                    const char *field_name_arg)
@@ -4829,8 +4916,7 @@ Item_ref::Item_ref(Name_resolution_context *context_arg,
   /*
     This constructor used to create some internals references over fixed items
   */
-  DBUG_ASSERT(ref != 0);
-  if (*ref && (*ref)->fixed)
+  if (ref && *ref && (*ref)->fixed)
     set_properties();
 }
 
@@ -4989,7 +5075,7 @@ bool Item_ref::fix_fields(THD *thd, Item **reference)
             goto error;
           if (from_field == view_ref_found)
           {
-            Item::Type type= (*reference)->type();
+            Item::Type refer_type= (*reference)->type();
             prev_subselect_item->used_tables_cache|=
               (*reference)->used_tables();
             prev_subselect_item->const_item_cache&=
@@ -4997,7 +5083,8 @@ bool Item_ref::fix_fields(THD *thd, Item **reference)
             DBUG_ASSERT((*reference)->type() == REF_ITEM);
             mark_as_dependent(thd, last_checked_context->select_lex,
                               context->select_lex, this,
-                              ((type == REF_ITEM || type == FIELD_ITEM) ?
+                              ((refer_type == REF_ITEM ||
+                                refer_type == FIELD_ITEM) ?
                                (Item_ident*) (*reference) :
                                0));
             /*
@@ -5130,7 +5217,7 @@ void Item_ref::print(String *str)
   if (ref)
   {
     if ((*ref)->type() != Item::CACHE_ITEM && ref_type() != VIEW_REF &&
-        name && alias_name_used)
+        ref_type() != OUTER_REF && name && alias_name_used)
     {
       THD *thd= current_thd;
       append_identifier(thd, str, name, (uint) strlen(name));
@@ -5378,7 +5465,7 @@ bool Item_direct_ref::get_date(TIME *ltime,uint fuzzydate)
 
 
 /*
-  Prepare referenced view viewld then call usual Item_direct_ref::fix_fields
+  Prepare referenced field then call usual Item_direct_ref::fix_fields
 
   SYNOPSIS
     Item_direct_view_ref::fix_fields()
@@ -5402,6 +5489,31 @@ bool Item_direct_view_ref::fix_fields(THD *thd, Item **reference)
 }
 
 /*
+  Prepare referenced outer field then call usual Item_direct_ref::fix_fields
+
+  SYNOPSIS
+    Item_outer_ref::fix_fields()
+    thd         thread handler
+    reference   reference on reference where this item stored
+
+  RETURN
+    FALSE   OK
+    TRUE    Error
+*/
+
+bool Item_outer_ref::fix_fields(THD *thd, Item **reference)
+{
+  DBUG_ASSERT(*ref);
+  /* outer_field->check_cols() will be made in Item_direct_ref::fix_fields */
+  outer_field->fixed_as_field= 1;
+  if (!outer_field->fixed &&
+      (outer_field->fix_fields(thd, reference)))
+    return TRUE;
+  table_name= outer_field->table_name;
+  return Item_direct_ref::fix_fields(thd, reference);
+}
+
+/*
   Compare two view column references for equality.
 
   SYNOPSIS
@@ -5731,8 +5843,9 @@ bool Item_trigger_field::fix_fields(THD *thd, Item **items)
     {
       table_grants->want_privilege= want_privilege;
 
-      if (check_grant_column(thd, table_grants, triggers->table->s->db,
-                             triggers->table->s->table_name, field_name,
+      if (check_grant_column(thd, table_grants, triggers->trigger_table->s->db,
+                             triggers->trigger_table->s->table_name,
+                             field_name,
                              strlen(field_name), thd->security_ctx))
         return TRUE;
     }
@@ -5850,7 +5963,8 @@ void resolve_const_item(THD *thd, Item **ref, Item *comp_item)
     DBUG_ASSERT(item_row->cols() == comp_item_row->cols());
     col= item_row->cols();
     while (col-- > 0)
-      resolve_const_item(thd, item_row->addr(col), comp_item_row->el(col));
+      resolve_const_item(thd, item_row->addr(col),
+                         comp_item_row->element_index(col));
     break;
   }
   /* Fallthrough */
@@ -6118,7 +6232,7 @@ bool Item_cache_row::setup(Item * item)
     return 1;
   for (uint i= 0; i < item_count; i++)
   {
-    Item *el= item->el(i);
+    Item *el= item->element_index(i);
     Item_cache *tmp;
     if (!(tmp= values[i]= Item_cache::get_cache(el->result_type())))
       return 1;
@@ -6134,7 +6248,7 @@ void Item_cache_row::store(Item * item)
   item->bring_value();
   for (uint i= 0; i < item_count; i++)
   {
-    values[i]->store(item->el(i));
+    values[i]->store(item->element_index(i));
     null_value|= values[i]->null_value;
   }
 }
diff --git a/sql/item.h b/sql/item.h
index 6c41aa09f80..833bebdee7e 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -325,10 +325,10 @@ private:
   TABLE_LIST *save_first_name_resolution_table;
   TABLE_LIST *save_next_name_resolution_table;
   bool        save_resolve_in_select_list;
+  TABLE_LIST *save_next_local;
 
 public:
   Name_resolution_context_state() {}          /* Remove gcc warning */
-  TABLE_LIST *save_next_local;
 
 public:
   /* Save the state of a name resolution context. */
@@ -350,6 +350,11 @@ public:
     context->first_name_resolution_table=  save_first_name_resolution_table;
     context->resolve_in_select_list=       save_resolve_in_select_list;
   }
+
+  TABLE_LIST *get_first_name_resolution_table()
+  {
+    return save_first_name_resolution_table;
+  }
 };
 
 /*************************************************************************/
@@ -646,7 +651,7 @@ public:
   */
   virtual bool basic_const_item() const { return 0; }
   /* cloning of constant items (0 if it is not const) */
-  virtual Item *new_item() { return 0; }
+  virtual Item *clone_item() { return 0; }
   virtual cond_result eq_cmp_result() const { return COND_OK; }
   inline uint float_length(uint decimals_par) const
   { return decimals != NOT_FIXED_DEC ? (DBL_DIG+2+decimals_par) : DBL_DIG+8;}
@@ -777,7 +782,7 @@ public:
   virtual bool collect_item_field_processor(byte * arg) { return 0; }
   virtual bool find_item_in_field_list_processor(byte *arg) { return 0; }
   virtual bool change_context_processor(byte *context) { return 0; }
-  virtual bool reset_query_id_processor(byte *query_id) { return 0; }
+  virtual bool reset_query_id_processor(byte *query_id_arg) { return 0; }
   virtual bool is_expensive_processor(byte *arg) { return 0; }
   virtual bool subst_argument_checker(byte **arg)
   { 
@@ -801,11 +806,11 @@ public:
     For SP local variable returns address of pointer to Item representing its
     current value and pointer passed via parameter otherwise.
   */
-  virtual Item **this_item_addr(THD *thd, Item **addr) { return addr; }
+  virtual Item **this_item_addr(THD *thd, Item **addr_arg) { return addr_arg; }
 
   // Row emulation
   virtual uint cols() { return 1; }
-  virtual Item* el(uint i) { return this; }
+  virtual Item* element_index(uint i) { return this; }
   virtual Item** addr(uint i) { return 0; }
   virtual bool check_cols(uint c);
   // It is not row => null inside is impossible
@@ -817,6 +822,7 @@ public:
   virtual Item_field *filed_for_view_update() { return 0; }
 
   virtual Item *neg_transformer(THD *thd) { return NULL; }
+  virtual Item *update_value_transformer(byte *select_arg) { return this; }
   virtual Item *safe_charset_converter(CHARSET_INFO *tocs);
   void delete_self()
   {
@@ -1071,7 +1077,8 @@ class Item_name_const : public Item
   Item *value_item;
   Item *name_item;
 public:
-  Item_name_const(Item *name, Item *val): value_item(val), name_item(name)
+  Item_name_const(Item *name_arg, Item *val):
+    value_item(val), name_item(name_arg)
   {
     Item::maybe_null= TRUE;
   }
@@ -1214,7 +1221,7 @@ public:
   uint have_privileges;
   /* field need any privileges (for VIEW creation) */
   bool any_privileges;
-
+  bool fixed_as_field;
   Item_field(Name_resolution_context *context_arg,
              const char *db_arg,const char *table_name_arg,
 	     const char *field_name_arg);
@@ -1291,10 +1298,11 @@ public:
   Item *equal_fields_propagator(byte *arg);
   bool set_no_const_sub(byte *arg);
   Item *replace_equal_field(byte *arg);
-  inline uint32 max_disp_length() { return field->max_length(); }
+  inline uint32 max_disp_length() { return field->max_display_length(); }
   Item_field *filed_for_view_update() { return this; }
   Item *safe_charset_converter(CHARSET_INFO *tocs);
   int fix_outer_field(THD *thd, Field **field, Item **reference);
+  virtual Item *update_value_transformer(byte *select_arg);
   friend class Item_default_value;
   friend class Item_insert_value;
   friend class st_select_lex_unit;
@@ -1325,7 +1333,7 @@ public:
   /* to prevent drop fixed flag (no need parent cleanup call) */
   void cleanup() {}
   bool basic_const_item() const { return 1; }
-  Item *new_item() { return new Item_null(name); }
+  Item *clone_item() { return new Item_null(name); }
   bool is_null() { return 1; }
   void print(String *str) { str->append(STRING_WITH_LEN("NULL")); }
   Item *safe_charset_converter(CHARSET_INFO *tocs);
@@ -1472,7 +1480,7 @@ public:
     basic_const_item returned TRUE.
   */
   Item *safe_charset_converter(CHARSET_INFO *tocs);
-  Item *new_item();
+  Item *clone_item();
   /*
     Implement by-value equality evaluation if parameter value
     is set and is a basic constant (integer, real or string).
@@ -1504,7 +1512,7 @@ public:
   String *val_str(String*);
   int save_in_field(Field *field, bool no_conversions);
   bool basic_const_item() const { return 1; }
-  Item *new_item() { return new Item_int(name,value,max_length); }
+  Item *clone_item() { return new Item_int(name,value,max_length); }
   // to prevent drop fixed flag (no need parent cleanup call)
   void cleanup() {}
   void print(String *str);
@@ -1524,7 +1532,7 @@ public:
   double val_real()
     { DBUG_ASSERT(fixed == 1); return ulonglong2double((ulonglong)value); }
   String *val_str(String*);
-  Item *new_item() { return new Item_uint(name,max_length); }
+  Item *clone_item() { return new Item_uint(name,max_length); }
   int save_in_field(Field *field, bool no_conversions);
   void print(String *str);
   Item_num *neg ();
@@ -1555,7 +1563,7 @@ public:
   my_decimal *val_decimal(my_decimal *val) { return &decimal_value; }
   int save_in_field(Field *field, bool no_conversions);
   bool basic_const_item() const { return 1; }
-  Item *new_item()
+  Item *clone_item()
   {
     return new Item_decimal(name, &decimal_value, decimals, max_length);
   }
@@ -1613,7 +1621,7 @@ public:
   bool basic_const_item() const { return 1; }
   // to prevent drop fixed flag (no need parent cleanup call)
   void cleanup() {}
-  Item *new_item()
+  Item *clone_item()
   { return new Item_float(name, value, decimals, max_length); }
   Item_num *neg() { value= -value; return this; }
   void print(String *str);
@@ -1698,7 +1706,7 @@ public:
   enum_field_types field_type() const { return MYSQL_TYPE_VARCHAR; }
   bool basic_const_item() const { return 1; }
   bool eq(const Item *item, bool binary_cmp) const;
-  Item *new_item() 
+  Item *clone_item() 
   {
     return new Item_string(name, str_value.ptr(), 
     			   str_value.length(), collation.collation);
@@ -1749,9 +1757,9 @@ class Item_return_int :public Item_int
 {
   enum_field_types int_field_type;
 public:
-  Item_return_int(const char *name, uint length,
+  Item_return_int(const char *name_arg, uint length,
 		  enum_field_types field_type_arg)
-    :Item_int(name, 0, length), int_field_type(field_type_arg)
+    :Item_int(name_arg, 0, length), int_field_type(field_type_arg)
   {
     unsigned_flag=1;
   }
@@ -1817,7 +1825,7 @@ class Item_ref :public Item_ident
 protected:
   void set_properties();
 public:
-  enum Ref_Type { REF, DIRECT_REF, VIEW_REF };
+  enum Ref_Type { REF, DIRECT_REF, VIEW_REF, OUTER_REF };
   Field *result_field;			 /* Save result here */
   Item **ref;
   Item_ref(Name_resolution_context *context_arg,
@@ -1878,7 +1886,7 @@ public:
                           (*ref)->get_tmp_table_item(thd));
   }
   table_map used_tables() const		
-  { 
+  {
     return depended_from ? OUTER_REF_TABLE_BIT : (*ref)->used_tables(); 
   }
   table_map not_null_tables() const { return (*ref)->not_null_tables(); }
@@ -1951,6 +1959,40 @@ public:
 };
 
 
+class Item_outer_ref :public Item_direct_ref
+{
+public:
+  Item_field *outer_field;
+  Item_outer_ref(Name_resolution_context *context_arg,
+                 Item_field *outer_field_arg)
+    :Item_direct_ref(context_arg, 0, outer_field_arg->table_name,
+                          outer_field_arg->field_name),
+    outer_field(outer_field_arg)
+  {
+    ref= (Item**)&outer_field;
+    set_properties();
+    fixed= 0;
+  }
+  void cleanup()
+  {
+    ref= (Item**)&outer_field;
+    fixed= 0;
+    Item_direct_ref::cleanup();
+    outer_field->cleanup();
+  }
+  void save_in_result_field(bool no_conversions)
+  {
+    outer_field->save_org_in_field(result_field);
+  }
+  bool fix_fields(THD *, Item **);
+  table_map used_tables() const
+  {
+    return (*ref)->const_item() ? 0 : OUTER_REF_TABLE_BIT;
+  }
+  virtual Ref_Type ref_type() { return OUTER_REF; }
+};
+
+
 class Item_in_subselect;
 
 
@@ -2013,7 +2055,7 @@ public:
   {
     return ref->save_in_field(field, no_conversions);
   }
-  Item *new_item();
+  Item *clone_item();
   virtual Item *real_item() { return ref; }
 };
 
@@ -2449,8 +2491,8 @@ public:
   enum Item_result result_type() const { return ROW_RESULT; }
   
   uint cols() { return item_count; }
-  Item* el(uint i) { return values[i]; }
-  Item** addr(uint i) { return (Item **) (values + i); }
+  Item *element_index(uint i) { return values[i]; }
+  Item **addr(uint i) { return (Item **) (values + i); }
   bool check_cols(uint c);
   bool null_inside();
   void bring_value();
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index 9ca010e7cf5..e0d74cc7547 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -281,7 +281,7 @@ static bool convert_constant_item(THD *thd, Field *field, Item **item)
 void Item_bool_func2::fix_length_and_dec()
 {
   max_length= 1;				     // Function returns 0 or 1
-  THD *thd= current_thd;
+  THD *thd;
 
   /*
     As some compare functions are generated after sql_yacc,
@@ -319,12 +319,13 @@ void Item_bool_func2::fix_length_and_dec()
     return;
   }
 
+  thd= current_thd;
   if (!thd->is_context_analysis_only())
   {
-    Item *real_item= args[0]->real_item();
-    if (real_item->type() == FIELD_ITEM)
+    Item *arg_real_item= args[0]->real_item();
+    if (arg_real_item->type() == FIELD_ITEM)
     {
-      Field *field=((Item_field*) real_item)->field;
+      Field *field=((Item_field*) arg_real_item)->field;
       if (field->can_be_compared_as_longlong())
       {
         if (convert_constant_item(thd, field,&args[1]))
@@ -336,10 +337,10 @@ void Item_bool_func2::fix_length_and_dec()
         }
       }
     }
-    real_item= args[1]->real_item();
-    if (real_item->type() == FIELD_ITEM /* && !real_item->const_item() */)
+    arg_real_item= args[1]->real_item();
+    if (arg_real_item->type() == FIELD_ITEM)
     {
-      Field *field=((Item_field*) real_item)->field;
+      Field *field=((Item_field*) arg_real_item)->field;
       if (field->can_be_compared_as_longlong())
       {
         if (convert_constant_item(thd, field,&args[0]))
@@ -375,9 +376,9 @@ int Arg_comparator::set_compare_func(Item_bool_func2 *item, Item_result type)
       return 1;
     for (uint i=0; i < n; i++)
     {
-      if ((*a)->el(i)->cols() != (*b)->el(i)->cols())
+      if ((*a)->element_index(i)->cols() != (*b)->element_index(i)->cols())
       {
-	my_error(ER_OPERAND_COLUMNS, MYF(0), (*a)->el(i)->cols());
+	my_error(ER_OPERAND_COLUMNS, MYF(0), (*a)->element_index(i)->cols());
 	return 1;
       }
       comparators[i].set_cmp_func(owner, (*a)->addr(i), (*b)->addr(i));
@@ -811,10 +812,10 @@ bool Item_in_optimizer::fix_left(THD *thd, Item **ref)
     uint n= cache->cols();
     for (uint i= 0; i < n; i++)
     {
-      if (args[0]->el(i)->used_tables())
-	((Item_cache *)cache->el(i))->set_used_tables(OUTER_REF_TABLE_BIT);
+      if (args[0]->element_index(i)->used_tables())
+	((Item_cache *)cache->element_index(i))->set_used_tables(OUTER_REF_TABLE_BIT);
       else
-	((Item_cache *)cache->el(i))->set_used_tables(0);
+	((Item_cache *)cache->element_index(i))->set_used_tables(0);
     }
     used_tables_cache= args[0]->used_tables();
   }
@@ -854,6 +855,7 @@ bool Item_in_optimizer::fix_fields(THD *thd, Item **ref)
 
 longlong Item_in_optimizer::val_int()
 {
+  bool tmp;
   DBUG_ASSERT(fixed == 1);
   cache->store(args[0]);
   
@@ -888,7 +890,7 @@ longlong Item_in_optimizer::val_int()
         if (cache->cols() == 1)
         {
           item_subs->set_cond_guard_var(0, FALSE);
-          longlong tmp= args[1]->val_bool_result();
+          (void) args[1]->val_bool_result();
           result_for_null_param= null_value= !item_subs->engine->no_rows();
           item_subs->set_cond_guard_var(0, TRUE);
         }
@@ -902,11 +904,11 @@ longlong Item_in_optimizer::val_int()
           */
           for (i= 0; i < ncols; i++)
           {
-            if (cache->el(i)->null_value)
+            if (cache->element_index(i)->null_value)
               item_subs->set_cond_guard_var(i, FALSE);
           }
           
-          longlong tmp= args[1]->val_bool_result();
+          (void) args[1]->val_bool_result();
           result_for_null_param= null_value= !item_subs->engine->no_rows();
           
           /* Turn all predicates back on */
@@ -917,7 +919,7 @@ longlong Item_in_optimizer::val_int()
     }
     return 0;
   }
-  bool tmp= args[1]->val_bool_result();
+  tmp= args[1]->val_bool_result();
   null_value= args[1]->null_value;
   return tmp;
 }
@@ -1026,15 +1028,15 @@ longlong Item_func_strcmp::val_int()
 
 void Item_func_interval::fix_length_and_dec()
 {
-  use_decimal_comparison= (row->el(0)->result_type() == DECIMAL_RESULT) ||
-    (row->el(0)->result_type() == INT_RESULT);
+  use_decimal_comparison= (row->element_index(0)->result_type() == DECIMAL_RESULT) ||
+    (row->element_index(0)->result_type() == INT_RESULT);
   if (row->cols() > 8)
   {
     bool consts=1;
 
     for (uint i=1 ; consts && i < row->cols() ; i++)
     {
-      consts&= row->el(i)->const_item();
+      consts&= row->element_index(i)->const_item();
     }
 
     if (consts &&
@@ -1045,7 +1047,7 @@ void Item_func_interval::fix_length_and_dec()
       {
         for (uint i=1 ; i < row->cols(); i++)
         {
-          Item *el= row->el(i);
+          Item *el= row->element_index(i);
           interval_range *range= intervals + (i-1);
           if ((el->result_type() == DECIMAL_RESULT) ||
               (el->result_type() == INT_RESULT))
@@ -1070,7 +1072,7 @@ void Item_func_interval::fix_length_and_dec()
       {
         for (uint i=1 ; i < row->cols(); i++)
         {
-          intervals[i-1].dbl= row->el(i)->val_real();
+          intervals[i-1].dbl= row->element_index(i)->val_real();
         }
       }
     }
@@ -1110,15 +1112,15 @@ longlong Item_func_interval::val_int()
 
   if (use_decimal_comparison)
   {
-    dec= row->el(0)->val_decimal(&dec_buf);
-    if (row->el(0)->null_value)
+    dec= row->element_index(0)->val_decimal(&dec_buf);
+    if (row->element_index(0)->null_value)
       return -1;
     my_decimal2double(E_DEC_FATAL_ERROR, dec, &value);
   }
   else
   {
-    value= row->el(0)->val_real();
-    if (row->el(0)->null_value)
+    value= row->element_index(0)->val_real();
+    if (row->element_index(0)->null_value)
       return -1;
   }
 
@@ -1154,16 +1156,16 @@ longlong Item_func_interval::val_int()
 
   for (i=1 ; i < row->cols() ; i++)
   {
-    Item *el= row->el(i);
+    Item *el= row->element_index(i);
     if (use_decimal_comparison &&
         ((el->result_type() == DECIMAL_RESULT) ||
          (el->result_type() == INT_RESULT)))
     {
-      my_decimal e_dec_buf, *e_dec= row->el(i)->val_decimal(&e_dec_buf);
+      my_decimal e_dec_buf, *e_dec= row->element_index(i)->val_decimal(&e_dec_buf);
       if (my_decimal_cmp(e_dec, dec) > 0)
         return i-1;
     }
-    else if (row->el(i)->val_real() > value)
+    else if (row->element_index(i)->val_real() > value)
       return i-1;
   }
   return i-1;
@@ -1886,7 +1888,9 @@ bool Item_func_case::fix_fields(THD *thd, Item **ref)
     buff should match stack usage from
     Item_func_case::val_int() -> Item_func_case::find_item()
   */
+#ifndef EMBEDDED_LIBRARY
   char buff[MAX_FIELD_WIDTH*2+sizeof(String)*2+sizeof(String*)*2+sizeof(double)*2+sizeof(longlong)*2];
+#endif
   bool res= Item_func::fix_fields(thd, ref);
   /*
     Call check_stack_overrun after fix_fields to be sure that stack variable
@@ -2349,11 +2353,11 @@ void cmp_item_row::store_value(Item *item)
     {
       if (!comparators[i])
         if (!(comparators[i]=
-              cmp_item::get_comparator(item->el(i)->result_type(),
-                                       item->el(i)->collation.collation)))
+              cmp_item::get_comparator(item->element_index(i)->result_type(),
+                                       item->element_index(i)->collation.collation)))
 	  break;					// new failed
-      comparators[i]->store_value(item->el(i));
-      item->null_value|= item->el(i)->null_value;
+      comparators[i]->store_value(item->element_index(i));
+      item->null_value|= item->element_index(i)->null_value;
     }
   }
   DBUG_VOID_RETURN;
@@ -2378,8 +2382,8 @@ void cmp_item_row::store_value_by_template(cmp_item *t, Item *item)
       if (!(comparators[i]= tmpl->comparators[i]->make_same()))
 	break;					// new failed
       comparators[i]->store_value_by_template(tmpl->comparators[i],
-					      item->el(i));
-      item->null_value|= item->el(i)->null_value;
+					      item->element_index(i));
+      item->null_value|= item->element_index(i)->null_value;
     }
   }
 }
@@ -2397,9 +2401,9 @@ int cmp_item_row::cmp(Item *arg)
   arg->bring_value();
   for (uint i=0; i < n; i++)
   {
-    if (comparators[i]->cmp(arg->el(i)))
+    if (comparators[i]->cmp(arg->element_index(i)))
     {
-      if (!arg->el(i)->null_value)
+      if (!arg->element_index(i)->null_value)
 	return 1;
       was_null= 1;
     }
@@ -2410,11 +2414,11 @@ int cmp_item_row::cmp(Item *arg)
 
 int cmp_item_row::compare(cmp_item *c)
 {
-  cmp_item_row *cmp= (cmp_item_row *) c;
+  cmp_item_row *l_cmp= (cmp_item_row *) c;
   for (uint i=0; i < n; i++)
   {
     int res;
-    if ((res= comparators[i]->compare(cmp->comparators[i])))
+    if ((res= comparators[i]->compare(l_cmp->comparators[i])))
       return res;
   }
   return 0;
@@ -2441,8 +2445,8 @@ int cmp_item_decimal::cmp(Item *arg)
 
 int cmp_item_decimal::compare(cmp_item *arg)
 {
-  cmp_item_decimal *cmp= (cmp_item_decimal*) arg;
-  return my_decimal_cmp(&value, &cmp->value);
+  cmp_item_decimal *l_cmp= (cmp_item_decimal*) arg;
+  return my_decimal_cmp(&value, &l_cmp->value);
 }
 
 
diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h
index d7db928e281..47f67d0392f 100644
--- a/sql/item_cmpfunc.h
+++ b/sql/item_cmpfunc.h
@@ -845,10 +845,10 @@ public:
     return (value_res ? (res ? sortcmp(value_res, res, cmp_charset) : 1) :
             (res ? -1 : 0));
   }
-  int compare(cmp_item *c)
+  int compare(cmp_item *ci)
   {
-    cmp_item_string *cmp= (cmp_item_string *)c;
-    return sortcmp(value_res, cmp->value_res, cmp_charset);
+    cmp_item_string *l_cmp= (cmp_item_string *) ci;
+    return sortcmp(value_res, l_cmp->value_res, cmp_charset);
   } 
   cmp_item *make_same();
 };
@@ -866,10 +866,10 @@ public:
   {
     return value != arg->val_int();
   }
-  int compare(cmp_item *c)
+  int compare(cmp_item *ci)
   {
-    cmp_item_int *cmp= (cmp_item_int *)c;
-    return (value < cmp->value) ? -1 : ((value == cmp->value) ? 0 : 1);
+    cmp_item_int *l_cmp= (cmp_item_int *)ci;
+    return (value < l_cmp->value) ? -1 : ((value == l_cmp->value) ? 0 : 1);
   }
   cmp_item *make_same();
 };
@@ -887,10 +887,10 @@ public:
   {
     return value != arg->val_real();
   }
-  int compare(cmp_item *c)
+  int compare(cmp_item *ci)
   {
-    cmp_item_real *cmp= (cmp_item_real *)c;
-    return (value < cmp->value)? -1 : ((value == cmp->value) ? 0 : 1);
+    cmp_item_real *l_cmp= (cmp_item_real *) ci;
+    return (value < l_cmp->value)? -1 : ((value == l_cmp->value) ? 0 : 1);
   }
   cmp_item *make_same();
 };
@@ -955,10 +955,10 @@ public:
     DBUG_ASSERT(0);
     return 1;
   }
-  int compare(cmp_item *c)
+  int compare(cmp_item *ci)
   {
-    cmp_item_string *cmp= (cmp_item_string *)c;
-    return sortcmp(value_res, cmp->value_res, cmp_charset);
+    cmp_item_string *l_cmp= (cmp_item_string *) ci;
+    return sortcmp(value_res, l_cmp->value_res, cmp_charset);
   }
   cmp_item *make_same()
   {
@@ -1372,7 +1372,7 @@ public:
   Item_cond_and() :Item_cond() {}
   Item_cond_and(Item *i1,Item *i2) :Item_cond(i1,i2) {}
   Item_cond_and(THD *thd, Item_cond_and *item) :Item_cond(thd, item) {}
-  Item_cond_and(List<Item> &list): Item_cond(list) {}
+  Item_cond_and(List<Item> &list_arg): Item_cond(list_arg) {}
   enum Functype functype() const { return COND_AND_FUNC; }
   longlong val_int();
   const char *func_name() const { return "and"; }
@@ -1394,7 +1394,7 @@ public:
   Item_cond_or() :Item_cond() {}
   Item_cond_or(Item *i1,Item *i2) :Item_cond(i1,i2) {}
   Item_cond_or(THD *thd, Item_cond_or *item) :Item_cond(thd, item) {}
-  Item_cond_or(List<Item> &list): Item_cond(list) {}
+  Item_cond_or(List<Item> &list_arg): Item_cond(list_arg) {}
   enum Functype functype() const { return COND_OR_FUNC; }
   longlong val_int();
   const char *func_name() const { return "or"; }
diff --git a/sql/item_func.cc b/sql/item_func.cc
index 32cc90b96d6..0e454ad26a1 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -2360,7 +2360,7 @@ longlong Item_func_locate::val_int()
                                             b->ptr(), b->length(),
                                             &match, 1))
     return 0;
-  return (longlong) match.mblen + start0 + 1;
+  return (longlong) match.mb_len + start0 + 1;
 }
 
 
@@ -3161,9 +3161,9 @@ longlong Item_master_pos_wait::val_int()
     null_value = 1;
     return 0;
   }
+#ifdef HAVE_REPLICATION
   longlong pos = (ulong)args[1]->val_int();
   longlong timeout = (arg_count==3) ? args[2]->val_int() : 0 ;
-#ifdef HAVE_REPLICATION
   if ((event_count = active_mi->rli.wait_for_pos(thd, log_name, pos, timeout)) == -2)
   {
     null_value = 1;
@@ -3715,7 +3715,8 @@ update_hash(user_var_entry *entry, bool set_null, void *ptr, uint length,
 
 
 bool
-Item_func_set_user_var::update_hash(void *ptr, uint length, Item_result type,
+Item_func_set_user_var::update_hash(void *ptr, uint length,
+                                    Item_result res_type,
                                     CHARSET_INFO *cs, Derivation dv,
                                     bool unsigned_arg)
 {
@@ -3724,9 +3725,9 @@ Item_func_set_user_var::update_hash(void *ptr, uint length, Item_result type,
     result type of the variable
   */
   if ((null_value= args[0]->null_value) && null_item)
-    type= entry->type;                          // Don't change type of item
+    res_type= entry->type;                      // Don't change type of item
   if (::update_hash(entry, (null_value= args[0]->null_value),
-                    ptr, length, type, cs, dv, unsigned_arg))
+                    ptr, length, res_type, cs, dv, unsigned_arg))
   {
     current_thd->fatal_error();     // Probably end of memory
     null_value= 1;
@@ -4226,7 +4227,14 @@ int get_var_with_binlog(THD *thd, enum_sql_command sql_command,
   user_var_entry *var_entry;
   var_entry= get_variable(&thd->user_vars, name, 0);
 
-  if (!(opt_bin_log && is_update_query(sql_command)))
+  /*
+    Any reference to user-defined variable which is done from stored
+    function or trigger affects their execution and the execution of the
+    calling statement. We must log all such variables even if they are 
+    not involved in table-updating statements.
+  */
+  if (!(opt_bin_log && 
+       (is_update_query(sql_command) || thd->in_sub_stmt)))
   {
     *out_entry= var_entry;
     return 0;
@@ -4978,8 +4986,9 @@ longlong Item_func_row_count::val_int()
 }
 
 
-Item_func_sp::Item_func_sp(Name_resolution_context *context_arg, sp_name *name)
-  :Item_func(), context(context_arg), m_name(name), m_sp(NULL),
+Item_func_sp::Item_func_sp(Name_resolution_context *context_arg,
+                           sp_name *name_arg)
+  :Item_func(), context(context_arg), m_name(name_arg), m_sp(NULL),
    result_field(NULL)
 {
   maybe_null= 1;
@@ -4989,8 +4998,8 @@ Item_func_sp::Item_func_sp(Name_resolution_context *context_arg, sp_name *name)
 
 
 Item_func_sp::Item_func_sp(Name_resolution_context *context_arg,
-                           sp_name *name, List<Item> &list)
-  :Item_func(list), context(context_arg), m_name(name), m_sp(NULL),
+                           sp_name *name_arg, List<Item> &list)
+  :Item_func(list), context(context_arg), m_name(name_arg), m_sp(NULL),
    result_field(NULL)
 {
   maybe_null= 1;
diff --git a/sql/item_geofunc.cc b/sql/item_geofunc.cc
index 676b3bc9b36..a304c554211 100644
--- a/sql/item_geofunc.cc
+++ b/sql/item_geofunc.cc
@@ -698,8 +698,9 @@ double Item_func_glength::val_real()
 
   null_value= (!swkb || 
 	       !(geom= Geometry::construct(&buffer,
-                                           swkb->ptr(), swkb->length())) ||
-	       geom->length(&res));
+                                           swkb->ptr(),
+                                           swkb->length())) ||
+	       geom->geom_length(&res));
   return res;
 }
 
diff --git a/sql/item_row.h b/sql/item_row.h
index bd47558a2f6..8623b579e33 100644
--- a/sql/item_row.h
+++ b/sql/item_row.h
@@ -71,7 +71,7 @@ public:
   Item *transform(Item_transformer transformer, byte *arg);
 
   uint cols() { return arg_count; }
-  Item* el(uint i) { return items[i]; }
+  Item* element_index(uint i) { return items[i]; }
   Item** addr(uint i) { return items + i; }
   bool check_cols(uint c);
   bool null_inside() { return with_null; };
diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
index 6c28cb3f42b..95df89d881d 100644
--- a/sql/item_strfunc.cc
+++ b/sql/item_strfunc.cc
@@ -37,15 +37,6 @@ C_MODE_END
 
 String my_empty_string("",default_charset_info);
 
-static void my_coll_agg_error(DTCollation &c1, DTCollation &c2,
-                              const char *fname)
-{
-  my_error(ER_CANT_AGGREGATE_2COLLATIONS, MYF(0),
-           c1.collation->name, c1.derivation_name(),
-           c2.collation->name, c2.derivation_name(),
-           fname);
-}
-
 
 String *Item_str_func::check_well_formed_result(String *str)
 {
@@ -3248,15 +3239,17 @@ String *Item_func_uuid::val_str(String *str)
     int i;
     if (my_gethwaddr(mac))
     {
+      /* purecov: begin inspected */
       /*
         generating random "hardware addr"
         and because specs explicitly specify that it should NOT correlate
         with a clock_seq value (initialized random below), we use a separate
         randominit() here
       */
-      randominit(&uuid_rand, tmp + (ulong) thd, tmp + (ulong)query_id);
+      randominit(&uuid_rand, tmp + (ulong) thd, tmp + (ulong)global_query_id);
       for (i=0; i < (int)sizeof(mac); i++)
         mac[i]=(uchar)(my_rnd(&uuid_rand)*255);
+      /* purecov: end */    
     }
     s=clock_seq_and_node_str+sizeof(clock_seq_and_node_str)-1;
     for (i=sizeof(mac)-1 ; i>=0 ; i--)
@@ -3264,7 +3257,7 @@ String *Item_func_uuid::val_str(String *str)
       *--s=_dig_vec_lower[mac[i] & 15];
       *--s=_dig_vec_lower[mac[i] >> 4];
     }
-    randominit(&uuid_rand, tmp + (ulong)start_time,
+    randominit(&uuid_rand, tmp + (ulong) server_start_time,
 	       tmp + thd->status_var.bytes_sent);
     set_clock_seq_str();
   }
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
index d61bb25e9b7..20d9ed8affa 100644
--- a/sql/item_subselect.cc
+++ b/sql/item_subselect.cc
@@ -232,11 +232,11 @@ bool Item_subselect::const_item() const
   return const_item_cache;
 }
 
-Item *Item_subselect::get_tmp_table_item(THD *thd)
+Item *Item_subselect::get_tmp_table_item(THD *thd_arg)
 {
   if (!with_sum_func && !const_item())
     return new Item_field(result_field);
-  return copy_or_same(thd);
+  return copy_or_same(thd_arg);
 }
 
 void Item_subselect::update_used_tables()
@@ -551,13 +551,13 @@ void Item_exists_subselect::print(String *str)
 }
 
 
-bool Item_in_subselect::test_limit(SELECT_LEX_UNIT *unit)
+bool Item_in_subselect::test_limit(SELECT_LEX_UNIT *unit_arg)
 {
-  if (unit->fake_select_lex &&
-      unit->fake_select_lex->test_limit())
+  if (unit_arg->fake_select_lex &&
+      unit_arg->fake_select_lex->test_limit())
     return(1);
 
-  SELECT_LEX *sl= unit->first_select();
+  SELECT_LEX *sl= unit_arg->first_select();
   for (; sl; sl= sl->next_select())
   {
     if (sl->test_limit())
@@ -829,7 +829,6 @@ Item_subselect::trans_res
 Item_in_subselect::single_value_transformer(JOIN *join,
 					    Comp_creator *func)
 {
-  Item_subselect::trans_res result= RES_ERROR;
   SELECT_LEX *select_lex= join->select_lex;
   DBUG_ENTER("Item_in_subselect::single_value_transformer");
 
@@ -927,7 +926,7 @@ Item_in_subselect::single_value_transformer(JOIN *join,
   if (!substitution)
   {
     /* We're invoked for the 1st (or the only) SELECT in the subquery UNION */
-    SELECT_LEX_UNIT *unit= select_lex->master_unit();
+    SELECT_LEX_UNIT *master_unit= select_lex->master_unit();
     substitution= optimizer;
 
     SELECT_LEX *current= thd->lex->current_select, *up;
@@ -950,7 +949,7 @@ Item_in_subselect::single_value_transformer(JOIN *join,
 			      (char *)"<no matter>",
 			      (char *)in_left_expr_name);
 
-    unit->uncacheable|= UNCACHEABLE_DEPENDENT;
+    master_unit->uncacheable|= UNCACHEABLE_DEPENDENT;
   }
   if (!abort_on_null && left_expr->maybe_null && !pushed_cond_guards)
   {
@@ -1149,7 +1148,7 @@ Item_in_subselect::row_value_transformer(JOIN *join)
   if (!substitution)
   {
     //first call for this unit
-    SELECT_LEX_UNIT *unit= select_lex->master_unit();
+    SELECT_LEX_UNIT *master_unit= select_lex->master_unit();
     substitution= optimizer;
 
     SELECT_LEX *current= thd->lex->current_select, *up;
@@ -1165,7 +1164,7 @@ Item_in_subselect::row_value_transformer(JOIN *join)
     optimizer->keep_top_level_cache();
 
     thd->lex->current_select= current;
-    unit->uncacheable|= UNCACHEABLE_DEPENDENT;
+    master_unit->uncacheable|= UNCACHEABLE_DEPENDENT;
 
     if (!abort_on_null && left_expr->maybe_null && !pushed_cond_guards)
     {
@@ -1198,7 +1197,7 @@ Item_in_subselect::row_value_transformer(JOIN *join)
     {
       DBUG_ASSERT(left_expr->fixed && select_lex->ref_pointer_array[i]->fixed);
       if (select_lex->ref_pointer_array[i]->
-          check_cols(left_expr->el(i)->cols()))
+          check_cols(left_expr->element_index(i)->cols()))
         DBUG_RETURN(RES_ERROR);
       Item *item_eq=
         new Item_func_eq(new
@@ -1221,7 +1220,7 @@ Item_in_subselect::row_value_transformer(JOIN *join)
                                       (char *)"<list ref>")
                             );
       Item *col_item= new Item_cond_or(item_eq, item_isnull);
-      if (!abort_on_null && left_expr->el(i)->maybe_null)
+      if (!abort_on_null && left_expr->element_index(i)->maybe_null)
       {
         if (!(col_item= new Item_func_trig_cond(col_item, get_cond_guard(i))))
           DBUG_RETURN(RES_ERROR);
@@ -1235,7 +1234,7 @@ Item_in_subselect::row_value_transformer(JOIN *join)
                                                 ref_pointer_array + i,
                                                 (char *)"<no matter>",
                                                 (char *)"<list ref>"));
-      if (!abort_on_null && left_expr->el(i)->maybe_null)
+      if (!abort_on_null && left_expr->element_index(i)->maybe_null)
       {
         if (!(item_nnull_test= 
               new Item_func_trig_cond(item_nnull_test, get_cond_guard(i))))
@@ -1272,7 +1271,7 @@ Item_in_subselect::row_value_transformer(JOIN *join)
       Item *item, *item_isnull;
       DBUG_ASSERT(left_expr->fixed && select_lex->ref_pointer_array[i]->fixed);
       if (select_lex->ref_pointer_array[i]->
-          check_cols(left_expr->el(i)->cols()))
+          check_cols(left_expr->element_index(i)->cols()))
         DBUG_RETURN(RES_ERROR);
       item=
         new Item_func_eq(new
@@ -1312,7 +1311,7 @@ Item_in_subselect::row_value_transformer(JOIN *join)
           TODO: why we create the above for cases where the right part
                 cant be NULL?
         */
-        if (left_expr->el(i)->maybe_null)
+        if (left_expr->element_index(i)->maybe_null)
         {
           if (!(item= new Item_func_trig_cond(item, get_cond_guard(i))))
             DBUG_RETURN(RES_ERROR);
@@ -1474,14 +1473,14 @@ void Item_in_subselect::print(String *str)
 }
 
 
-bool Item_in_subselect::fix_fields(THD *thd, Item **ref)
+bool Item_in_subselect::fix_fields(THD *thd_arg, Item **ref)
 {
   bool result = 0;
   
-  if(thd->lex->view_prepare_mode && left_expr && !left_expr->fixed)
-    result = left_expr->fix_fields(thd, &left_expr);
+  if (thd_arg->lex->view_prepare_mode && left_expr && !left_expr->fixed)
+    result = left_expr->fix_fields(thd_arg, &left_expr);
 
-  return result || Item_subselect::fix_fields(thd, ref);
+  return result || Item_subselect::fix_fields(thd_arg, ref);
 }
 
 
@@ -1520,13 +1519,13 @@ void subselect_engine::set_thd(THD *thd_arg)
 
 subselect_single_select_engine::
 subselect_single_select_engine(st_select_lex *select,
-			       select_subselect *result,
-			       Item_subselect *item)
-  :subselect_engine(item, result),
+			       select_subselect *result_arg,
+			       Item_subselect *item_arg)
+  :subselect_engine(item_arg, result_arg),
    prepared(0), optimized(0), executed(0),
    select_lex(select), join(0)
 {
-  select_lex->master_unit()->item= item;
+  select_lex->master_unit()->item= item_arg;
 }
 
 
@@ -1763,7 +1762,6 @@ int subselect_single_select_engine::exec()
   if (!executed)
   {
     item->reset_value_registration();
-    bool have_changed_access= FALSE;
     JOIN_TAB *changed_tabs[MAX_TABLES];
     JOIN_TAB **last_changed_tab= changed_tabs;
     if (item->have_guarded_conds())
diff --git a/sql/item_subselect.h b/sql/item_subselect.h
index 25a0326f8b6..485a896c1c7 100644
--- a/sql/item_subselect.h
+++ b/sql/item_subselect.h
@@ -163,7 +163,7 @@ public:
   void fix_length_and_dec();
 
   uint cols();
-  Item* el(uint i) { return my_reinterpret_cast(Item*)(row[i]); }
+  Item* element_index(uint i) { return my_reinterpret_cast(Item*)(row[i]); }
   Item** addr(uint i) { return (Item**)row + i; }
   bool check_cols(uint c);
   bool null_inside();
@@ -531,10 +531,10 @@ class subselect_indexsubquery_engine: public subselect_uniquesubquery_engine
 public:
 
   // constructor can assign THD because it will be called after JOIN::prepare
-  subselect_indexsubquery_engine(THD *thd, st_join_table *tab_arg,
+  subselect_indexsubquery_engine(THD *thd_arg, st_join_table *tab_arg,
 				 Item_subselect *subs, Item *where,
                                  Item *having_arg, bool chk_null)
-    :subselect_uniquesubquery_engine(thd, tab_arg, subs, where),
+    :subselect_uniquesubquery_engine(thd_arg, tab_arg, subs, where),
      check_null(chk_null),
      having(having_arg)
   {}
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index 28a9a1f4dbf..41f0dd6496b 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -1158,7 +1158,7 @@ double Item_sum_avg::val_real()
 
 my_decimal *Item_sum_avg::val_decimal(my_decimal *val)
 {
-  my_decimal sum, cnt;
+  my_decimal sum_buff, cnt;
   const my_decimal *sum_dec;
   DBUG_ASSERT(fixed == 1);
   if (!count)
@@ -1166,7 +1166,7 @@ my_decimal *Item_sum_avg::val_decimal(my_decimal *val)
     null_value=1;
     return NULL;
   }
-  sum_dec= Item_sum_sum::val_decimal(&sum);
+  sum_dec= Item_sum_sum::val_decimal(&sum_buff);
   int2my_decimal(E_DEC_FATAL_ERROR, count, 0, &cnt);
   my_decimal_div(E_DEC_FATAL_ERROR, val, sum_dec, &cnt, prec_increment);
   return val;
@@ -1609,7 +1609,7 @@ bool Item_sum_min::add()
   break;
   case DECIMAL_RESULT:
   {
-    my_decimal value, *val= args[0]->val_decimal(&value);
+    my_decimal value_buff, *val= args[0]->val_decimal(&value_buff);
     if (!args[0]->null_value &&
         (null_value || (my_decimal_cmp(&sum_dec, val) > 0)))
     {
@@ -1673,7 +1673,7 @@ bool Item_sum_max::add()
   break;
   case DECIMAL_RESULT:
   {
-    my_decimal value, *val= args[0]->val_decimal(&value);
+    my_decimal value_buff, *val= args[0]->val_decimal(&value_buff);
     if (!args[0]->null_value &&
         (null_value || (my_decimal_cmp(val, &sum_dec) > 0)))
     {
@@ -1838,7 +1838,7 @@ void Item_sum_hybrid::reset_field()
   }
   case DECIMAL_RESULT:
   {
-    my_decimal value, *arg_dec= args[0]->val_decimal(&value);
+    my_decimal value_buff, *arg_dec= args[0]->val_decimal(&value_buff);
 
     if (maybe_null)
     {
@@ -2466,11 +2466,11 @@ bool Item_sum_count_distinct::setup(THD *thd)
     for (tree_key_length= 0; field < field_end; ++field)
     {
       Field *f= *field;
-      enum enum_field_types type= f->type();
+      enum enum_field_types f_type= f->type();
       tree_key_length+= f->pack_length();
-      if ((type == MYSQL_TYPE_VARCHAR) ||
-          !f->binary() && (type == MYSQL_TYPE_STRING ||
-                           type == MYSQL_TYPE_VAR_STRING))
+      if ((f_type == MYSQL_TYPE_VARCHAR) ||
+          !f->binary() && (f_type == MYSQL_TYPE_STRING ||
+                           f_type == MYSQL_TYPE_VAR_STRING))
       {
         all_binary= FALSE;
         break;
@@ -3053,8 +3053,6 @@ Item_func_group_concat::Item_func_group_concat(THD *thd,
 
 void Item_func_group_concat::cleanup()
 {
-  THD *thd= current_thd;
-
   DBUG_ENTER("Item_func_group_concat::cleanup");
   Item_sum::cleanup();
 
@@ -3063,7 +3061,7 @@ void Item_func_group_concat::cleanup()
   {
     char warn_buff[MYSQL_ERRMSG_SIZE];
     sprintf(warn_buff, ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
-    warning->set_msg(thd, warn_buff);
+    warning->set_msg(current_thd, warn_buff);
     warning= 0;
   }
 
@@ -3093,8 +3091,7 @@ void Item_func_group_concat::cleanup()
         warning= 0;
       }
     }
-    DBUG_ASSERT(tree == 0);
-    DBUG_ASSERT(warning == 0);
+    DBUG_ASSERT(tree == 0 && warning == 0);
   }
   DBUG_VOID_RETURN;
 }
diff --git a/sql/item_timefunc.cc b/sql/item_timefunc.cc
index 737064a9713..683cd8803d6 100644
--- a/sql/item_timefunc.cc
+++ b/sql/item_timefunc.cc
@@ -1167,14 +1167,14 @@ String* Item_func_dayname::val_str(String* str)
 {
   DBUG_ASSERT(fixed == 1);
   uint weekday=(uint) val_int();		// Always Item_func_daynr()
-  const char *name;
+  const char *day_name;
   THD *thd= current_thd;
 
   if (null_value)
     return (String*) 0;
   
-  name= thd->variables.lc_time_names->day_names->type_names[weekday];
-  str->set(name, strlen(name), system_charset_info);
+  day_name= thd->variables.lc_time_names->day_names->type_names[weekday];
+  str->set(day_name, strlen(day_name), system_charset_info);
   return str;
 }
 
@@ -1608,7 +1608,7 @@ int Item_func_now::save_in_field(Field *to, bool no_conversions)
 void Item_func_sysdate_local::store_now_in_TIME(TIME *now_time)
 {
   THD *thd= current_thd;
-  thd->variables.time_zone->gmt_sec_to_TIME(now_time, time(NULL));
+  thd->variables.time_zone->gmt_sec_to_TIME(now_time, (my_time_t) time(NULL));
   thd->time_zone_used= 1;
 }
 
@@ -3302,10 +3302,10 @@ bool Item_func_str_to_date::get_date(TIME *ltime, uint fuzzy_date)
 {
   DATE_TIME_FORMAT date_time_format;
   char val_buff[64], format_buff[64];
-  String val_str(val_buff, sizeof(val_buff), &my_charset_bin), *val;
+  String val_string(val_buff, sizeof(val_buff), &my_charset_bin), *val;
   String format_str(format_buff, sizeof(format_buff), &my_charset_bin), *format;
 
-  val=    args[0]->val_str(&val_str);
+  val=    args[0]->val_str(&val_string);
   format= args[1]->val_str(&format_str);
   if (args[0]->null_value || args[1]->null_value)
     goto null_date;
diff --git a/sql/log.cc b/sql/log.cc
index 9b47de05c86..7d0bef5ca2c 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -117,7 +117,7 @@ static int binlog_prepare(THD *thd, bool all)
     do nothing.
     just pretend we can do 2pc, so that MySQL won't
     switch to 1pc.
-    real work will be done in MYSQL_LOG::log()
+    real work will be done in MYSQL_LOG::log_xid()
   */
   return 0;
 }
@@ -131,7 +131,7 @@ static int binlog_commit(THD *thd, bool all)
 
   if (my_b_tell(trans_log) == 0)
   {
-    // we're here because trans_log was flushed in MYSQL_LOG::log()
+    // we're here because trans_log was flushed in MYSQL_LOG::log_xid()
     DBUG_RETURN(0);
   }
   if (all) 
@@ -304,7 +304,7 @@ void setup_windows_event_source()
 
   /* Register EventMessageFile */
   dwError = RegSetValueEx(hRegKey, "EventMessageFile", 0, REG_EXPAND_SZ,
-                          (PBYTE) szPath, strlen(szPath)+1);
+                          (PBYTE) szPath, (DWORD) (strlen(szPath) + 1));
 
   /* Register supported event types */
   dwTypes= (EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE |
@@ -758,6 +758,8 @@ int MYSQL_LOG::raw_get_current_log(LOG_INFO* linfo)
     0	ok
 */
 
+#ifdef HAVE_REPLICATION
+
 static bool copy_up_file_and_fill(IO_CACHE *index_file, my_off_t offset)
 {
   int bytes_read;
@@ -791,6 +793,7 @@ err:
   DBUG_RETURN(1);
 }
 
+#endif /* HAVE_REPLICATION */
 
 /*
   Find the position in the log-index-file for the given log name
@@ -1267,8 +1270,6 @@ err:
   pthread_mutex_unlock(&LOCK_index);
   DBUG_RETURN(error);
 }
-
-
 #endif /* HAVE_REPLICATION */
 
 
@@ -1577,13 +1578,13 @@ bool MYSQL_LOG::flush_and_sync()
   return err;
 }
 
-void MYSQL_LOG::start_union_events(THD *thd)
+void MYSQL_LOG::start_union_events(THD *thd, query_id_t query_id_param)
 {
   DBUG_ASSERT(!thd->binlog_evt_union.do_union);
   thd->binlog_evt_union.do_union= TRUE;
   thd->binlog_evt_union.unioned_events= FALSE;
   thd->binlog_evt_union.unioned_events_trans= FALSE;
-  thd->binlog_evt_union.first_query_id= thd->query_id;
+  thd->binlog_evt_union.first_query_id= query_id_param;
 }
 
 void MYSQL_LOG::stop_union_events(THD *thd)
@@ -1628,14 +1629,14 @@ bool MYSQL_LOG::write(Log_event *event_info)
   */
   if (likely(is_open()))
   {
-    const char *local_db= event_info->get_db();
     IO_CACHE *file= &log_file;
 #ifdef HAVE_REPLICATION
     /*
-       In the future we need to add to the following if tests like
-       "do the involved tables match (to be implemented)
-        binlog_[wild_]{do|ignore}_table?" (WL#1049)"
+      In the future we need to add to the following if tests like
+      "do the involved tables match (to be implemented)
+      binlog_[wild_]{do|ignore}_table?" (WL#1049)"
     */
+    const char *local_db= event_info->get_db();
     if ((thd && !(thd->options & OPTION_BIN_LOG)) ||
 	(!db_ok(local_db, binlog_do_db, binlog_ignore_db)))
     {
@@ -1783,7 +1784,7 @@ void MYSQL_LOG::rotate_and_purge(uint flags)
 #ifdef HAVE_REPLICATION
     if (expire_logs_days)
     {
-      long purge_time= time(0) - expire_logs_days*24*60*60;
+      long purge_time= (long) (time(0) - expire_logs_days*24*60*60);
       if (purge_time >= 0)
         purge_logs_before_date(purge_time);
     }
@@ -2523,7 +2524,7 @@ int TC_LOG_MMAP::open(const char *opt_name)
       goto err;
     if (using_heuristic_recover())
       return 1;
-    if ((fd= my_create(logname, O_RDWR, 0, MYF(MY_WME))) < 0)
+    if ((fd= my_create(logname, CREATE_MODE, O_RDWR, MYF(MY_WME))) < 0)
       goto err;
     inited=1;
     file_length= opt_tc_log_size;
@@ -2670,21 +2671,34 @@ int TC_LOG_MMAP::overflow()
 }
 
 /*
-  all access to active page is serialized but it's not a problem, as
-  we're assuming that fsync() will be a main bottleneck.
-  That is, parallelizing writes to log pages we'll decrease number of
-  threads waiting for a page, but then all these threads will be waiting
-  for a fsync() anyway
+  Record that transaction XID is committed on the persistent storage
+
+  NOTES
+    This function is called in the middle of two-phase commit:
+    First all resources prepare the transaction, then tc_log->log() is called,
+    then all resources commit the transaction, then tc_log->unlog() is called.
+
+    All access to active page is serialized but it's not a problem, as
+    we're assuming that fsync() will be a main bottleneck.
+    That is, parallelizing writes to log pages we'll decrease number of
+    threads waiting for a page, but then all these threads will be waiting
+    for a fsync() anyway
+
+  IMPLEMENTATION
+   If tc_log == MYSQL_LOG then tc_log writes transaction to binlog and
+   records XID in a special Xid_log_event.
+   If tc_log = TC_LOG_MMAP then xid is written in a special memory-mapped
+   log.
 
   RETURN
-         0  - error
-  otherwise - "cookie", a number that will be passed as an argument
-              to unlog() call. tc_log can define it any way it wants,
-              and use for whatever purposes. TC_LOG_MMAP sets it
-              to the position in memory where xid was logged to.
+    0  Error
+    #  "cookie", a number that will be passed as an argument
+       to unlog() call. tc_log can define it any way it wants,
+       and use for whatever purposes. TC_LOG_MMAP sets it
+       to the position in memory where xid was logged to.
 */
 
-int TC_LOG_MMAP::log(THD *thd, my_xid xid)
+int TC_LOG_MMAP::log_xid(THD *thd, my_xid xid)
 {
   int err;
   PAGE *p;
@@ -2793,6 +2807,7 @@ int TC_LOG_MMAP::sync()
   erase xid from the page, update page free space counters/pointers.
   cookie points directly to the memory where xid was logged
 */
+
 void TC_LOG_MMAP::unlog(ulong cookie, my_xid xid)
 {
   PAGE *p=pages+(cookie/tc_log_page_size);
@@ -3035,7 +3050,7 @@ void TC_LOG_BINLOG::close()
          0  - error
          1  - success
 */
-int TC_LOG_BINLOG::log(THD *thd, my_xid xid)
+int TC_LOG_BINLOG::log_xid(THD *thd, my_xid xid)
 {
   Xid_log_event xle(thd, xid);
   IO_CACHE *trans_log= (IO_CACHE*)thd->ha_data[binlog_hton.slot];
diff --git a/sql/log_event.cc b/sql/log_event.cc
index 657fd510e78..227b6f0073e 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -269,11 +269,14 @@ append_query_string(CHARSET_INFO *csinfo,
 }
 #endif
 
+
 /*
   Prints a "session_var=value" string. Used by mysqlbinlog to print some SET
   commands just before it prints a query.
 */
 
+#ifdef MYSQL_CLIENT
+
 static void print_set_option(FILE* file, uint32 bits_changed, uint32 option,
                              uint32 flags, const char* name, bool* need_comma) 
 {
@@ -285,6 +288,7 @@ static void print_set_option(FILE* file, uint32 bits_changed, uint32 option,
     *need_comma= 1;
   }
 }
+#endif
 
 /**************************************************************************
 	Log_event methods (= the parent class of all events)
@@ -1088,7 +1092,8 @@ bool Query_log_event::write(IO_CACHE* file)
             1+4+           // code of autoinc and the 2 autoinc variables
             1+6+           // code of charset and charset
             1+1+MAX_TIME_ZONE_NAME_LENGTH+ // code of tz and tz length and tz name
-            1+2            // code of lc_time_names and lc_time_names_number
+            1+2+           // code of lc_time_names and lc_time_names_number
+            1+2            // code of charset_database and charset_database_number
             ], *start, *start_of_status;
   ulong event_length;
 
@@ -1207,6 +1212,13 @@ bool Query_log_event::write(IO_CACHE* file)
     int2store(start, lc_time_names_number);
     start+= 2;
   }
+  if (charset_database_number)
+  {
+    DBUG_ASSERT(charset_database_number <= 0xFFFF);
+    *start++= Q_CHARSET_DATABASE_CODE;
+    int2store(start, charset_database_number);
+    start+= 2;
+  }
   /*
     Here there could be code like
     if (command-line-option-which-says-"log_this_variable" && inited)
@@ -1272,7 +1284,8 @@ Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg,
    sql_mode(thd_arg->variables.sql_mode),
    auto_increment_increment(thd_arg->variables.auto_increment_increment),
    auto_increment_offset(thd_arg->variables.auto_increment_offset),
-   lc_time_names_number(thd_arg->variables.lc_time_names->number)
+   lc_time_names_number(thd_arg->variables.lc_time_names->number),
+   charset_database_number(0)
 {
   time_t end_time;
   time(&end_time);
@@ -1280,6 +1293,9 @@ Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg,
   catalog_len = (catalog) ? (uint32) strlen(catalog) : 0;
   /* status_vars_len is set just before writing the event */
   db_len = (db) ? (uint32) strlen(db) : 0;
+  if (thd_arg->variables.collation_database != thd_arg->db_charset)
+    charset_database_number= thd_arg->variables.collation_database->number;
+  
   /*
     If we don't use flags2 for anything else than options contained in
     thd->options, it would be more efficient to flags2=thd_arg->options
@@ -1350,7 +1366,7 @@ Query_log_event::Query_log_event(const char* buf, uint event_len,
    db(NullS), catalog_len(0), status_vars_len(0),
    flags2_inited(0), sql_mode_inited(0), charset_inited(0),
    auto_increment_increment(1), auto_increment_offset(1),
-   time_zone_len(0), lc_time_names_number(0)
+   time_zone_len(0), lc_time_names_number(0), charset_database_number(0)
 {
   ulong data_len;
   uint32 tmp;
@@ -1455,6 +1471,10 @@ Query_log_event::Query_log_event(const char* buf, uint event_len,
       lc_time_names_number= uint2korr(pos);
       pos+= 2;
       break;
+    case Q_CHARSET_DATABASE_CODE:
+      charset_database_number= uint2korr(pos);
+      pos+= 2;
+      break;
     default:
       /* That's why you must write status vars in growing order of code */
       DBUG_PRINT("info",("Query_log_event has unknown status vars (first has\
@@ -1652,6 +1672,16 @@ void Query_log_event::print_query_header(FILE* file,
             lc_time_names_number, print_event_info->delimiter);
     print_event_info->lc_time_names_number= lc_time_names_number;
   }
+  if (charset_database_number != print_event_info->charset_database_number)
+  {
+    if (charset_database_number)
+      fprintf(file, "SET @@session.collation_database=%d%s\n",
+              charset_database_number, print_event_info->delimiter);
+    else
+      fprintf(file, "SET @@session.collation_database=DEFAULT%s\n",
+              print_event_info->delimiter);
+    print_event_info->charset_database_number= charset_database_number;
+  }
 }
 
 
@@ -1817,7 +1847,21 @@ int Query_log_event::exec_event(struct st_relay_log_info* rli,
       }
       else
         thd->variables.lc_time_names= &my_locale_en_US;
-
+      if (charset_database_number)
+      {
+        CHARSET_INFO *cs;
+        if (!(cs= get_charset(charset_database_number, MYF(0))))
+        {
+          char buf[20];
+          int10_to_str((int) charset_database_number, buf, -10);
+          my_error(ER_UNKNOWN_COLLATION, MYF(0), buf);
+          goto compare_errors;
+        }
+        thd->variables.collation_database= cs;
+      }
+      else
+        thd->variables.collation_database= thd->db_charset;
+      
       /* Execute the query (note that we bypass dispatch_command()) */
       mysql_parse(thd, thd->query, thd->query_length);
 
@@ -2047,6 +2091,8 @@ Start_log_event_v3::Start_log_event_v3(const char* buf,
   binlog_version= uint2korr(buf+ST_BINLOG_VER_OFFSET);
   memcpy(server_version, buf+ST_SERVER_VER_OFFSET,
 	 ST_SERVER_VER_LEN);
+  // prevent overrun if log is corrupted on disk
+  server_version[ST_SERVER_VER_LEN-1]= 0;
   created= uint4korr(buf+ST_CREATED_OFFSET);
   /* We use log_pos to mark if this was an artificial event or not */
   artificial_event= (log_pos == 0);
@@ -2170,6 +2216,8 @@ Format_description_log_event(uint8 binlog_ver, const char* server_ver)
   switch (binlog_ver) {
   case 4: /* MySQL 5.0 */
     memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
+    DBUG_EXECUTE_IF("pretend_version_50034_in_binlog",
+                    strmov(server_version, "5.0.34"););
     common_header_len= LOG_EVENT_HEADER_LEN;
     number_of_event_types= LOG_EVENT_TYPES;
     /* we'll catch my_malloc() error in is_valid() */
@@ -2241,6 +2289,7 @@ Format_description_log_event(uint8 binlog_ver, const char* server_ver)
     post_header_len= 0; /* will make is_valid() fail */
     break;
   }
+  calc_server_version_split();
 }
 
 
@@ -2280,6 +2329,7 @@ Format_description_log_event(const char* buf,
   post_header_len= (uint8*) my_memdup((byte*)buf+ST_COMMON_HEADER_LEN_OFFSET+1,
                                       number_of_event_types*
                                       sizeof(*post_header_len), MYF(0));
+  calc_server_version_split();
   DBUG_VOID_RETURN;
 }
 
@@ -2380,6 +2430,37 @@ int Format_description_log_event::exec_event(struct st_relay_log_info* rli)
 }
 #endif
 
+
+/**
+   Splits the event's 'server_version' string into three numeric pieces stored
+   into 'server_version_split':
+   X.Y.Zabc (X,Y,Z numbers, a not a digit) -> {X,Y,Z}
+   X.Yabc -> {X,Y,0}
+   Xabc -> {X,0,0}
+   'server_version_split' is then used for lookups to find if the server which
+   created this event has some known bug.
+*/
+void Format_description_log_event::calc_server_version_split()
+{
+  char *p= server_version, *r;
+  ulong number;
+  for (uint i= 0; i<=2; i++)
+  {
+    number= strtoul(p, &r, 10);
+    server_version_split[i]= (uchar)number;
+    DBUG_ASSERT(number < 256); // fit in uchar
+    p= r;
+    DBUG_ASSERT(!((i == 0) && (*r != '.'))); // should be true in practice
+    if (*r == '.')
+      p++; // skip the dot
+  }
+  DBUG_PRINT("info",("Format_description_log_event::server_version_split:"
+                     " '%s' %d %d %d", server_version,
+                     server_version_split[0],
+                     server_version_split[1], server_version_split[2]));
+}
+
+
   /**************************************************************************
         Load_log_event methods
    General note about Load_log_event: the binlogging of LOAD DATA INFILE is
@@ -3036,7 +3117,6 @@ int Load_log_event::exec_event(NET* net, struct st_relay_log_info* rli,
       thd->main_lex.select_lex.context.resolve_in_table_list_only(&tables);
       set_fields(tables.db, field_list, &thd->main_lex.select_lex.context);
       thd->variables.pseudo_thread_id= thread_id;
-      List<Item> set_fields;
       if (net)
       {
 	// mysql_load will use thd->net to read the file
@@ -3047,10 +3127,11 @@ int Load_log_event::exec_event(NET* net, struct st_relay_log_info* rli,
 	thd->net.pkt_nr = net->pkt_nr;
       }
       /*
-        It is safe to use set_fields twice because we are not going to
+        It is safe to use tmp_list twice because we are not going to
         update it inside mysql_load().
       */
-      if (mysql_load(thd, &ex, &tables, field_list, set_fields, set_fields,
+      List<Item> tmp_list;
+      if (mysql_load(thd, &ex, &tables, field_list, tmp_list, tmp_list,
                      handle_dup, ignore, net != 0))
         thd->query_error= 1;
       if (thd->cuted_fields)
diff --git a/sql/log_event.h b/sql/log_event.h
index fd2a5e5fb63..a1e7adb6487 100644
--- a/sql/log_event.h
+++ b/sql/log_event.h
@@ -272,6 +272,7 @@ struct sql_ex_info
 
 #define Q_LC_TIME_NAMES_CODE    7
 
+#define Q_CHARSET_DATABASE_CODE 8
 /* Intvar event post-header */
 
 #define I_TYPE_OFFSET        0
@@ -509,10 +510,11 @@ typedef struct st_print_event_info
   char charset[6]; // 3 variables, each of them storable in 2 bytes
   char time_zone_str[MAX_TIME_ZONE_NAME_LENGTH];
   uint lc_time_names_number;
+  uint charset_database_number;
   st_print_event_info()
     :flags2_inited(0), sql_mode_inited(0),
      auto_increment_increment(1),auto_increment_offset(1), charset_inited(0),
-     lc_time_names_number(0)
+     lc_time_names_number(0), charset_database_number(0)
     {
       /*
         Currently we only use static PRINT_EVENT_INFO objects, so zeroed at
@@ -797,6 +799,7 @@ public:
   uint time_zone_len; /* 0 means uninited */
   const char *time_zone_str;
   uint lc_time_names_number; /* 0 means en_US */
+  uint charset_database_number;
 
 #ifndef MYSQL_CLIENT
 
@@ -854,6 +857,8 @@ public:
 
   bool write(IO_CACHE* file) { return(false); };
   virtual bool write_post_header_for_derived(IO_CACHE* file) { return FALSE; }
+#else
+  Muted_query_log_event() {}
 #endif
 };
 
@@ -1102,6 +1107,7 @@ public:
   uint8 number_of_event_types;
   /* The list of post-headers' lengthes */
   uint8 *post_header_len;
+  uchar server_version_split[3];
 
   Format_description_log_event(uint8 binlog_ver, const char* server_ver=0);
 
@@ -1133,6 +1139,7 @@ public:
     */
     return FORMAT_DESCRIPTION_HEADER_LEN;
   }
+  void calc_server_version_split();
 };
 
 
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index fb3ac00fd62..6667795f5f0 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -60,10 +60,10 @@ typedef ulonglong nested_join_map;
 
 /* query_id */
 typedef ulonglong query_id_t;
-extern query_id_t query_id;
+extern query_id_t global_query_id;
 
 /* increment query_id and return it.  */
-inline query_id_t next_query_id() { return query_id++; }
+inline query_id_t next_query_id() { return global_query_id++; }
 
 /* useful constants */
 extern const key_map key_map_empty;
@@ -97,6 +97,18 @@ void net_set_read_timeout(NET *net, uint timeout);
 #define PREV_BITS(type,A)	((type) (((type) 1 << (A)) -1))
 #define all_bits_set(A,B) ((A) & (B) != (B))
 
+#define WARN_DEPRECATED(Thd,Ver,Old,New)                                             \
+  do {                                                                               \
+    DBUG_ASSERT(strncmp(Ver, MYSQL_SERVER_VERSION, sizeof(Ver)-1) > 0);              \
+    if (((gptr)Thd) != NULL)                                                         \
+      push_warning_printf(((THD *)Thd), MYSQL_ERROR::WARN_LEVEL_WARN,                \
+                        ER_WARN_DEPRECATED_SYNTAX, ER(ER_WARN_DEPRECATED_SYNTAX),    \
+                        (Old), (Ver), (New));                                        \
+    else                                                                             \
+      sql_print_warning("The syntax %s is deprecated and will be removed "           \
+                        "in MySQL %s. Please use %s instead.", (Old), (Ver), (New)); \
+  } while(0)
+
 extern CHARSET_INFO *system_charset_info, *files_charset_info ;
 extern CHARSET_INFO *national_charset_info, *table_alias_charset;
 
@@ -163,7 +175,7 @@ MY_LOCALE *my_locale_by_number(uint number);
  Feel free to raise this by the smallest amount you can to get the
  "execution_constants" test to pass.
  */
-#define STACK_MIN_SIZE          10788   // Abort if less stack during eval.
+#define STACK_MIN_SIZE          12000   // Abort if less stack during eval.
 
 #define STACK_MIN_SIZE_FOR_OPEN 1024*80
 #define STACK_BUFF_ALLOC	256	// For stack overrun checks
@@ -754,6 +766,8 @@ int setup_order(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
 int setup_group(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
 		List<Item> &fields, List<Item> &all_fields, ORDER *order,
 		bool *hidden_group_fields);
+bool fix_inner_refs(THD *thd, List<Item> &all_fields, SELECT_LEX *select,
+                   Item **ref_pointer_array);
 
 bool handle_select(THD *thd, LEX *lex, select_result *result,
                    ulong setup_tables_done_option);
@@ -1201,7 +1215,7 @@ void my_dbopt_free(void);
   External variables
 */
 
-extern time_t start_time;
+extern time_t server_start_time;
 extern char *mysql_data_home,server_version[SERVER_VERSION_LENGTH],
 	    mysql_real_data_home[], *opt_mysql_tmpdir, mysql_charsets_dir[],
             def_ft_boolean_syntax[sizeof(ft_boolean_syntax)];
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index b260394e50d..2bdd7d1a11d 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -319,9 +319,14 @@ static char *my_bind_addr_str;
 static char *default_collation_name;
 static char compiled_default_collation_name[]= MYSQL_DEFAULT_COLLATION_NAME;
 static char mysql_data_home_buff[2];
-static struct passwd *user_info;
 static I_List<THD> thread_cache;
 
+#ifndef EMBEDDED_LIBRARY
+static struct passwd *user_info;
+static pthread_t select_thread;
+static uint thr_kill_signal;
+#endif
+
 static pthread_cond_t COND_thread_cache, COND_flush_thread_cache;
 
 #ifdef HAVE_BERKELEY_DB
@@ -350,6 +355,8 @@ my_bool opt_safe_user_create = 0, opt_no_mix_types = 0;
 my_bool opt_show_slave_auth_info, opt_sql_bin_update = 0;
 my_bool opt_log_slave_updates= 0;
 my_bool	opt_innodb;
+bool slave_warning_issued = false; 
+
 #ifdef HAVE_NDBCLUSTER_DB
 const char *opt_ndbcluster_connectstring= 0;
 const char *opt_ndb_connectstring= 0;
@@ -396,7 +403,7 @@ ulong slave_net_timeout, slave_trans_retries;
 ulong thread_cache_size=0, binlog_cache_size=0, max_binlog_cache_size=0;
 ulong query_cache_size=0;
 ulong refresh_version, flush_version;	/* Increments on each reload */
-query_id_t query_id;
+query_id_t global_query_id;
 ulong aborted_threads, aborted_connects;
 ulong delayed_insert_timeout, delayed_insert_limit, delayed_queue_size;
 ulong delayed_insert_threads, delayed_insert_writes, delayed_rows_in_use;
@@ -428,7 +435,7 @@ ulong rpl_recovery_rank=0;
 
 double log_10[32];			/* 10 potences */
 double log_01[32];
-time_t start_time;
+time_t server_start_time;
 
 char mysql_home[FN_REFLEN], pidfile_name[FN_REFLEN], system_time_zone[30];
 char *default_tz_name;
@@ -519,7 +526,6 @@ rw_lock_t	LOCK_grant, LOCK_sys_init_connect, LOCK_sys_init_slave;
 pthread_cond_t COND_refresh,COND_thread_count, COND_global_read_lock;
 pthread_t signal_thread;
 pthread_attr_t connection_attrib;
-static uint thr_kill_signal;
 
 File_parser_dummy_hook file_parser_dummy_hook;
 
@@ -547,7 +553,6 @@ static char **defaults_argv;
 static char *opt_bin_logname;
 
 static my_socket unix_sock,ip_sock;
-static pthread_t select_thread;
 struct rand_struct sql_rand; // used by sql_class.cc:THD::THD()
 
 /* OS specific variables */
@@ -630,7 +635,6 @@ struct st_VioSSLFd *ssl_acceptor_fd;
 
 /* Function declarations */
 
-static void start_signal_handler(void);
 pthread_handler_t signal_hand(void *arg);
 static void mysql_init_variables(void);
 static void get_options(int argc,char **argv);
@@ -641,7 +645,6 @@ static void fix_paths(void);
 pthread_handler_t handle_connections_sockets(void *arg);
 pthread_handler_t kill_server_thread(void *arg);
 static void bootstrap(FILE *file);
-static void close_server_sock();
 static bool read_init_file(char *file_name);
 #ifdef __NT__
 pthread_handler_t handle_connections_namedpipes(void *arg);
@@ -652,10 +655,16 @@ pthread_handler_t handle_connections_shared_memory(void *arg);
 pthread_handler_t handle_slave(void *arg);
 static ulong find_bit_type(const char *x, TYPELIB *bit_lib);
 static void clean_up(bool print_message);
+static int test_if_case_insensitive(const char *dir_name);
+
+#ifndef EMBEDDED_LIBRARY
+static void start_signal_handler(void);
+static void close_server_sock();
 static void clean_up_mutexes(void);
 static void wait_for_signal_thread_to_end(void);
-static int test_if_case_insensitive(const char *dir_name);
 static void create_pid_file();
+#endif
+
 
 #ifndef EMBEDDED_LIBRARY
 /****************************************************************************
@@ -844,7 +853,6 @@ static void close_connections(void)
   DBUG_PRINT("quit",("close_connections thread"));
   DBUG_VOID_RETURN;
 }
-#endif /*EMBEDDED_LIBRARY*/
 
 
 static void close_server_sock()
@@ -887,12 +895,14 @@ static void close_server_sock()
 #endif
 }
 
+#endif /*EMBEDDED_LIBRARY*/
+
 
 void kill_mysql(void)
 {
   DBUG_ENTER("kill_mysql");
 
-#ifdef SIGNALS_DONT_BREAK_READ
+#if defined(SIGNALS_DONT_BREAK_READ) && !defined(EMBEDDED_LIBRARY)
   abort_loop=1;					// Break connection loops
   close_server_sock();				// Force accept to wake up
 #endif
@@ -972,7 +982,7 @@ static void __cdecl kill_server(int sig_ptr)
   kill_in_progress=TRUE;
   abort_loop=1;					// This should be set
   if (sig != 0) // 0 is not a valid signal number
-    my_sigset(sig,SIG_IGN);
+    my_sigset(sig, SIG_IGN);                    /* purify inspected */
   if (sig == MYSQL_KILL_SIGNAL || sig == 0)
     sql_print_information(ER(ER_NORMAL_SHUTDOWN),my_progname);
   else
@@ -1194,6 +1204,8 @@ void clean_up(bool print_message)
 } /* clean_up */
 
 
+#ifndef EMBEDDED_LIBRARY
+
 /*
   This is mainly needed when running with purify, but it's still nice to
   know that all child threads have died when mysqld exits
@@ -1262,6 +1274,9 @@ static void clean_up_mutexes()
   (void) pthread_cond_destroy(&COND_manager);
 }
 
+#endif /*EMBEDDED_LIBRARY*/
+
+
 /****************************************************************************
 ** Init IP and UNIX socket
 ****************************************************************************/
@@ -1296,7 +1311,7 @@ static void set_ports()
 static struct passwd *check_user(const char *user)
 {
 #if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
-  struct passwd *user_info;
+  struct passwd *tmp_user_info;
   uid_t user_id= geteuid();
 
   // Don't bother if we aren't superuser
@@ -1304,12 +1319,14 @@ static struct passwd *check_user(const char *user)
   {
     if (user)
     {
-      // Don't give a warning, if real user is same as given with --user
-      user_info= getpwnam(user);
-      if ((!user_info || user_id != user_info->pw_uid) &&
+      /* Don't give a warning, if real user is same as given with --user */
+      /* purecov: begin tested */
+      tmp_user_info= getpwnam(user);
+      if ((!tmp_user_info || user_id != tmp_user_info->pw_uid) &&
 	  global_system_variables.log_warnings)
         sql_print_warning(
                     "One can only use the --user switch if running as root\n");
+      /* purecov: end */    
     }
     return NULL;
   }
@@ -1322,23 +1339,25 @@ static struct passwd *check_user(const char *user)
     }
     return NULL;
   }
+  /* purecov: begin tested */
   if (!strcmp(user,"root"))
     return NULL;                        // Avoid problem with dynamic libraries
 
-  if (!(user_info= getpwnam(user)))
+  if (!(tmp_user_info= getpwnam(user)))
   {
     // Allow a numeric uid to be used
     const char *pos;
     for (pos= user; my_isdigit(mysqld_charset,*pos); pos++) ;
     if (*pos)                                   // Not numeric id
       goto err;
-    if (!(user_info= getpwuid(atoi(user))))
+    if (!(tmp_user_info= getpwuid(atoi(user))))
       goto err;
     else
-      return user_info;
+      return tmp_user_info;
   }
   else
-    return user_info;
+    return tmp_user_info;
+  /* purecov: end */    
 
 err:
   sql_print_error("Fatal error: Can't change to run as user '%s' ;  Please check that the user exists!\n",user);
@@ -1347,10 +1366,11 @@ err:
   return NULL;
 }
 
-static void set_user(const char *user, struct passwd *user_info)
+static void set_user(const char *user, struct passwd *user_info_arg)
 {
+  /* purecov: begin tested */
 #if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
-  DBUG_ASSERT(user_info != 0);
+  DBUG_ASSERT(user_info_arg != 0);
 #ifdef HAVE_INITGROUPS
   /*
     We can get a SIGSEGV when calling initgroups() on some systems when NSS
@@ -1359,33 +1379,34 @@ static void set_user(const char *user, struct passwd *user_info)
     output a specific message to help the user resolve this problem.
   */
   calling_initgroups= TRUE;
-  initgroups((char*) user, user_info->pw_gid);
+  initgroups((char*) user, user_info_arg->pw_gid);
   calling_initgroups= FALSE;
 #endif
-  if (setgid(user_info->pw_gid) == -1)
+  if (setgid(user_info_arg->pw_gid) == -1)
   {
     sql_perror("setgid");
     unireg_abort(1);
   }
-  if (setuid(user_info->pw_uid) == -1)
+  if (setuid(user_info_arg->pw_uid) == -1)
   {
     sql_perror("setuid");
     unireg_abort(1);
   }
 #endif
+  /* purecov: end */    
 }
 
 
-static void set_effective_user(struct passwd *user_info)
+static void set_effective_user(struct passwd *user_info_arg)
 {
 #if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
-  DBUG_ASSERT(user_info != 0);
-  if (setregid((gid_t)-1, user_info->pw_gid) == -1)
+  DBUG_ASSERT(user_info_arg != 0);
+  if (setregid((gid_t)-1, user_info_arg->pw_gid) == -1)
   {
     sql_perror("setregid");
     unireg_abort(1);
   }
-  if (setreuid((uid_t)-1, user_info->pw_uid) == -1)
+  if (setreuid((uid_t)-1, user_info_arg->pw_uid) == -1)
   {
     sql_perror("setreuid");
     unireg_abort(1);
@@ -1732,6 +1753,7 @@ extern "C" sig_handler abort_thread(int sig __attribute__((unused)))
   the signal thread is ready before continuing
 ******************************************************************************/
 
+
 #if defined(__WIN__) || defined(OS2)
 static void init_signals(void)
 {
@@ -1972,6 +1994,7 @@ static void init_signals(void)
 
 }
 
+
 static void start_signal_handler(void)
 {
   // Save vm id of this process
@@ -2023,6 +2046,7 @@ static void init_signals(void)
   signal_thread = pthread_self();
 }
 
+
 static void start_signal_handler(void)
 {}
 
@@ -2154,6 +2178,8 @@ bugs.\n");
 #define SA_NODEFER 0
 #endif
 
+#ifndef EMBEDDED_LIBRARY
+
 static void init_signals(void)
 {
   sigset_t set;
@@ -2232,7 +2258,6 @@ static void init_signals(void)
 }
 
 
-#ifndef EMBEDDED_LIBRARY
 static void start_signal_handler(void)
 {
   int error;
@@ -2396,11 +2421,11 @@ pthread_handler_t signal_hand(void *arg __attribute__((unused)))
   }
   return(0);					/* purecov: deadcode */
 }
-#endif /*!EMBEDDED_LIBRARY*/
 
 static void check_data_home(const char *path)
 {}
 
+#endif /*!EMBEDDED_LIBRARY*/
 #endif	/* __WIN__*/
 
 
@@ -2463,6 +2488,7 @@ static int my_message_sql(uint error, const char *str, myf MyFlags)
 }
 
 
+#ifndef EMBEDDED_LIBRARY
 static void *my_str_malloc_mysqld(size_t size)
 {
   return my_malloc(size, MYF(MY_FAE));
@@ -2473,6 +2499,7 @@ static void my_str_free_mysqld(void *ptr)
 {
   my_free((gptr)ptr, MYF(MY_FAE));
 }
+#endif /* EMBEDDED_LIBRARY */
 
 
 #ifdef __WIN__
@@ -2605,7 +2632,7 @@ static int init_common_variables(const char *conf_file_name, int argc,
   tzset();			// Set tzname
 
   max_system_variables.pseudo_thread_id= (ulong)~0;
-  start_time=time((time_t*) 0);
+  server_start_time= time((time_t*) 0);
   if (init_thread_environment())
     return 1;
   mysql_init_variables();
@@ -2621,7 +2648,7 @@ static int init_common_variables(const char *conf_file_name, int argc,
 #ifdef HAVE_TZNAME
   {
     struct tm tm_tmp;
-    localtime_r(&start_time,&tm_tmp);
+    localtime_r(&server_start_time,&tm_tmp);
     strmake(system_time_zone, tzname[tm_tmp.tm_isdst != 0 ? 1 : 0],
             sizeof(system_time_zone)-1);
 
@@ -3004,6 +3031,8 @@ static void openssl_lock(int mode, openssl_lock_t *lock, const char *file,
 #endif /* HAVE_OPENSSL */
 
 
+#ifndef EMBEDDED_LIBRARY
+
 static void init_ssl()
 {
 #ifdef HAVE_OPENSSL
@@ -3029,6 +3058,7 @@ static void init_ssl()
 #endif /* HAVE_OPENSSL */
 }
 
+#endif /* EMBEDDED_LIBRARY */
 
 static int init_server_components()
 {
@@ -3040,7 +3070,7 @@ static int init_server_components()
   query_cache_set_min_res_unit(query_cache_min_res_unit);
   query_cache_init();
   query_cache_resize(query_cache_size);
-  randominit(&sql_rand,(ulong) start_time,(ulong) start_time/2);
+  randominit(&sql_rand,(ulong) server_start_time,(ulong) server_start_time/2);
   reset_floating_point_exceptions();
   init_thr_lock();
 #ifdef HAVE_REPLICATION
@@ -3210,7 +3240,7 @@ server.");
                                (TC_LOG *) &tc_log_mmap) :
            (TC_LOG *) &tc_log_dummy);
 
-  if (tc_log->open(opt_bin_logname))
+  if (tc_log->open(opt_bin_log ? opt_bin_logname : opt_tc_log_file))
   {
     sql_print_error("Can't init tc log");
     unireg_abort(1);
@@ -3228,7 +3258,7 @@ server.");
 #ifdef HAVE_REPLICATION
   if (opt_bin_log && expire_logs_days)
   {
-    long purge_time= time(0) - expire_logs_days*24*60*60;
+    long purge_time= (long) (time(0) - expire_logs_days*24*60*60);
     if (purge_time >= 0)
       mysql_bin_log.purge_logs_before_date(purge_time);
   }
@@ -3269,6 +3299,7 @@ server.");
 }
 
 
+#ifndef EMBEDDED_LIBRARY
 static void create_maintenance_thread()
 {
   if (
@@ -3286,7 +3317,6 @@ static void create_maintenance_thread()
 
 static void create_shutdown_thread()
 {
-#if !defined(EMBEDDED_LIBRARY)
 #ifdef __WIN__
   hEventShutdown=CreateEvent(0, FALSE, FALSE, shutdown_event_name);
   pthread_t hThread;
@@ -3302,9 +3332,9 @@ static void create_shutdown_thread()
   if (pthread_create(&hThread,&connection_attrib,handle_shutdown,0))
     sql_print_warning("Can't create thread to handle shutdown requests");
 #endif
-#endif // EMBEDDED_LIBRARY
 }
 
+#endif /* EMBEDDED_LIBRARY */
 
 #if defined(__NT__) || defined(HAVE_SMEM)
 static void handle_connections_methods()
@@ -6478,7 +6508,7 @@ static void mysql_init_variables(void)
   protocol_version= PROTOCOL_VERSION;
   what_to_log= ~ (1L << (uint) COM_TIME);
   refresh_version= flush_version= 1L;	/* Increments on each reload */
-  query_id= thread_id= 1L;
+  global_query_id= thread_id= 1L;
   strmov(server_version, MYSQL_SERVER_VERSION);
   myisam_recover_options_str= sql_mode_str= "OFF";
   myisam_stats_method_str= "nulls_unequal";
@@ -6954,6 +6984,29 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
   case (int) OPT_STANDALONE:		/* Dummy option for NT */
     break;
 #endif
+  /*
+    The following change issues a deprecation warning if the slave
+    configuration is specified either in the my.cnf file or on
+    the command-line. See BUG#21490.
+  */
+  case OPT_MASTER_HOST:
+  case OPT_MASTER_USER:
+  case OPT_MASTER_PASSWORD:
+  case OPT_MASTER_PORT:
+  case OPT_MASTER_CONNECT_RETRY:
+  case OPT_MASTER_SSL:          
+  case OPT_MASTER_SSL_KEY:
+  case OPT_MASTER_SSL_CERT:       
+  case OPT_MASTER_SSL_CAPATH:
+  case OPT_MASTER_SSL_CIPHER:
+  case OPT_MASTER_SSL_CA:
+    if (!slave_warning_issued)                 //only show the warning once
+    {
+      slave_warning_issued = true;   
+      WARN_DEPRECATED(NULL, "5.2", "for replication startup options", 
+        "'CHANGE MASTER'");
+    }
+    break;
   case OPT_CONSOLE:
     if (opt_console)
       opt_error_log= 0;			// Force logs to stdout
@@ -7579,6 +7632,8 @@ static int test_if_case_insensitive(const char *dir_name)
 
 /* Create file to store pid number */
 
+#ifndef EMBEDDED_LIBRARY
+
 static void create_pid_file()
 {
   File file;
@@ -7598,7 +7653,7 @@ static void create_pid_file()
   sql_perror("Can't start server: can't create PID file");
   exit(1);
 }
-
+#endif /* EMBEDDED_LIBRARY */
 
 /* Clear most status variables */
 void refresh_status(THD *thd)
diff --git a/sql/net_serv.cc b/sql/net_serv.cc
index 16b36b927d6..ef929bc67f0 100644
--- a/sql/net_serv.cc
+++ b/sql/net_serv.cc
@@ -221,6 +221,8 @@ my_bool net_realloc(NET *net, ulong length)
     -1  Don't know if data is ready or not
 */
 
+#if !defined(EMBEDDED_LIBRARY)
+
 static int net_data_is_ready(my_socket sd)
 {
 #ifdef HAVE_POLL
@@ -255,9 +257,10 @@ static int net_data_is_ready(my_socket sd)
     return 0;
   else
     return test(res ? FD_ISSET(sd, &sfds) : 0);
-#endif
+#endif /* HAVE_POLL */
 }
 
+#endif /* EMBEDDED_LIBRARY */
 
 /*
   Remove unwanted characters from connection
@@ -282,8 +285,11 @@ static int net_data_is_ready(my_socket sd)
 
 void net_clear(NET *net)
 {
+#if !defined(EMBEDDED_LIBRARY)
   int count, ready;
+#endif
   DBUG_ENTER("net_clear");
+
 #if !defined(EMBEDDED_LIBRARY)
   while((ready= net_data_is_ready(net->vio->sd)) > 0)
   {
@@ -293,7 +299,7 @@ void net_clear(NET *net)
     {
       DBUG_PRINT("info",("skipped %d bytes from file: %s",
                          count, vio_description(net->vio)));
-#ifdef EXTRA_DEBUG
+#if defined(EXTRA_DEBUG) && (MYSQL_VERSION_ID < 51000)
       fprintf(stderr,"skipped %d bytes from file: %s\n",
               count, vio_description(net->vio));
 #endif
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index 4838e690dd7..dfb3af87c29 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -499,9 +499,6 @@ TABLE_READ_PLAN *get_best_disjunct_quick(PARAM *param, SEL_IMERGE *imerge,
                                          double read_time);
 static
 TRP_GROUP_MIN_MAX *get_best_group_min_max(PARAM *param, SEL_TREE *tree);
-static int get_index_merge_params(PARAM *param, key_map& needed_reg,
-                           SEL_IMERGE *imerge, double *read_time,
-                           ha_rows* imerge_rows);
 static double get_index_only_read_time(const PARAM* param, ha_rows records,
                                        int keynr);
 
@@ -511,7 +508,6 @@ static void print_sel_tree(PARAM *param, SEL_TREE *tree, key_map *tree_map,
 static void print_ror_scans_arr(TABLE *table, const char *msg,
                                 struct st_ror_scan_info **start,
                                 struct st_ror_scan_info **end);
-static void print_rowid(byte* val, int len);
 static void print_quick(QUICK_SELECT_I *quick, const key_map *needed_reg);
 #endif
 
@@ -823,7 +819,7 @@ QUICK_SELECT_I::QUICK_SELECT_I()
 
 QUICK_RANGE_SELECT::QUICK_RANGE_SELECT(THD *thd, TABLE *table, uint key_nr,
                                        bool no_alloc, MEM_ROOT *parent_alloc)
-  :dont_free(0),error(0),free_file(0),in_range(0),cur_range(NULL),range(0)
+  :dont_free(0),error(0),free_file(0),in_range(0),cur_range(NULL),last_range(0)
 {
   sorted= 0;
   index= key_nr;
@@ -1248,13 +1244,12 @@ int QUICK_ROR_UNION_SELECT::queue_cmp(void *arg, byte *val1, byte *val2)
 
 int QUICK_ROR_UNION_SELECT::reset()
 {
-  QUICK_SELECT_I* quick;
+  QUICK_SELECT_I *quick;
   int error;
   DBUG_ENTER("QUICK_ROR_UNION_SELECT::reset");
   have_prev_rowid= FALSE;
   if (!scans_inited)
   {
-    QUICK_SELECT_I *quick;
     List_iterator_fast<QUICK_SELECT_I> it(quick_selects);
     while ((quick= it++))
     {
@@ -6614,7 +6609,7 @@ int QUICK_RANGE_SELECT::reset()
   byte  *mrange_buff;
   DBUG_ENTER("QUICK_RANGE_SELECT::reset");
   next=0;
-  range= NULL;
+  last_range= NULL;
   in_range= FALSE;
   cur_range= (QUICK_RANGE**) ranges.buffer;
 
@@ -6732,23 +6727,23 @@ int QUICK_RANGE_SELECT::get_next()
     {
       start_key= &mrange_slot->start_key;
       end_key= &mrange_slot->end_key;
-      range= *(cur_range++);
+      last_range= *(cur_range++);
 
-      start_key->key=    (const byte*) range->min_key;
-      start_key->length= range->min_length;
-      start_key->flag=   ((range->flag & NEAR_MIN) ? HA_READ_AFTER_KEY :
-                          (range->flag & EQ_RANGE) ?
+      start_key->key=    (const byte*) last_range->min_key;
+      start_key->length= last_range->min_length;
+      start_key->flag=   ((last_range->flag & NEAR_MIN) ? HA_READ_AFTER_KEY :
+                          (last_range->flag & EQ_RANGE) ?
                           HA_READ_KEY_EXACT : HA_READ_KEY_OR_NEXT);
-      end_key->key=      (const byte*) range->max_key;
-      end_key->length=   range->max_length;
+      end_key->key=      (const byte*) last_range->max_key;
+      end_key->length=   last_range->max_length;
       /*
         We use HA_READ_AFTER_KEY here because if we are reading on a key
         prefix. We want to find all keys with this prefix.
       */
-      end_key->flag=     (range->flag & NEAR_MAX ? HA_READ_BEFORE_KEY :
+      end_key->flag=     (last_range->flag & NEAR_MAX ? HA_READ_BEFORE_KEY :
                           HA_READ_AFTER_KEY);
 
-      mrange_slot->range_flag= range->flag;
+      mrange_slot->range_flag= last_range->flag;
     }
 
     result= file->read_multi_range_first(&mrange, multi_range, count,
@@ -6798,7 +6793,7 @@ int QUICK_RANGE_SELECT::get_next_prefix(uint prefix_length, byte *cur_prefix)
   {
     int result;
     key_range start_key, end_key;
-    if (range)
+    if (last_range)
     {
       /* Read the next record in the same range with prefix after cur_prefix. */
       DBUG_ASSERT(cur_prefix != 0);
@@ -6812,35 +6807,35 @@ int QUICK_RANGE_SELECT::get_next_prefix(uint prefix_length, byte *cur_prefix)
     if (count == 0)
     {
       /* Ranges have already been used up before. None is left for read. */
-      range= 0;
+      last_range= 0;
       DBUG_RETURN(HA_ERR_END_OF_FILE);
     }
-    range= *(cur_range++);
+    last_range= *(cur_range++);
 
-    start_key.key=    (const byte*) range->min_key;
-    start_key.length= min(range->min_length, prefix_length);
-    start_key.flag=   ((range->flag & NEAR_MIN) ? HA_READ_AFTER_KEY :
-		       (range->flag & EQ_RANGE) ?
+    start_key.key=    (const byte*) last_range->min_key;
+    start_key.length= min(last_range->min_length, prefix_length);
+    start_key.flag=   ((last_range->flag & NEAR_MIN) ? HA_READ_AFTER_KEY :
+		       (last_range->flag & EQ_RANGE) ?
 		       HA_READ_KEY_EXACT : HA_READ_KEY_OR_NEXT);
-    end_key.key=      (const byte*) range->max_key;
-    end_key.length=   min(range->max_length, prefix_length);
+    end_key.key=      (const byte*) last_range->max_key;
+    end_key.length=   min(last_range->max_length, prefix_length);
     /*
       We use READ_AFTER_KEY here because if we are reading on a key
       prefix we want to find all keys with this prefix
     */
-    end_key.flag=     (range->flag & NEAR_MAX ? HA_READ_BEFORE_KEY :
+    end_key.flag=     (last_range->flag & NEAR_MAX ? HA_READ_BEFORE_KEY :
 		       HA_READ_AFTER_KEY);
 
-    result= file->read_range_first(range->min_length ? &start_key : 0,
-				   range->max_length ? &end_key : 0,
-                                   test(range->flag & EQ_RANGE),
+    result= file->read_range_first(last_range->min_length ? &start_key : 0,
+				   last_range->max_length ? &end_key : 0,
+                                   test(last_range->flag & EQ_RANGE),
 				   sorted);
-    if (range->flag == (UNIQUE_RANGE | EQ_RANGE))
-      range=0;				// Stop searching
+    if (last_range->flag == (UNIQUE_RANGE | EQ_RANGE))
+      last_range= 0;			// Stop searching
 
     if (result != HA_ERR_END_OF_FILE)
       DBUG_RETURN(result);
-    range=0;				// No matching rows; go to next range
+    last_range= 0;			// No matching rows; go to next range
   }
 }
 
@@ -6854,11 +6849,11 @@ int QUICK_RANGE_SELECT_GEOM::get_next()
   for (;;)
   {
     int result;
-    if (range)
+    if (last_range)
     {
       // Already read through key
-      result= file->index_next_same(record, (byte*) range->min_key,
-				    range->min_length);
+      result= file->index_next_same(record, (byte*) last_range->min_key,
+				    last_range->min_length);
       if (result != HA_ERR_END_OF_FILE)
 	DBUG_RETURN(result);
     }
@@ -6867,18 +6862,18 @@ int QUICK_RANGE_SELECT_GEOM::get_next()
     if (count == 0)
     {
       /* Ranges have already been used up before. None is left for read. */
-      range= 0;
+      last_range= 0;
       DBUG_RETURN(HA_ERR_END_OF_FILE);
     }
-    range= *(cur_range++);
+    last_range= *(cur_range++);
 
     result= file->index_read(record,
-			     (byte*) range->min_key,
-			     range->min_length,
-			     (ha_rkey_function)(range->flag ^ GEOM_FLAG));
+			     (byte*) last_range->min_key,
+			     last_range->min_length,
+			     (ha_rkey_function)(last_range->flag ^ GEOM_FLAG));
     if (result != HA_ERR_KEY_NOT_FOUND)
       DBUG_RETURN(result);
-    range=0;				// Not found, to next range
+    last_range= 0;				// Not found, to next range
   }
 }
 
@@ -6903,7 +6898,7 @@ int QUICK_RANGE_SELECT_GEOM::get_next()
 
 bool QUICK_RANGE_SELECT::row_in_ranges()
 {
-  QUICK_RANGE *range;
+  QUICK_RANGE *res;
   uint min= 0;
   uint max= ranges.elements - 1;
   uint mid= (max + min)/2;
@@ -6919,8 +6914,8 @@ bool QUICK_RANGE_SELECT::row_in_ranges()
       max= mid;
     mid= (min + max) / 2;
   }
-  range= *(QUICK_RANGE**)dynamic_array_ptr(&ranges, mid);
-  return (!cmp_next(range) && !cmp_prev(range));
+  res= *(QUICK_RANGE**)dynamic_array_ptr(&ranges, mid);
+  return (!cmp_next(res) && !cmp_prev(res));
 }
 
 /*
@@ -6934,14 +6929,14 @@ bool QUICK_RANGE_SELECT::row_in_ranges()
  */
 
 QUICK_SELECT_DESC::QUICK_SELECT_DESC(QUICK_RANGE_SELECT *q,
-                                     uint used_key_parts)
+                                     uint used_key_parts_arg)
  : QUICK_RANGE_SELECT(*q), rev_it(rev_ranges)
 {
   QUICK_RANGE *r;
 
   QUICK_RANGE **pr= (QUICK_RANGE**)ranges.buffer;
-  QUICK_RANGE **last_range= pr + ranges.elements;
-  for (; pr!=last_range; pr++)
+  QUICK_RANGE **end_range= pr + ranges.elements;
+  for (; pr!=end_range; pr++)
     rev_ranges.push_front(*pr);
 
   /* Remove EQ_RANGE flag for keys that are not using the full key */
@@ -6975,11 +6970,11 @@ int QUICK_SELECT_DESC::get_next()
   for (;;)
   {
     int result;
-    if (range)
+    if (last_range)
     {						// Already read through key
-      result = ((range->flag & EQ_RANGE)
-		? file->index_next_same(record, (byte*) range->min_key,
-					range->min_length) :
+      result = ((last_range->flag & EQ_RANGE)
+		? file->index_next_same(record, (byte*) last_range->min_key,
+					last_range->min_length) :
 		file->index_prev(record));
       if (!result)
       {
@@ -6990,47 +6985,49 @@ int QUICK_SELECT_DESC::get_next()
 	DBUG_RETURN(result);
     }
 
-    if (!(range=rev_it++))
+    if (!(last_range= rev_it++))
       DBUG_RETURN(HA_ERR_END_OF_FILE);		// All ranges used
 
-    if (range->flag & NO_MAX_RANGE)		// Read last record
+    if (last_range->flag & NO_MAX_RANGE)        // Read last record
     {
       int local_error;
       if ((local_error=file->index_last(record)))
 	DBUG_RETURN(local_error);		// Empty table
-      if (cmp_prev(range) == 0)
+      if (cmp_prev(last_range) == 0)
 	DBUG_RETURN(0);
-      range=0;			// No matching records; go to next range
+      last_range= 0;                            // No match; go to next range
       continue;
     }
 
-    if (range->flag & EQ_RANGE)
+    if (last_range->flag & EQ_RANGE)
     {
-      result = file->index_read(record, (byte*) range->max_key,
-				range->max_length, HA_READ_KEY_EXACT);
+      result= file->index_read(record, (byte*) last_range->max_key,
+                               last_range->max_length, HA_READ_KEY_EXACT);
     }
     else
     {
-      DBUG_ASSERT(range->flag & NEAR_MAX || range_reads_after_key(range));
-      result=file->index_read(record, (byte*) range->max_key,
-			      range->max_length,
-			      ((range->flag & NEAR_MAX) ?
-			       HA_READ_BEFORE_KEY : HA_READ_PREFIX_LAST_OR_PREV));
+      DBUG_ASSERT(last_range->flag & NEAR_MAX ||
+                  range_reads_after_key(last_range));
+      result=file->index_read(record, (byte*) last_range->max_key,
+			      last_range->max_length,
+			      ((last_range->flag & NEAR_MAX) ?
+			       HA_READ_BEFORE_KEY :
+                               HA_READ_PREFIX_LAST_OR_PREV));
     }
     if (result)
     {
       if (result != HA_ERR_KEY_NOT_FOUND)
 	DBUG_RETURN(result);
-      range=0;					// Not found, to next range
+      last_range= 0;                            // Not found, to next range
       continue;
     }
-    if (cmp_prev(range) == 0)
+    if (cmp_prev(last_range) == 0)
     {
-      if (range->flag == (UNIQUE_RANGE | EQ_RANGE))
-	range = 0;				// Stop searching
+      if (last_range->flag == (UNIQUE_RANGE | EQ_RANGE))
+	last_range= 0;				// Stop searching
       DBUG_RETURN(0);				// Found key is in range
     }
-    range = 0;					// To next range
+    last_range= 0;                              // To next range
   }
 }
 
@@ -9514,23 +9511,9 @@ static void print_quick(QUICK_SELECT_I *quick, const key_map *needed_reg)
 }
 
 
-static void print_rowid(byte* val, int len)
-{
-  byte *pb;
-  DBUG_LOCK_FILE;
-  fputc('\"', DBUG_FILE);
-  for (pb= val; pb!= val + len; ++pb)
-    fprintf(DBUG_FILE, "%c", *pb);
-  fprintf(DBUG_FILE, "\", hex: ");
-
-  for (pb= val; pb!= val + len; ++pb)
-    fprintf(DBUG_FILE, "%x ", *pb);
-  fputc('\n', DBUG_FILE);
-  DBUG_UNLOCK_FILE;
-}
-
 void QUICK_RANGE_SELECT::dbug_dump(int indent, bool verbose)
 {
+  /* purecov: begin inspected */
   fprintf(DBUG_FILE, "%*squick range select, key %s, length: %d\n",
 	  indent, "", head->key_info[index].name, max_used_key_length);
 
@@ -9538,8 +9521,8 @@ void QUICK_RANGE_SELECT::dbug_dump(int indent, bool verbose)
   {
     QUICK_RANGE *range;
     QUICK_RANGE **pr= (QUICK_RANGE**)ranges.buffer;
-    QUICK_RANGE **last_range= pr + ranges.elements;
-    for (; pr!=last_range; ++pr)
+    QUICK_RANGE **end_range= pr + ranges.elements;
+    for (; pr != end_range; ++pr)
     {
       fprintf(DBUG_FILE, "%*s", indent + 2, "");
       range= *pr;
@@ -9564,6 +9547,7 @@ void QUICK_RANGE_SELECT::dbug_dump(int indent, bool verbose)
       fputs("\n",DBUG_FILE);
     }
   }
+  /* purecov: end */    
 }
 
 void QUICK_INDEX_MERGE_SELECT::dbug_dump(int indent, bool verbose)
diff --git a/sql/opt_range.h b/sql/opt_range.h
index cbd27d389ad..3a737323eb7 100644
--- a/sql/opt_range.h
+++ b/sql/opt_range.h
@@ -299,7 +299,7 @@ protected:
   DYNAMIC_ARRAY ranges;     /* ordered array of range ptrs */
   QUICK_RANGE **cur_range;  /* current element in ranges  */
 
-  QUICK_RANGE *range;
+  QUICK_RANGE *last_range;
   KEY_PART *key_parts;
   KEY_PART_INFO *key_part_info;
   int cmp_next(QUICK_RANGE *range);
diff --git a/sql/password.c b/sql/password.c
index bb5b2693f26..57ed3e6ab0f 100644
--- a/sql/password.c
+++ b/sql/password.c
@@ -472,7 +472,7 @@ scramble(char *to, const char *message, const char *password)
 */
 
 my_bool
-check_scramble(const char *scramble, const char *message,
+check_scramble(const char *scramble_arg, const char *message,
                const uint8 *hash_stage2)
 {
   SHA1_CONTEXT sha1_context;
@@ -485,7 +485,7 @@ check_scramble(const char *scramble, const char *message,
   mysql_sha1_input(&sha1_context, hash_stage2, SHA1_HASH_SIZE);
   mysql_sha1_result(&sha1_context, buf);
   /* encrypt scramble */
-    my_crypt((char *) buf, buf, (const uchar *) scramble, SCRAMBLE_LENGTH);
+    my_crypt((char *) buf, buf, (const uchar *) scramble_arg, SCRAMBLE_LENGTH);
   /* now buf supposedly contains hash_stage1: so we can get hash_stage2 */
   mysql_sha1_reset(&sha1_context);
   mysql_sha1_input(&sha1_context, buf, SHA1_HASH_SIZE);
@@ -495,7 +495,8 @@ check_scramble(const char *scramble, const char *message,
 
 
 /*
-    Convert scrambled password from asciiz hex string to binary form.
+  Convert scrambled password from asciiz hex string to binary form.
+
   SYNOPSIS
     get_salt_from_password()
     res       OUT buf to hold password. Must be at least SHA1_HASH_SIZE
diff --git a/sql/protocol.cc b/sql/protocol.cc
index 757e7aae026..f9ba734a48d 100644
--- a/sql/protocol.cc
+++ b/sql/protocol.cc
@@ -27,8 +27,10 @@
 #include <stdarg.h>
 
 static const unsigned int PACKET_BUFFER_EXTRA_ALLOC= 1024;
-static void write_eof_packet(THD *thd, NET *net);
 void net_send_error_packet(THD *thd, uint sql_errno, const char *err);
+#ifndef EMBEDDED_LIBRARY
+static void write_eof_packet(THD *thd, NET *net);
+#endif
 
 #ifndef EMBEDDED_LIBRARY
 bool Protocol::net_store_data(const char *from, uint length)
diff --git a/sql/repl_failsafe.cc b/sql/repl_failsafe.cc
index a2e5c3b0894..1dc16b6e566 100644
--- a/sql/repl_failsafe.cc
+++ b/sql/repl_failsafe.cc
@@ -528,11 +528,11 @@ HOSTS";
 
   while ((row= mysql_fetch_row(res)))
   {
-    uint32 server_id;
+    uint32 log_server_id;
     SLAVE_INFO* si, *old_si;
-    server_id = atoi(row[0]);
+    log_server_id = atoi(row[0]);
     if ((old_si= (SLAVE_INFO*)hash_search(&slave_list,
-					  (byte*)&server_id,4)))
+					  (byte*)&log_server_id,4)))
       si = old_si;
     else
     {
@@ -542,7 +542,7 @@ HOSTS";
 	pthread_mutex_unlock(&LOCK_slave_list);
 	goto err;
       }
-      si->server_id = server_id;
+      si->server_id = log_server_id;
       my_hash_insert(&slave_list, (byte*)si);
     }
     strmake(si->host, row[1], sizeof(si->host)-1);
@@ -916,14 +916,14 @@ bool load_master_data(THD* thd)
           setting active_mi, because init_master_info() sets active_mi with
           defaults.
         */
-        int error;
+        int error_2;
 
         if (init_master_info(active_mi, master_info_file, relay_log_info_file, 
 			     0, (SLAVE_IO | SLAVE_SQL)))
           my_message(ER_MASTER_INFO, ER(ER_MASTER_INFO), MYF(0));
 	strmake(active_mi->master_log_name, row[0],
 		sizeof(active_mi->master_log_name));
-	active_mi->master_log_pos= my_strtoll10(row[1], (char**) 0, &error);
+	active_mi->master_log_pos= my_strtoll10(row[1], (char**) 0, &error_2);
         /* at least in recent versions, the condition below should be false */
 	if (active_mi->master_log_pos < BIN_LOG_HEADER_SIZE)
 	  active_mi->master_log_pos = BIN_LOG_HEADER_SIZE;
diff --git a/sql/set_var.cc b/sql/set_var.cc
index b3a9305132a..daccd0469e7 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -82,9 +82,6 @@ TYPELIB delay_key_write_typelib=
   delay_key_write_type_names, NULL
 };
 
-static int sys_check_charset(THD *thd, set_var *var);
-static bool sys_update_charset(THD *thd, set_var *var);
-static void sys_set_default_charset(THD *thd, enum_var_type type);
 static int  sys_check_ftb_syntax(THD *thd,  set_var *var);
 static bool sys_update_ftb_syntax(THD *thd, set_var * var);
 static void sys_default_ftb_syntax(THD *thd, enum_var_type type);
@@ -1424,9 +1421,9 @@ static void fix_server_id(THD *thd, enum_var_type type)
 
 
 sys_var_long_ptr::
-sys_var_long_ptr(const char *name_arg, ulong *value_ptr,
+sys_var_long_ptr(const char *name_arg, ulong *value_ptr_arg,
                  sys_after_update_func after_update_arg)
-  :sys_var_long_ptr_global(name_arg, value_ptr,
+  :sys_var_long_ptr_global(name_arg, value_ptr_arg,
                            &LOCK_global_system_variables, after_update_arg)
 {}
 
@@ -1776,7 +1773,7 @@ Item *sys_var::item(THD *thd, enum_var_type var_type, LEX_STRING *base)
     /* As there was no local variable, return the global value */
     var_type= OPT_GLOBAL;
   }
-  switch (type()) {
+  switch (show_type()) {
   case SHOW_INT:
   {
     uint value;
diff --git a/sql/set_var.h b/sql/set_var.h
index 60fdb0e879b..6000e155db9 100644
--- a/sql/set_var.h
+++ b/sql/set_var.h
@@ -55,8 +55,8 @@ public:
   bool check_enum(THD *thd, set_var *var, TYPELIB *enum_names);
   bool check_set(THD *thd, set_var *var, TYPELIB *enum_names);
   virtual bool update(THD *thd, set_var *var)=0;
-  virtual void set_default(THD *thd, enum_var_type type) {}
-  virtual SHOW_TYPE type() { return SHOW_UNDEF; }
+  virtual void set_default(THD *thd_arg, enum_var_type type) {}
+  virtual SHOW_TYPE show_type() { return SHOW_UNDEF; }
   virtual byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
   { return 0; }
   virtual bool check_type(enum_var_type type)
@@ -96,14 +96,16 @@ class sys_var_long_ptr_global: public sys_var_global
 {
 public:
   ulong *value;
-  sys_var_long_ptr_global(const char *name_arg, ulong *value_ptr,
+  sys_var_long_ptr_global(const char *name_arg, ulong *value_ptr_arg,
                         pthread_mutex_t *guard_arg,
                         sys_after_update_func after_update_arg= NULL)
-    :sys_var_global(name_arg, after_update_arg, guard_arg), value(value_ptr) {}
+    :sys_var_global(name_arg, after_update_arg, guard_arg),
+    value(value_ptr_arg)
+    {}
   bool check(THD *thd, set_var *var);
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
-  SHOW_TYPE type() { return SHOW_LONG; }
+  SHOW_TYPE show_type() { return SHOW_LONG; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
   { return (byte*) value; }
 };
@@ -125,14 +127,14 @@ class sys_var_ulonglong_ptr :public sys_var
 {
 public:
   ulonglong *value;
-  sys_var_ulonglong_ptr(const char *name_arg, ulonglong *value_ptr)
-    :sys_var(name_arg),value(value_ptr) {}
-  sys_var_ulonglong_ptr(const char *name_arg, ulonglong *value_ptr,
+  sys_var_ulonglong_ptr(const char *name_arg, ulonglong *value_ptr_arg)
+    :sys_var(name_arg),value(value_ptr_arg) {}
+  sys_var_ulonglong_ptr(const char *name_arg, ulonglong *value_ptr_arg,
 		       sys_after_update_func func)
-    :sys_var(name_arg,func), value(value_ptr) {}
+    :sys_var(name_arg,func), value(value_ptr_arg) {}
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
-  SHOW_TYPE type() { return SHOW_LONGLONG; }
+  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
   { return (byte*) value; }
 };
@@ -151,7 +153,7 @@ public:
   }
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
-  SHOW_TYPE type() { return SHOW_MY_BOOL; }
+  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
   { return (byte*) value; }
   bool check_update_type(Item_result type) { return 0; }
@@ -183,7 +185,7 @@ public:
   {
     (*set_default_func)(thd, type);
   }
-  SHOW_TYPE type() { return SHOW_CHAR; }
+  SHOW_TYPE show_type() { return SHOW_CHAR; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
   { return (byte*) value; }
   bool check_update_type(Item_result type)
@@ -209,7 +211,7 @@ public:
   {
     return 1;
   }
-  SHOW_TYPE type() { return SHOW_CHAR; }
+  SHOW_TYPE show_type() { return SHOW_CHAR; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
   {
     return (byte*) value;
@@ -238,7 +240,7 @@ public:
   {
     return 1;
   }
-  SHOW_TYPE type() { return SHOW_CHAR; }
+  SHOW_TYPE show_type() { return SHOW_CHAR; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
   {
     return (byte*) *value;
@@ -266,7 +268,7 @@ public:
     return check_enum(thd, var, enum_names);
   }
   bool update(THD *thd, set_var *var);
-  SHOW_TYPE type() { return SHOW_CHAR; }
+  SHOW_TYPE show_type() { return SHOW_CHAR; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
   bool check_update_type(Item_result type) { return 0; }
 };
@@ -301,7 +303,7 @@ public:
   bool check(THD *thd, set_var *var);
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
-  SHOW_TYPE type() { return SHOW_LONG; }
+  SHOW_TYPE show_type() { return SHOW_LONG; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
 };
 
@@ -319,7 +321,7 @@ public:
   {}
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
-  SHOW_TYPE type() { return SHOW_HA_ROWS; }
+  SHOW_TYPE show_type() { return SHOW_HA_ROWS; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
 };
 
@@ -339,7 +341,7 @@ public:
   {}
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
-  SHOW_TYPE type() { return SHOW_LONGLONG; }
+  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
   bool check_default(enum_var_type type)
   {
@@ -365,7 +367,7 @@ public:
   {}
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
-  SHOW_TYPE type() { return SHOW_MY_BOOL; }
+  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
   bool check(THD *thd, set_var *var)
   {
@@ -396,7 +398,7 @@ public:
   }
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
-  SHOW_TYPE type() { return SHOW_CHAR; }
+  SHOW_TYPE show_type() { return SHOW_CHAR; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
   bool check_update_type(Item_result type) { return 0; }
 };
@@ -431,7 +433,7 @@ public:
     :sys_var_thd(name_arg), offset(offset_arg)
   {}
   bool check(THD *thd, set_var *var);
-SHOW_TYPE type() { return SHOW_CHAR; }
+  SHOW_TYPE show_type() { return SHOW_CHAR; }
   bool check_update_type(Item_result type)
   {
     return type != STRING_RESULT;		/* Only accept strings */
@@ -469,7 +471,7 @@ public:
   bool update(THD *thd, set_var *var);
   bool check_update_type(Item_result type) { return 0; }
   bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
-  SHOW_TYPE type() { return SHOW_MY_BOOL; }
+  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
 };
 
@@ -484,7 +486,7 @@ public:
   void set_default(THD *thd, enum_var_type type);
   bool check_type(enum_var_type type)    { return type == OPT_GLOBAL; }
   bool check_default(enum_var_type type) { return 0; }
-  SHOW_TYPE type() { return SHOW_LONG; }
+  SHOW_TYPE show_type() { return SHOW_LONG; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
 };
 
@@ -495,7 +497,7 @@ public:
   sys_var_last_insert_id(const char *name_arg) :sys_var(name_arg) {}
   bool update(THD *thd, set_var *var);
   bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
-  SHOW_TYPE type() { return SHOW_LONGLONG; }
+  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
 };
 
@@ -506,7 +508,7 @@ public:
   sys_var_insert_id(const char *name_arg) :sys_var(name_arg) {}
   bool update(THD *thd, set_var *var);
   bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
-  SHOW_TYPE type() { return SHOW_LONGLONG; }
+  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
 };
 
@@ -528,8 +530,8 @@ public:
 class sys_var_sync_binlog_period :public sys_var_long_ptr
 {
 public:
-  sys_var_sync_binlog_period(const char *name_arg, ulong *value_ptr)
-    :sys_var_long_ptr(name_arg,value_ptr) {}
+  sys_var_sync_binlog_period(const char *name_arg, ulong *value_ptr_arg)
+    :sys_var_long_ptr(name_arg,value_ptr_arg) {}
   bool update(THD *thd, set_var *var);
 };
 #endif
@@ -559,7 +561,7 @@ public:
     no_support_one_shot= 0;
     }
   bool check(THD *thd, set_var *var);
-SHOW_TYPE type() { return SHOW_CHAR; }
+  SHOW_TYPE show_type() { return SHOW_CHAR; }
   bool check_update_type(Item_result type)
   {
     return ((type != STRING_RESULT) && (type != INT_RESULT));
@@ -583,7 +585,7 @@ public:
     no_support_one_shot= 0;
   }
   bool check(THD *thd, set_var *var);
-  SHOW_TYPE type() { return SHOW_CHAR; }
+  SHOW_TYPE show_type() { return SHOW_CHAR; }
   bool check_update_type(Item_result type)
   {
     return ((type != STRING_RESULT) && (type != INT_RESULT));
@@ -699,7 +701,7 @@ public:
     :sys_var_key_cache_param(name_arg, offsetof(KEY_CACHE, param_buff_size))
   {}
   bool update(THD *thd, set_var *var);
-  SHOW_TYPE type() { return SHOW_LONGLONG; }
+  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
 };
 
 
@@ -710,7 +712,7 @@ public:
     :sys_var_key_cache_param(name_arg, offset_arg)
   {}
   bool update(THD *thd, set_var *var);
-  SHOW_TYPE type() { return SHOW_LONG; }
+  SHOW_TYPE show_type() { return SHOW_LONG; }
 };
 
 
@@ -725,7 +727,7 @@ public:
     :sys_var_thd(name_arg), offset(offset_arg),
     date_time_type(date_time_type_arg)
   {}
-  SHOW_TYPE type() { return SHOW_CHAR; }
+  SHOW_TYPE show_type() { return SHOW_CHAR; }
   bool check_update_type(Item_result type)
   {
     return type != STRING_RESULT;		/* Only accept strings */
@@ -745,13 +747,13 @@ class sys_var_readonly: public sys_var
 {
 public:
   enum_var_type var_type;
-  SHOW_TYPE show_type;
+  SHOW_TYPE show_type_value;
   sys_value_ptr_func value_ptr_func;
   sys_var_readonly(const char *name_arg, enum_var_type type,
 		   SHOW_TYPE show_type_arg,
 		   sys_value_ptr_func value_ptr_func_arg)
     :sys_var(name_arg), var_type(type), 
-       show_type(show_type_arg), value_ptr_func(value_ptr_func_arg)
+       show_type_value(show_type_arg), value_ptr_func(value_ptr_func_arg)
   {}
   bool update(THD *thd, set_var *var) { return 1; }
   bool check_default(enum_var_type type) { return 1; }
@@ -761,7 +763,7 @@ public:
   {
     return (*value_ptr_func)(thd);
   }
-  SHOW_TYPE type() { return show_type; }
+  SHOW_TYPE show_type() { return show_type_value; }
   bool is_readonly() const { return 1; }
 };
 
@@ -774,7 +776,7 @@ public:
     no_support_one_shot= 0;
   }
   bool check(THD *thd, set_var *var);
-  SHOW_TYPE type() { return SHOW_CHAR; }
+  SHOW_TYPE show_type() { return SHOW_CHAR; }
   bool check_update_type(Item_result type)
   {
     return type != STRING_RESULT;		/* Only accept strings */
@@ -798,7 +800,7 @@ public:
     return type != OPT_GLOBAL || !option_limits;
   }
   void set_default(THD *thd, enum_var_type type);
-  SHOW_TYPE type() { return SHOW_INT; }
+  SHOW_TYPE show_type() { return SHOW_INT; }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
 };
 
@@ -825,7 +827,7 @@ public:
 #endif
   }
   bool check(THD *thd, set_var *var);
-  SHOW_TYPE type() { return SHOW_CHAR; }
+  SHOW_TYPE show_type() { return SHOW_CHAR; }
   bool check_update_type(Item_result type)
   {
     return ((type != STRING_RESULT) && (type != INT_RESULT));
@@ -872,8 +874,8 @@ public:
   } save_result;
   LEX_STRING base;			/* for structs */
 
-  set_var(enum_var_type type_arg, sys_var *var_arg, const LEX_STRING *base_name_arg,
-	  Item *value_arg)
+  set_var(enum_var_type type_arg, sys_var *var_arg,
+          const LEX_STRING *base_name_arg, Item *value_arg)
     :var(var_arg), type(type_arg), base(*base_name_arg)
   {
     /*
diff --git a/sql/slave.cc b/sql/slave.cc
index 5ff05046895..9d466ce5dad 100644
--- a/sql/slave.cc
+++ b/sql/slave.cc
@@ -52,7 +52,9 @@ ulonglong relay_log_space_limit = 0;
 
 int disconnect_slave_event_count = 0, abort_slave_event_count = 0;
 int events_till_abort = -1;
+#ifndef DBUG_OFF
 static int events_till_disconnect = -1;
+#endif
 
 typedef enum { SLAVE_THD_IO, SLAVE_THD_SQL} SLAVE_THD_TYPE;
 
@@ -1695,7 +1697,7 @@ static int init_relay_log_info(RELAY_LOG_INFO* rli,
   char fname[FN_REFLEN+128];
   int info_fd;
   const char* msg = 0;
-  int error = 0;
+  int error;
   DBUG_ENTER("init_relay_log_info");
 
   if (rli->inited)                       // Set if this function called
@@ -1800,11 +1802,11 @@ file '%s', errno %d)", fname, my_errno);
   }
   else // file exists
   {
+    error= 0;
     if (info_fd >= 0)
       reinit_io_cache(&rli->info_file, READ_CACHE, 0L,0,0);
     else 
     {
-      int error=0;
       if ((info_fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0)
       {
         sql_print_error("\
@@ -2514,12 +2516,12 @@ bool show_master_info(THD* thd, MASTER_INFO* mi)
     if ((mi->slave_running == MYSQL_SLAVE_RUN_CONNECT) &&
         mi->rli.slave_running)
     {
-      long tmp= (long)((time_t)time((time_t*) 0)
-                               - mi->rli.last_master_timestamp)
-        - mi->clock_diff_with_master;
+      long time_diff= ((long)((time_t)time((time_t*) 0)
+                              - mi->rli.last_master_timestamp)
+                       - mi->clock_diff_with_master);
       /*
-        Apparently on some systems tmp can be <0. Here are possible reasons
-        related to MySQL:
+        Apparently on some systems time_diff can be <0. Here are possible
+        reasons related to MySQL:
         - the master is itself a slave of another master whose time is ahead.
         - somebody used an explicit SET TIMESTAMP on the master.
         Possible reason related to granularity-to-second of time functions
@@ -2537,8 +2539,8 @@ bool show_master_info(THD* thd, MASTER_INFO* mi)
         last_master_timestamp == 0 (an "impossible" timestamp 1970) is a
         special marker to say "consider we have caught up".
       */
-      protocol->store((longlong)(mi->rli.last_master_timestamp ? max(0, tmp)
-                                 : 0));
+      protocol->store((longlong)(mi->rli.last_master_timestamp ?
+                                 max(0, time_diff) : 0));
     }
     else
       protocol->store_null();
@@ -3586,15 +3588,17 @@ after reconnect");
 
     while (!io_slave_killed(thd,mi))
     {
-      bool suppress_warnings= 0;
+      ulong event_len;
+
+      suppress_warnings= 0;
       /*
          We say "waiting" because read_event() will wait if there's nothing to
          read. But if there's something to read, it will not wait. The
          important thing is to not confuse users by saying "reading" whereas
          we're in fact receiving nothing.
       */
-      thd->proc_info = "Waiting for master to send event";
-      ulong event_len = read_event(mysql, mi, &suppress_warnings);
+      thd->proc_info= "Waiting for master to send event";
+      event_len= read_event(mysql, mi, &suppress_warnings);
       if (io_slave_killed(thd,mi))
       {
 	if (global_system_variables.log_warnings)
@@ -3757,8 +3761,13 @@ err:
   mi->abort_slave= 0;
   mi->slave_running= 0;
   mi->io_thd= 0;
-  pthread_mutex_unlock(&mi->run_lock);
+  /*
+    Note: the order of the two following calls (first broadcast, then unlock)
+    is important. Otherwise a killer_thread can execute between the calls and
+    delete the mi structure leading to a crash! (see BUG#25306 for details)
+   */ 
   pthread_cond_broadcast(&mi->stop_cond);       // tell the world we are done
+  pthread_mutex_unlock(&mi->run_lock);
 #ifndef DBUG_OFF
   if (abort_slave_event_count && !events_till_abort)
     goto slave_begin;
@@ -3976,8 +3985,13 @@ the slave SQL thread with \"SLAVE START\". We stopped at log \
   THD_CHECK_SENTRY(thd);
   delete thd;
   pthread_mutex_unlock(&LOCK_thread_count);
-  pthread_cond_broadcast(&rli->stop_cond);
 
+ /*
+  Note: the order of the broadcast and unlock calls below (first broadcast, then unlock)
+  is important. Otherwise a killer_thread can execute between the calls and
+  delete the mi structure leading to a crash! (see BUG#25306 for details)
+ */ 
+  pthread_cond_broadcast(&rli->stop_cond);
 #ifndef DBUG_OFF
   /*
     Bug #19938 Valgrind error (race) in handle_slave_sql()
@@ -3985,9 +3999,8 @@ the slave SQL thread with \"SLAVE START\". We stopped at log \
   */
   const int eta= rli->events_till_abort;
 #endif
-
-  // tell the world we are done
-  pthread_mutex_unlock(&rli->run_lock);
+  pthread_mutex_unlock(&rli->run_lock);  // tell the world we are done
+  
 #ifndef DBUG_OFF // TODO: reconsider the code below
   if (abort_slave_event_count && !eta)
     goto slave_begin;
@@ -4389,6 +4402,8 @@ int queue_event(MASTER_INFO* mi,const char* buf, ulong event_len)
   pthread_mutex_t *log_lock= rli->relay_log.get_log_lock();
   DBUG_ENTER("queue_event");
 
+  LINT_INIT(inc_pos);
+
   if (mi->rli.relay_log.description_event_for_queue->binlog_version<4 &&
       buf[EVENT_TYPE_OFFSET] != FORMAT_DESCRIPTION_EVENT /* a way to escape */)
     DBUG_RETURN(queue_old_event(mi,buf,event_len));
@@ -4529,7 +4544,7 @@ int queue_event(MASTER_INFO* mi,const char* buf, ulong event_len)
 
 err:
   pthread_mutex_unlock(&mi->data_lock);
-  DBUG_PRINT("info", ("error=%d", error));
+  DBUG_PRINT("info", ("error: %d", error));
   DBUG_RETURN(error);
 }
 
@@ -5170,6 +5185,70 @@ end:
 }
 
 
+/**
+   Detects, based on master's version (as found in the relay log), if master
+   has a certain bug.
+   @param rli RELAY_LOG_INFO which tells the master's version
+   @param bug_id Number of the bug as found in bugs.mysql.com
+   @return TRUE if master has the bug, FALSE if it does not.
+*/
+bool rpl_master_has_bug(RELAY_LOG_INFO *rli, uint bug_id)
+{
+  struct st_version_range_for_one_bug {
+    uint        bug_id;
+    const uchar introduced_in[3]; // first version with bug
+    const uchar fixed_in[3];      // first version with fix
+  };
+  static struct st_version_range_for_one_bug versions_for_all_bugs[]=
+  {
+    {24432, { 5, 0, 24 }, { 5, 0, 38 } },
+    {24432, { 5, 1, 12 }, { 5, 1, 17 } }
+  };
+  const uchar *master_ver=
+    rli->relay_log.description_event_for_exec->server_version_split;
+
+  DBUG_ASSERT(sizeof(rli->relay_log.description_event_for_exec->server_version_split) == 3);
+
+  for (uint i= 0;
+       i < sizeof(versions_for_all_bugs)/sizeof(*versions_for_all_bugs);i++)
+  {
+    const uchar *introduced_in= versions_for_all_bugs[i].introduced_in,
+      *fixed_in= versions_for_all_bugs[i].fixed_in;
+    if ((versions_for_all_bugs[i].bug_id == bug_id) &&
+        (memcmp(introduced_in, master_ver, 3) <= 0) &&
+        (memcmp(fixed_in,      master_ver, 3) >  0))
+    {
+      // a verbose message for the error log
+      slave_print_error(rli, ER_UNKNOWN_ERROR,
+                        "According to the master's version ('%s'),"
+                        " it is probable that master suffers from this bug:"
+                        " http://bugs.mysql.com/bug.php?id=%u"
+                        " and thus replicating the current binary log event"
+                        " may make the slave's data become different from the"
+                        " master's data."
+                        " To take no risk, slave refuses to replicate"
+                        " this event and stops."
+                        " We recommend that all updates be stopped on the"
+                        " master and slave, that the data of both be"
+                        " manually synchronized,"
+                        " that master's binary logs be deleted,"
+                        " that master be upgraded to a version at least"
+                        " equal to '%d.%d.%d'. Then replication can be"
+                        " restarted.",
+                        rli->relay_log.description_event_for_exec->server_version,
+                        bug_id,
+                        fixed_in[0], fixed_in[1], fixed_in[2]);
+      // a short message for SHOW SLAVE STATUS (message length constraints)
+      my_printf_error(ER_UNKNOWN_ERROR, "master may suffer from"
+                      " http://bugs.mysql.com/bug.php?id=%u"
+                      " so slave stops; check error log on slave"
+                      " for more info", MYF(0), bug_id);
+      return TRUE;
+    }
+  }
+  return FALSE;
+}
+
 #ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
 template class I_List_iterator<i_string>;
 template class I_List_iterator<i_string_pair>;
diff --git a/sql/slave.h b/sql/slave.h
index bbf450bab75..e7d4456ccd9 100644
--- a/sql/slave.h
+++ b/sql/slave.h
@@ -533,6 +533,7 @@ void table_rule_ent_hash_to_str(String* s, HASH* h);
 void table_rule_ent_dynamic_array_to_str(String* s, DYNAMIC_ARRAY* a);
 bool show_master_info(THD* thd, MASTER_INFO* mi);
 bool show_binlog_info(THD* thd);
+bool rpl_master_has_bug(RELAY_LOG_INFO *rli, uint bug_id);
 
 /* See if the query uses any tables that should not be replicated */
 bool tables_ok(THD* thd, TABLE_LIST* tables);
diff --git a/sql/sp.cc b/sql/sp.cc
index a33f6bfda29..2bb13b02e14 100644
--- a/sql/sp.cc
+++ b/sql/sp.cc
@@ -491,8 +491,6 @@ db_create_routine(THD *thd, int type, sp_head *sp)
   int ret;
   TABLE *table;
   char definer[USER_HOST_BUFF_SIZE];
-  char old_db_buf[NAME_LEN+1];
-  LEX_STRING old_db= { old_db_buf, sizeof(old_db_buf) };
   DBUG_ENTER("db_create_routine");
   DBUG_PRINT("enter", ("type: %d name: %.*s",type,sp->m_name.length,
                        sp->m_name.str));
@@ -1842,9 +1840,7 @@ create_string(THD *thd, String *buf,
   SYNOPSIS
     sp_use_new_db()
       thd            thread handle
-
       new_db         new database name (a string and its length)
-
       old_db         [IN] str points to a buffer where to store the old
                           database, length contains the size of the buffer
                      [OUT] if old db was not NULL, its name is copied
@@ -1852,7 +1848,6 @@ create_string(THD *thd, String *buf,
                      accordingly. Otherwise str[0] is set to '\0' and length
                      is set to 0. The out parameter should be used only if
                      the database name has been changed (see dbchangedp).
-
      dbchangedp      [OUT] is set to TRUE if the current database is changed,
                      FALSE otherwise. A database is not changed if the old
                      name is the same as the new one, both names are empty,
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index de0edabda3e..24bdd2db5b6 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -94,8 +94,6 @@ sp_map_item_type(enum enum_field_types type)
 static String *
 sp_get_item_value(THD *thd, Item *item, String *str)
 {
-  Item_result result_type= item->result_type();
-
   switch (item->result_type()) {
   case REAL_RESULT:
   case INT_RESULT:
@@ -1464,8 +1462,24 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
   binlog_save_options= thd->options;
   if (need_binlog_call)
   {
+    query_id_t q;
     reset_dynamic(&thd->user_var_events);
-    mysql_bin_log.start_union_events(thd);
+    /*
+      In case of artificially constructed events for function calls
+      we have separate union for each such event and hence can't use
+      query_id of real calling statement as the start of all these
+      unions (this will break logic of replication of user-defined
+      variables). So we use artifical value which is guaranteed to
+      be greater than all query_id's of all statements belonging
+      to previous events/unions.
+      Possible alternative to this is logging of all function invocations
+      as one select and not resetting THD::user_var_events before
+      each invocation.
+    */
+    VOID(pthread_mutex_lock(&LOCK_thread_count));
+    q= global_query_id;
+    VOID(pthread_mutex_unlock(&LOCK_thread_count));
+    mysql_bin_log.start_union_events(thd, q + 1);
   }
 
   /*
@@ -1733,7 +1747,7 @@ sp_head::reset_lex(THD *thd)
   DBUG_ENTER("sp_head::reset_lex");
   LEX *sublex;
   LEX *oldlex= thd->lex;
-  my_lex_states state= oldlex->next_state; // Keep original next_state
+  my_lex_states org_next_state= oldlex->next_state;
 
   (void)m_lex.push_front(oldlex);
   thd->lex= sublex= new st_lex;
@@ -1742,10 +1756,10 @@ sp_head::reset_lex(THD *thd)
   lex_start(thd, oldlex->buf, (ulong) (oldlex->end_of_query - oldlex->ptr));
 
   /*
-   * next_state is normally the same (0), but it happens that we swap lex in
-   * "mid-sentence", so we must restore it.
+    next_state is normally the same (0), but it happens that we swap lex in
+    "mid-sentence", so we must restore it.
    */
-  sublex->next_state= state;
+  sublex->next_state= org_next_state;
   /* We must reset ptr and end_of_query again */
   sublex->ptr= oldlex->ptr;
   sublex->end_of_query= oldlex->end_of_query;
diff --git a/sql/sp_head.h b/sql/sp_head.h
index 0139f879ce4..7f50f2a8202 100644
--- a/sql/sp_head.h
+++ b/sql/sp_head.h
@@ -634,9 +634,9 @@ class sp_instr_set : public sp_instr
 public:
 
   sp_instr_set(uint ip, sp_pcontext *ctx,
-	       uint offset, Item *val, enum enum_field_types type,
+	       uint offset, Item *val, enum enum_field_types type_arg,
                LEX *lex, bool lex_resp)
-    : sp_instr(ip, ctx), m_offset(offset), m_value(val), m_type(type),
+    : sp_instr(ip, ctx), m_offset(offset), m_value(val), m_type(type_arg),
       m_lex_keeper(lex, lex_resp)
   {}
 
@@ -834,8 +834,9 @@ class sp_instr_freturn : public sp_instr
 public:
 
   sp_instr_freturn(uint ip, sp_pcontext *ctx,
-		   Item *val, enum enum_field_types type, LEX *lex)
-    : sp_instr(ip, ctx), m_value(val), m_type(type), m_lex_keeper(lex, TRUE)
+		   Item *val, enum enum_field_types type_arg, LEX *lex)
+    : sp_instr(ip, ctx), m_value(val), m_type(type_arg),
+      m_lex_keeper(lex, TRUE)
   {}
 
   virtual ~sp_instr_freturn()
diff --git a/sql/spatial.cc b/sql/spatial.cc
index 9012ced1041..bd4b6278eab 100644
--- a/sql/spatial.cc
+++ b/sql/spatial.cc
@@ -23,13 +23,13 @@
 
 String Geometry::bad_geometry_data("Bad object", &my_charset_bin);
 
-Geometry::Class_info *Geometry::ci_collection[Geometry::wkb_end+1]=
+Geometry::Class_info *Geometry::ci_collection[Geometry::wkb_last+1]=
 {
   NULL, NULL, NULL, NULL, NULL, NULL, NULL
 };
 
 static Geometry::Class_info **ci_collection_end=
-                                Geometry::ci_collection+Geometry::wkb_end + 1;
+                                Geometry::ci_collection+Geometry::wkb_last + 1;
 
 Geometry::Class_info::Class_info(const char *name, int type_id,
 					 void(*create_func)(void *)):
@@ -549,7 +549,7 @@ bool Gis_line_string::get_mbr(MBR *mbr, const char **end) const
 }
 
 
-int Gis_line_string::length(double *len) const
+int Gis_line_string::geom_length(double *len) const
 {
   uint32 n_points;
   double prev_x, prev_y;
@@ -945,15 +945,14 @@ int Gis_polygon::centroid_xy(double *x, double *y) const
 
     while (--n_points)				// One point is already read
     {
-      double x, y;
-      get_point(&x, &y, data);
+      double tmp_x, tmp_y;
+      get_point(&tmp_x, &tmp_y, data);
       data+= (SIZEOF_STORED_DOUBLE*2);
-      /* QQ: Is the following prev_x+x right ? */
-      cur_area+= (prev_x + x) * (prev_y - y);
-      cur_cx+= x;
-      cur_cy+= y;
-      prev_x= x;
-      prev_y= y;
+      cur_area+= (prev_x + tmp_x) * (prev_y - tmp_y);
+      cur_cx+= tmp_x;
+      cur_cy+= tmp_y;
+      prev_x= tmp_x;
+      prev_y= tmp_y;
     }
     cur_area= fabs(cur_area) / 2;
     cur_cx= cur_cx / (org_n_points - 1);
@@ -1297,7 +1296,7 @@ int Gis_multi_line_string::geometry_n(uint32 num, String *result) const
 }
 
 
-int Gis_multi_line_string::length(double *len) const
+int Gis_multi_line_string::geom_length(double *len) const
 {
   uint32 n_line_strings;
   const char *data= m_data;
@@ -1314,7 +1313,7 @@ int Gis_multi_line_string::length(double *len) const
     Gis_line_string ls;
     data+= WKB_HEADER_SIZE;
     ls.set_data_ptr(data, (uint32) (m_data_end - data));
-    if (ls.length(&ls_len))
+    if (ls.geom_length(&ls_len))
       return 1;
     *len+= ls_len;
     /*
diff --git a/sql/spatial.h b/sql/spatial.h
index 3e398ac6200..109ac7f60cc 100644
--- a/sql/spatial.h
+++ b/sql/spatial.h
@@ -188,7 +188,7 @@ public:
     wkb_multilinestring= 5,
     wkb_multipolygon= 6,
     wkb_geometrycollection= 7,
-    wkb_end=7
+    wkb_last=7
   };
   enum wkbByteOrder
   {
@@ -217,7 +217,7 @@ public:
   virtual bool dimension(uint32 *dim, const char **end) const=0;
   virtual int get_x(double *x) const { return -1; }
   virtual int get_y(double *y) const { return -1; }
-  virtual int length(double *len) const  { return -1; }
+  virtual int geom_length(double *len) const  { return -1; }
   virtual int area(double *ar, const char **end) const { return -1;}
   virtual int is_closed(int *closed) const { return -1; }
   virtual int num_interior_ring(uint32 *n_int_rings) const { return -1; }
@@ -273,12 +273,12 @@ public:
   }
 
   bool envelope(String *result) const;
-  static Class_info *ci_collection[wkb_end+1];
+  static Class_info *ci_collection[wkb_last+1];
 
 protected:
   static Class_info *find_class(int type_id)
   {
-    return ((type_id < wkb_point) || (type_id > wkb_end)) ?
+    return ((type_id < wkb_point) || (type_id > wkb_last)) ?
       NULL : ci_collection[type_id];
   }  
   static Class_info *find_class(const char *name, uint32 len);
@@ -359,7 +359,7 @@ public:
   uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res);
   bool get_data_as_wkt(String *txt, const char **end) const;
   bool get_mbr(MBR *mbr, const char **end) const;
-  int length(double *len) const;
+  int geom_length(double *len) const;
   int is_closed(int *closed) const;
   int num_points(uint32 *n_points) const;
   int start_point(String *point) const;
@@ -441,7 +441,7 @@ public:
   bool get_mbr(MBR *mbr, const char **end) const;
   int num_geometries(uint32 *num) const;
   int geometry_n(uint32 num, String *result) const;
-  int length(double *len) const;
+  int geom_length(double *len) const;
   int is_closed(int *closed) const;
   bool dimension(uint32 *dim, const char **end) const
   {
diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc
index 39a38f3c44e..298fb61d5f0 100644
--- a/sql/sql_acl.cc
+++ b/sql/sql_acl.cc
@@ -5021,6 +5021,8 @@ static int handle_grant_struct(uint struct_no, bool drop,
       user= grant_name->user;
       host= grant_name->host.hostname;
       break;
+    default:
+      assert(0);
     }
     if (! user)
       user= "";
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index ad9cd5985d1..630d135be48 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -2975,6 +2975,7 @@ find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
   if (nj_col->view_field)
   {
     Item *item;
+    LINT_INIT(arena);
     if (register_tree_change)
       arena= thd->activate_stmt_arena_if_needed(&backup);
     /*
@@ -4527,21 +4528,8 @@ bool setup_tables(THD *thd, Name_resolution_context *context,
   uint tablenr= 0;
   DBUG_ENTER("setup_tables");
 
-  /*
-    Due to the various call paths that lead to setup_tables() it may happen
-    that context->table_list and context->first_name_resolution_table can be
-    NULL (this is typically done when creating TABLE_LISTs internally).
-    TODO:
-    Investigate all cases when this my happen, initialize the name resolution
-    context correctly in all those places, and remove the context reset below.
-  */
-  if (!context->table_list || !context->first_name_resolution_table)
-  {
-    /* Test whether the context is in a consistent state. */
-    DBUG_ASSERT(!context->first_name_resolution_table && !context->table_list);
-    context->table_list= context->first_name_resolution_table= tables;
-  }
-
+  DBUG_ASSERT ((select_insert && !tables->next_name_resolution_table) || !tables || 
+               (context->table_list && context->first_name_resolution_table));
   /*
     this is used for INSERT ... SELECT.
     For select we setup tables except first (and its underlying tables)
diff --git a/sql/sql_cache.h b/sql/sql_cache.h
index 0fbc06ce919..bc00f7ea629 100644
--- a/sql/sql_cache.h
+++ b/sql/sql_cache.h
@@ -127,7 +127,7 @@ struct Query_cache_query
   inline void tables_type(uint8 type)      { tbls_type= type; }
   inline ulong length()			   { return len; }
   inline ulong add(ulong packet_len)	   { return(len+= packet_len); }
-  inline void length(ulong length)	   { len= length; }
+  inline void length(ulong length_arg)	   { len= length_arg; }
   inline gptr query()
   {
     return (gptr)(((byte*)this)+
@@ -155,7 +155,7 @@ struct Query_cache_table
 
   inline char *db()			     { return (char *) data(); }
   inline char *table()			     { return tbl; }
-  inline void table(char *table)	     { tbl= table; }
+  inline void table(char *table_arg)	     { tbl= table_arg; }
   inline uint32 key_length()                 { return key_len; }
   inline void key_length(uint32 len)         { key_len= len; }
   inline uint8 type()                        { return table_type; }
@@ -163,7 +163,7 @@ struct Query_cache_table
   inline qc_engine_callback callback()       { return callback_func; }
   inline void callback(qc_engine_callback fn){ callback_func= fn; }
   inline ulonglong engine_data()             { return engine_data_buff; }
-  inline void engine_data(ulonglong data)    { engine_data_buff= data; }
+  inline void engine_data(ulonglong data_arg){ engine_data_buff= data_arg; }
   inline gptr data()
   {
     return (gptr)(((byte*)this)+
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 714b1244be4..e6106675159 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -182,6 +182,8 @@ THD::THD()
    clear_next_insert_id(0), in_lock_tables(0), bootstrap(0),
    derived_tables_processing(FALSE), spcont(NULL)
 {
+  ulong tmp;
+
   stmt_arena= this;
   thread_stack= 0;
   db= 0;
@@ -268,8 +270,8 @@ THD::THD()
   protocol_prep.init(this);
 
   tablespace_op=FALSE;
-  ulong tmp=sql_rnd_with_mutex();
-  randominit(&rand, tmp + (ulong) &rand, tmp + (ulong) ::query_id);
+  tmp= sql_rnd_with_mutex();
+  randominit(&rand, tmp + (ulong) &rand, tmp + (ulong) ::global_query_id);
   substitute_null_with_insert_id = FALSE;
   thr_lock_info_init(&lock_info); /* safety: will be reset after start */
   thr_lock_owner_init(&main_lock_id, &lock_info);
@@ -899,6 +901,7 @@ sql_exchange::sql_exchange(char *name,bool flag)
   enclosed=   line_start= &my_empty_string;
   line_term=  &default_line_term;
   escaped=    &default_escaped;
+  cs= NULL;
 }
 
 bool select_send::send_fields(List<Item> &list, uint flags)
@@ -1443,7 +1446,7 @@ bool select_max_min_finder_subselect::send_data(List<Item> &items)
 
 bool select_max_min_finder_subselect::cmp_real()
 {
-  Item *maxmin= ((Item_singlerow_subselect *)item)->el(0);
+  Item *maxmin= ((Item_singlerow_subselect *)item)->element_index(0);
   double val1= cache->val_real(), val2= maxmin->val_real();
   if (fmax)
     return (cache->null_value && !maxmin->null_value) ||
@@ -1456,7 +1459,7 @@ bool select_max_min_finder_subselect::cmp_real()
 
 bool select_max_min_finder_subselect::cmp_int()
 {
-  Item *maxmin= ((Item_singlerow_subselect *)item)->el(0);
+  Item *maxmin= ((Item_singlerow_subselect *)item)->element_index(0);
   longlong val1= cache->val_int(), val2= maxmin->val_int();
   if (fmax)
     return (cache->null_value && !maxmin->null_value) ||
@@ -1469,7 +1472,7 @@ bool select_max_min_finder_subselect::cmp_int()
 
 bool select_max_min_finder_subselect::cmp_decimal()
 {
-  Item *maxmin= ((Item_singlerow_subselect *)item)->el(0);
+  Item *maxmin= ((Item_singlerow_subselect *)item)->element_index(0);
   my_decimal cval, *cvalue= cache->val_decimal(&cval);
   my_decimal mval, *mvalue= maxmin->val_decimal(&mval);
   if (fmax)
@@ -1484,7 +1487,7 @@ bool select_max_min_finder_subselect::cmp_decimal()
 bool select_max_min_finder_subselect::cmp_str()
 {
   String *val1, *val2, buf1, buf2;
-  Item *maxmin= ((Item_singlerow_subselect *)item)->el(0);
+  Item *maxmin= ((Item_singlerow_subselect *)item)->element_index(0);
   /*
     as far as both operand is Item_cache buf1 & buf2 will not be used,
     but added for safety
@@ -2056,6 +2059,10 @@ void THD::reset_sub_statement_state(Sub_statement_state *backup,
 
   if (!lex->requires_prelocking() || is_update_query(lex->sql_command))
     options&= ~OPTION_BIN_LOG;
+
+  if ((backup->options & OPTION_BIN_LOG) && is_update_query(lex->sql_command))
+    mysql_bin_log.start_union_events(this, this->query_id);
+
   /* Disable result sets */
   client_capabilities &= ~CLIENT_MULTI_RESULTS;
   in_sub_stmt|= new_state;
@@ -2102,6 +2109,9 @@ void THD::restore_sub_statement_state(Sub_statement_state *backup)
   sent_row_count=   backup->sent_row_count;
   client_capabilities= backup->client_capabilities;
 
+  if ((options & OPTION_BIN_LOG) && is_update_query(lex->sql_command))
+    mysql_bin_log.stop_union_events(this);
+
   /*
     The following is added to the old values as we are interested in the
     total complexity of the query
diff --git a/sql/sql_class.h b/sql/sql_class.h
index 1fe5ef54043..b22c67979f8 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -63,7 +63,7 @@ class TC_LOG
 
   virtual int open(const char *opt_name)=0;
   virtual void close()=0;
-  virtual int log(THD *thd, my_xid xid)=0;
+  virtual int log_xid(THD *thd, my_xid xid)=0;
   virtual void unlog(ulong cookie, my_xid xid)=0;
 };
 
@@ -73,7 +73,7 @@ public:
   TC_LOG_DUMMY() {}                           /* Remove gcc warning */
   int open(const char *opt_name)        { return 0; }
   void close()                          { }
-  int log(THD *thd, my_xid xid)         { return 1; }
+  int log_xid(THD *thd, my_xid xid)     { return 1; }
   void unlog(ulong cookie, my_xid xid)  { }
 };
 
@@ -118,7 +118,7 @@ class TC_LOG_MMAP: public TC_LOG
   TC_LOG_MMAP(): inited(0) {}
   int open(const char *opt_name);
   void close();
-  int log(THD *thd, my_xid xid);
+  int log_xid(THD *thd, my_xid xid);
   void unlog(ulong cookie, my_xid xid);
   int recover();
 
@@ -252,7 +252,7 @@ public:
 
   int open(const char *opt_name);
   void close();
-  int log(THD *thd, my_xid xid);
+  int log_xid(THD *thd, my_xid xid);
   void unlog(ulong cookie, my_xid xid);
   int recover(IO_CACHE *log, Format_description_log_event *fdle);
   void reset_bytes_written()
@@ -311,7 +311,7 @@ public:
   bool write(Log_event* event_info); // binary log write
   bool write(THD *thd, IO_CACHE *cache, Log_event *commit_event);
 
-  void start_union_events(THD *thd);
+  void start_union_events(THD *thd, query_id_t query_id_param);
   void stop_union_events(THD *thd);
   bool is_query_in_union(THD *thd, query_id_t query_id_param);
 
@@ -1687,6 +1687,7 @@ public:
   bool opt_enclosed;
   bool dumpfile;
   ulong skip_lines;
+  CHARSET_INFO *cs;
   sql_exchange(char *name,bool dumpfile_flag);
 };
 
@@ -1844,13 +1845,13 @@ class select_create: public select_insert {
   MYSQL_LOCK *lock;
   Field **field;
 public:
-  select_create(TABLE_LIST *table,
+  select_create(TABLE_LIST *table_arg,
                 HA_CREATE_INFO *create_info_arg,
                 Alter_info *alter_info_arg,
                 List<Item> &select_fields,
                 enum_duplicates duplic, bool ignore)
     :select_insert(NULL, NULL, &select_fields, 0, 0, duplic, ignore),
-    create_table(table),
+    create_table(table_arg),
     create_info(create_info_arg),
     alter_info(alter_info_arg),
     lock(0)
@@ -1957,7 +1958,9 @@ public:
 class select_singlerow_subselect :public select_subselect
 {
 public:
-  select_singlerow_subselect(Item_subselect *item):select_subselect(item){}
+  select_singlerow_subselect(Item_subselect *item_arg)
+    :select_subselect(item_arg)
+  {}
   bool send_data(List<Item> &items);
 };
 
@@ -1968,8 +1971,8 @@ class select_max_min_finder_subselect :public select_subselect
   bool (select_max_min_finder_subselect::*op)();
   bool fmax;
 public:
-  select_max_min_finder_subselect(Item_subselect *item, bool mx)
-    :select_subselect(item), cache(0), fmax(mx)
+  select_max_min_finder_subselect(Item_subselect *item_arg, bool mx)
+    :select_subselect(item_arg), cache(0), fmax(mx)
   {}
   void cleanup();
   bool send_data(List<Item> &items);
@@ -1983,7 +1986,8 @@ public:
 class select_exists_subselect :public select_subselect
 {
 public:
-  select_exists_subselect(Item_subselect *item):select_subselect(item){}
+  select_exists_subselect(Item_subselect *item_arg)
+    :select_subselect(item_arg){}
   bool send_data(List<Item> &items);
 };
 
diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc
index 94d753eb703..749ee04493b 100644
--- a/sql/sql_delete.cc
+++ b/sql/sql_delete.cc
@@ -353,6 +353,7 @@ bool mysql_prepare_delete(THD *thd, TABLE_LIST *table_list, Item **conds)
   Item *fake_conds= 0;
   SELECT_LEX *select_lex= &thd->lex->select_lex;
   DBUG_ENTER("mysql_prepare_delete");
+  List<Item> all_fields;
 
   thd->lex->allow_sum_func= 0;
   if (setup_tables_and_check_access(thd, &thd->lex->select_lex.context,
@@ -376,6 +377,11 @@ bool mysql_prepare_delete(THD *thd, TABLE_LIST *table_list, Item **conds)
       DBUG_RETURN(TRUE);
     }
   }
+
+  if (select_lex->inner_refs_list.elements &&
+    fix_inner_refs(thd, all_fields, select_lex, select_lex->ref_pointer_array))
+    DBUG_RETURN(-1);
+
   select_lex->fix_prepare_information(thd, conds, &fake_conds);
   DBUG_RETURN(FALSE);
 }
diff --git a/sql/sql_derived.cc b/sql/sql_derived.cc
index 1765f8b73fa..cd46f3bcc0e 100644
--- a/sql/sql_derived.cc
+++ b/sql/sql_derived.cc
@@ -109,8 +109,6 @@ bool mysql_derived_prepare(THD *thd, LEX *lex, TABLE_LIST *orig_table_list)
     SELECT_LEX *first_select= unit->first_select();
     TABLE *table= 0;
     select_union *derived_result;
-    bool is_union= first_select->next_select() && 
-      first_select->next_select()->linkage == UNION_TYPE;
 
     /* prevent name resolving out of derived table */
     for (SELECT_LEX *sl= first_select; sl; sl= sl->next_select())
diff --git a/sql/sql_help.cc b/sql/sql_help.cc
index 78349a6ef0d..ba7f1a534ea 100644
--- a/sql/sql_help.cc
+++ b/sql/sql_help.cc
@@ -656,6 +656,8 @@ bool mysqld_help(THD *thd, const char *mask)
     Init tables and fields to be usable from items
     tables do not contain VIEWs => we can pass 0 as conds
   */
+  thd->lex->select_lex.context.table_list= 
+    thd->lex->select_lex.context.first_name_resolution_table= &tables[0];
   setup_tables(thd, &thd->lex->select_lex.context,
                &thd->lex->select_lex.top_join_list,
                tables, 0, &leaves, FALSE);
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index 39d7f8e9b58..c7eb68ede07 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -58,8 +58,8 @@
 #include "sp_head.h"
 #include "sql_trigger.h"
 #include "sql_select.h"
+#include "slave.h"
 
-static int check_null_fields(THD *thd,TABLE *entry);
 #ifndef EMBEDDED_LIBRARY
 static TABLE *delayed_get_table(THD *thd,TABLE_LIST *table_list);
 static int write_delayed(THD *thd,TABLE *table, enum_duplicates dup, bool ignore,
@@ -189,11 +189,11 @@ static int check_insert_fields(THD *thd, TABLE_LIST *table_list,
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
     if (grant_option)
     {
-      Field_iterator_table fields;
-      fields.set_table(table);
+      Field_iterator_table field_it;
+      field_it.set_table(table);
       if (check_grant_all_columns(thd, INSERT_ACL, &table->grant,
                                   table->s->db, table->s->table_name,
-                                  &fields))
+                                  &field_it))
         return -1;
     }
 #endif
@@ -370,8 +370,6 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list,
     By default, both logs are enabled (this won't cause problems if the server
     runs without --log-update or --log-bin).
   */
-  bool log_on= (thd->options & OPTION_BIN_LOG) ||
-    (!(thd->security_ctx->master_access & SUPER_ACL));
   bool transactional_table, joins_freed= FALSE;
   bool changed;
   uint value_count;
@@ -386,6 +384,8 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list,
 #ifndef EMBEDDED_LIBRARY
   char *query= thd->query;
 #endif
+  bool log_on= (thd->options & OPTION_BIN_LOG) ||
+    (!(thd->security_ctx->master_access & SUPER_ACL));
   thr_lock_type lock_type = table_list->lock_type;
   Item *unused_conds= 0;
   DBUG_ENTER("mysql_insert");
@@ -406,11 +406,33 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list,
       (duplic == DUP_UPDATE))
     lock_type=TL_WRITE;
 #endif
+  if ((lock_type == TL_WRITE_DELAYED) &&
+      log_on && mysql_bin_log.is_open() &&
+      (values_list.elements > 1))
+  {
+    /*
+      Statement-based binary logging does not work in this case, because:
+      a) two concurrent statements may have their rows intermixed in the
+      queue, leading to autoincrement replication problems on slave (because
+      the values generated used for one statement don't depend only on the
+      value generated for the first row of this statement, so are not
+      replicable)
+      b) if first row of the statement has an error the full statement is
+      not binlogged, while next rows of the statement may be inserted.
+      c) if first row succeeds, statement is binlogged immediately with a
+      zero error code (i.e. "no error"), if then second row fails, query
+      will fail on slave too and slave will stop (wrongly believing that the
+      master got no error).
+      So we fallback to non-delayed INSERT.
+    */
+    lock_type= TL_WRITE;
+  }
   table_list->lock_type= lock_type;
 
 #ifndef EMBEDDED_LIBRARY
   if (lock_type == TL_WRITE_DELAYED)
   {
+    res= 1;
     if (thd->locked_tables)
     {
       DBUG_ASSERT(table_list->db); /* Must be set in the parser */
@@ -519,6 +541,14 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list,
   thd->cuted_fields = 0L;
   table->next_number_field=table->found_next_number_field;
 
+#ifdef HAVE_REPLICATION
+  if (thd->slave_thread &&
+      (info.handle_duplicates == DUP_UPDATE) &&
+      (table->next_number_field != NULL) &&
+      rpl_master_has_bug(&active_mi->rli, 24432))
+    goto abort;
+#endif
+
   error=0;
   id=0;
   thd->proc_info="update";
@@ -808,7 +838,6 @@ static bool check_view_insertability(THD * thd, TABLE_LIST *view)
   Field_translator *trans_start= view->field_translation,
 		   *trans_end= trans_start + num;
   Field_translator *trans;
-  Field **field_ptr= table->field;
   uint used_fields_buff_size= (table->s->fields + 7) / 8;
   uchar *used_fields_buff= (uchar*)thd->alloc(used_fields_buff_size);
   MY_BITMAP used_fields;
@@ -966,6 +995,8 @@ bool mysql_prepare_insert(THD *thd, TABLE_LIST *table_list,
   DBUG_PRINT("enter", ("table_list 0x%lx, table 0x%lx, view %d",
 		       (ulong)table_list, (ulong)table,
 		       (int)insert_into_view));
+  /* INSERT should have a SELECT or VALUES clause */
+  DBUG_ASSERT (!select_insert || !values);
 
   /*
     For subqueries in VALUES() we should not see the table in which we are
@@ -998,44 +1029,40 @@ bool mysql_prepare_insert(THD *thd, TABLE_LIST *table_list,
                                        select_insert))
     DBUG_RETURN(TRUE);
 
-  /* Save the state of the current name resolution context. */
-  ctx_state.save_state(context, table_list);
-
-  /*
-    Perform name resolution only in the first table - 'table_list',
-    which is the table that is inserted into.
-  */
-  table_list->next_local= 0;
-  context->resolve_in_table_list_only(table_list);
 
   /* Prepare the fields in the statement. */
-  if (values &&
-      !(res= check_insert_fields(thd, context->table_list, fields, *values,
-                                 !insert_into_view, &map) ||
-        setup_fields(thd, 0, *values, 0, 0, 0)) &&
-      duplic == DUP_UPDATE)
+  if (values)
   {
-    select_lex->no_wrap_view_item= TRUE;
-    res= check_update_fields(thd, context->table_list, update_fields, &map);
-    select_lex->no_wrap_view_item= FALSE;
+    /* if we have INSERT ... VALUES () we cannot have a GROUP BY clause */
+    DBUG_ASSERT (!select_lex->group_list.elements);
+
+    /* Save the state of the current name resolution context. */
+    ctx_state.save_state(context, table_list);
+
     /*
-      When we are not using GROUP BY we can refer to other tables in the
-      ON DUPLICATE KEY part.
-    */       
-    if (select_lex->group_list.elements == 0)
+      Perform name resolution only in the first table - 'table_list',
+      which is the table that is inserted into.
+     */
+    table_list->next_local= 0;
+    context->resolve_in_table_list_only(table_list);
+
+    if (!(res= check_insert_fields(thd, context->table_list, fields, *values,
+                                 !insert_into_view, &map) ||
+          setup_fields(thd, 0, *values, 0, 0, 0)) 
+        && duplic == DUP_UPDATE)
     {
-      context->table_list->next_local=       ctx_state.save_next_local;
-      /* first_name_resolution_table was set by resolve_in_table_list_only() */
-      context->first_name_resolution_table->
-        next_name_resolution_table=          ctx_state.save_next_local;
+      select_lex->no_wrap_view_item= TRUE;
+      res= check_update_fields(thd, context->table_list, update_fields, &map);
+      select_lex->no_wrap_view_item= FALSE;
     }
+
+    /* Restore the current context. */
+    ctx_state.restore_state(context, table_list);
+
     if (!res)
       res= setup_fields(thd, 0, update_values, 1, 0, 0);
   }
 
-  /* Restore the current context. */
-  ctx_state.restore_state(context, table_list);
-
   if (res)
     DBUG_RETURN(res);
 
@@ -1185,17 +1212,17 @@ int write_record(THD *thd, TABLE *table,COPY_INFO *info)
         if (res == VIEW_CHECK_ERROR)
           goto before_trg_err;
 
+        table->file->restore_auto_increment();
         if ((error=table->file->update_row(table->record[1],table->record[0])))
         {
           if ((error == HA_ERR_FOUND_DUPP_KEY) && info->ignore)
           {
-            table->file->restore_auto_increment();
             goto ok_or_after_trg_err;
           }
           goto err;
         }
         if ((table->file->table_flags() & HA_PARTIAL_COLUMN_READ) ||
-            compare_record(table, query_id))
+            compare_record(table, thd->query_id))
         {
           info->updated++;
 
@@ -2361,7 +2388,6 @@ select_insert::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
 
   if (info.handle_duplicates == DUP_UPDATE)
   {
-    /* Save the state of the current name resolution context. */
     Name_resolution_context *context= &lex->select_lex.context;
     Name_resolution_context_state ctx_state;
 
@@ -2377,18 +2403,38 @@ select_insert::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
                                     *info.update_fields, &map);
     lex->select_lex.no_wrap_view_item= FALSE;
     /*
-      When we are not using GROUP BY we can refer to other tables in the
-      ON DUPLICATE KEY part
+      When we are not using GROUP BY and there are no ungrouped aggregate functions 
+      we can refer to other tables in the ON DUPLICATE KEY part.
+      We use next_name_resolution_table descructively, so check it first (views?)
     */       
-    if (lex->select_lex.group_list.elements == 0)
-    {
-      context->table_list->next_local=       ctx_state.save_next_local;
-      /* first_name_resolution_table was set by resolve_in_table_list_only() */
-      context->first_name_resolution_table->
-        next_name_resolution_table=          ctx_state.save_next_local;
-    }
+    DBUG_ASSERT (!table_list->next_name_resolution_table);
+    if (lex->select_lex.group_list.elements == 0 &&
+        !lex->select_lex.with_sum_func)
+      /*
+        We must make a single context out of the two separate name resolution contexts :
+        the INSERT table and the tables in the SELECT part of INSERT ... SELECT.
+        To do that we must concatenate the two lists
+      */  
+      table_list->next_name_resolution_table= ctx_state.get_first_name_resolution_table();
+
     res= res || setup_fields(thd, 0, *info.update_values, 1, 0, 0);
+    if (!res)
+    {
+      /*
+        Traverse the update values list and substitute fields from the
+        select for references (Item_ref objects) to them. This is done in
+        order to get correct values from those fields when the select
+        employs a temporary table.
+      */
+      List_iterator<Item> li(*info.update_values);
+      Item *item;
 
+      while ((item= li++))
+      {
+        item->transform(&Item::update_value_transformer,
+                        (byte*)lex->current_select);
+      }
+    }
     /* Restore the current context. */
     ctx_state.restore_state(context, table_list);
   }
@@ -2428,6 +2474,15 @@ select_insert::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
   }
   restore_record(table,s->default_values);		// Get empty record
   table->next_number_field=table->found_next_number_field;
+
+#ifdef HAVE_REPLICATION
+  if (thd->slave_thread &&
+      (info.handle_duplicates == DUP_UPDATE) &&
+      (table->next_number_field != NULL) &&
+      rpl_master_has_bug(&active_mi->rli, 24432))
+    DBUG_RETURN(1);
+#endif
+
   thd->cuted_fields=0;
   if (info.ignore || info.handle_duplicates != DUP_ERROR)
     table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index ce76c35b33c..cd4d2e85316 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -286,13 +286,15 @@ static char *get_text(LEX *lex)
   {
     c = yyGet();
 #ifdef USE_MB
-    int l;
-    if (use_mb(cs) &&
-        (l = my_ismbchar(cs,
-                         (const char *)lex->ptr-1,
-                         (const char *)lex->end_of_query))) {
+    {
+      int l;
+      if (use_mb(cs) &&
+          (l = my_ismbchar(cs,
+                           (const char *)lex->ptr-1,
+                           (const char *)lex->end_of_query))) {
 	lex->ptr += l-1;
 	continue;
+      }
     }
 #endif
     if (c == '\\' &&
@@ -759,8 +761,8 @@ int MYSQLlex(void *arg, void *yythd)
       lex->tok_start=lex->ptr;			// Skip first `
       while ((c=yyGet()))
       {
-	int length;
-	if ((length= my_mbcharlen(cs, c)) == 1)
+	int var_length;
+	if ((var_length= my_mbcharlen(cs, c)) == 1)
 	{
 	  if (c == (uchar) NAMES_SEP_CHAR)
 	    break; /* Old .frm format can't handle this char */
@@ -774,9 +776,9 @@ int MYSQLlex(void *arg, void *yythd)
 	  }
 	}
 #ifdef USE_MB
-	else if (length < 1)
+	else if (var_length < 1)
 	  break;				// Error
-	lex->ptr+= length-1;
+	lex->ptr+= var_length-1;
 #endif
       }
       if (double_quotes)
@@ -1151,6 +1153,7 @@ void st_select_lex::init_query()
   cond_count= between_count= with_wild= 0;
   conds_processed_with_permanent_arena= 0;
   ref_pointer_array= 0;
+  select_n_where_fields= 0;
   select_n_having_items= 0;
   subquery_in_having= explicit_limit= 0;
   is_item_list_lookup= 0;
@@ -1192,6 +1195,7 @@ void st_select_lex::init_select()
   is_correlated= 0;
   cur_pos_in_select_list= UNDEF_POS;
   non_agg_fields.empty();
+  inner_refs_list.empty();
 }
 
 /*
@@ -1549,6 +1553,7 @@ bool st_select_lex::setup_ref_array(THD *thd, uint order_group_num)
           (Item **)arena->alloc(sizeof(Item*) * (n_child_sum_items +
                                                  item_list.elements +
                                                  select_n_having_items +
+                                                 select_n_where_fields +
                                                  order_group_num)*5)) == 0;
 }
 
@@ -1736,13 +1741,14 @@ bool st_lex::can_be_merged()
   bool selects_allow_merge= select_lex.next_select() == 0;
   if (selects_allow_merge)
   {
-    for (SELECT_LEX_UNIT *unit= select_lex.first_inner_unit();
-         unit;
-         unit= unit->next_unit())
+    for (SELECT_LEX_UNIT *tmp_unit= select_lex.first_inner_unit();
+         tmp_unit;
+         tmp_unit= tmp_unit->next_unit())
     {
-      if (unit->first_select()->parent_lex == this &&
-          (unit->item == 0 ||
-           (unit->item->place() != IN_WHERE && unit->item->place() != IN_ON)))
+      if (tmp_unit->first_select()->parent_lex == this &&
+          (tmp_unit->item == 0 ||
+           (tmp_unit->item->place() != IN_WHERE &&
+            tmp_unit->item->place() != IN_ON)))
       {
         selects_allow_merge= 0;
         break;
@@ -2039,12 +2045,12 @@ void st_lex::first_lists_tables_same()
    FALSE - success
 */
 
-bool st_lex::add_time_zone_tables_to_query_tables(THD *thd)
+bool st_lex::add_time_zone_tables_to_query_tables(THD *thd_arg)
 {
   /* We should not add these tables twice */
   if (!time_zone_tables_used)
   {
-    time_zone_tables_used= my_tz_get_table_list(thd, &query_tables_last);
+    time_zone_tables_used= my_tz_get_table_list(thd_arg, &query_tables_last);
     if (time_zone_tables_used == &fake_time_zone_tables_list)
       return TRUE;
   }
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index ae2b0d30a9c..86d01675c2a 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -397,7 +397,8 @@ protected:
 
   select_result *result;
   ulonglong found_rows_for_union;
-  bool res;
+  bool saved_error;
+
 public:
   bool  prepared, // prepare phase already performed for UNION (unit)
     optimized, // optimize phase already performed for UNION (unit)
@@ -530,6 +531,11 @@ public:
   uint select_n_having_items;
   uint cond_count;    /* number of arguments of and/or/xor in where/having/on */
   uint between_count; /* number of between predicates in where/having/on      */   
+  /*
+    Number of fields used in select list or where clause of current select
+    and all inner subselects.
+  */
+  uint select_n_where_fields;
   enum_parsing_place parsing_place; /* where we are parsing expression */
   bool with_sum_func;   /* sum function indicator */
   /* 
@@ -547,7 +553,8 @@ public:
   bool  braces;   	/* SELECT ... UNION (SELECT ... ) <- this braces */
   /* TRUE when having fix field called in processing of this SELECT */
   bool having_fix_field;
-
+  /* List of references to fields referenced from inner selects */
+  List<Item_outer_ref> inner_refs_list;
   /* Number of Item_sum-derived objects in this SELECT */
   uint n_sum_items;
   /* Number of Item_sum-derived objects in children and descendant SELECTs */
diff --git a/sql/sql_load.cc b/sql/sql_load.cc
index ede70adc378..7ed1a900fba 100644
--- a/sql/sql_load.cc
+++ b/sql/sql_load.cc
@@ -82,10 +82,11 @@ static int read_sep_field(THD *thd, COPY_INFO &info, TABLE_LIST *table_list,
                           List<Item> &set_values, READ_INFO &read_info,
 			  String &enclosed, ulong skip_lines,
 			  bool ignore_check_option_errors);
+#ifndef EMBEDDED_LIBRARY
 static bool write_execute_load_query_log_event(THD *thd,
 					       bool duplicates, bool ignore,
 					       bool transactional_table);
-
+#endif /* EMBEDDED_LIBRARY */
 
 /*
   Execute LOAD DATA query
@@ -322,7 +323,8 @@ bool mysql_load(THD *thd,sql_exchange *ex,TABLE_LIST *table_list,
   info.handle_duplicates=handle_duplicates;
   info.escape_char=escaped->length() ? (*escaped)[0] : INT_MAX;
 
-  READ_INFO read_info(file,tot_length,thd->variables.collation_database,
+  READ_INFO read_info(file,tot_length,
+                      ex->cs ? ex->cs : thd->variables.collation_database,
 		      *field_term,*ex->line_start, *ex->line_term, *enclosed,
 		      info.escape_char, read_file_from_client, is_fifo);
   if (read_info.error)
@@ -463,7 +465,6 @@ bool mysql_load(THD *thd,sql_exchange *ex,TABLE_LIST *table_list,
   }
   sprintf(name, ER(ER_LOAD_INFO), (ulong) info.records, (ulong) info.deleted,
 	  (ulong) (info.records - info.copied), (ulong) thd->cuted_fields);
-  send_ok(thd,info.copied+info.deleted,0L,name);
 
   if (!transactional_table)
     thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
@@ -484,6 +485,8 @@ bool mysql_load(THD *thd,sql_exchange *ex,TABLE_LIST *table_list,
   if (transactional_table)
     error=ha_autocommit_or_rollback(thd,error);
 
+  /* ok to client sent only after binlog write and engine commit */
+  send_ok(thd, info.copied + info.deleted, 0L, name);
 err:
   if (thd->lock)
   {
@@ -495,6 +498,8 @@ err:
 }
 
 
+#ifndef EMBEDDED_LIBRARY
+
 /* Not a very useful function; just to avoid duplication of code */
 static bool write_execute_load_query_log_event(THD *thd,
 					       bool duplicates, bool ignore,
@@ -510,6 +515,7 @@ static bool write_execute_load_query_log_event(THD *thd,
   return mysql_bin_log.write(&e);
 }
 
+#endif
 
 /****************************************************************************
 ** Read of rows of fixed size + optional garage + optonal newline
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 501e0a3dde9..2dda3e30692 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -32,6 +32,7 @@
 #include "sp_head.h"
 #include "sp.h"
 #include "sp_cache.h"
+#include "sql_trigger.h"
 
 #ifdef HAVE_OPENSSL
 /*
@@ -65,13 +66,12 @@
 extern "C" int gethostname(char *name, int namelen);
 #endif
 
-static void time_out_user_resource_limits(THD *thd, USER_CONN *uc);
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
+static void time_out_user_resource_limits(THD *thd, USER_CONN *uc);
 static int check_for_max_user_connections(THD *thd, USER_CONN *uc);
 static void decrease_user_connections(USER_CONN *uc);
 #endif /* NO_EMBEDDED_ACCESS_CHECKS */
 static bool check_db_used(THD *thd,TABLE_LIST *tables);
-static bool check_multi_update_lock(THD *thd);
 static void remove_escape(char *name);
 static bool append_file_to_dir(THD *thd, const char **filename_ptr,
 			       const char *table_name);
@@ -671,6 +671,8 @@ bool is_update_query(enum enum_sql_command command)
     safe to test and modify members of the USER_CONN structure.
 */
 
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
+
 static void time_out_user_resource_limits(THD *thd, USER_CONN *uc)
 {
   time_t check_time = thd->start_time ?  thd->start_time : time(NULL);
@@ -688,7 +690,6 @@ static void time_out_user_resource_limits(THD *thd, USER_CONN *uc)
   DBUG_VOID_RETURN;
 }
 
-
 /*
   Check if maximum queries per hour limit has been reached
   returns 0 if OK.
@@ -696,7 +697,6 @@ static void time_out_user_resource_limits(THD *thd, USER_CONN *uc)
 
 static bool check_mqh(THD *thd, uint check_command)
 {
-#ifndef NO_EMBEDDED_ACCESS_CHECKS
   bool error= 0;
   USER_CONN *uc=thd->user_connect;
   DBUG_ENTER("check_mqh");
@@ -730,11 +730,10 @@ static bool check_mqh(THD *thd, uint check_command)
 end:
   (void) pthread_mutex_unlock(&LOCK_user_conn);
   DBUG_RETURN(error);
-#else
-  return (0);
-#endif /* NO_EMBEDDED_ACCESS_CHECKS */
 }
 
+#endif /* NO_EMBEDDED_ACCESS_CHECKS */
+
 
 static void reset_mqh(LEX_USER *lu, bool get_them= 0)
 {
@@ -1617,7 +1616,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
   thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
   thd->set_time();
   VOID(pthread_mutex_lock(&LOCK_thread_count));
-  thd->query_id=query_id;
+  thd->query_id= global_query_id;
   if (command != COM_STATISTICS && command != COM_PING)
     next_query_id();
   thread_running++;
@@ -1798,7 +1797,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
 
     while (!thd->killed && thd->lex->found_semicolon && !thd->net.report_error)
     {
-      char *packet= thd->lex->found_semicolon;
+      char *next_packet= thd->lex->found_semicolon;
       net->no_send_error= 0;
       /*
         Multiple queries exits, execute them individually
@@ -1806,24 +1805,24 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
       if (thd->lock || thd->open_tables || thd->derived_tables ||
           thd->prelocked_mode)
         close_thread_tables(thd);
-      ulong length= (ulong)(packet_end-packet);
+      ulong length= (ulong)(packet_end - next_packet);
 
       log_slow_statement(thd);
 
       /* Remove garbage at start of query */
-      while (my_isspace(thd->charset(), *packet) && length > 0)
+      while (my_isspace(thd->charset(), *next_packet) && length > 0)
       {
-        packet++;
+        next_packet++;
         length--;
       }
       VOID(pthread_mutex_lock(&LOCK_thread_count));
       thd->query_length= length;
-      thd->query= packet;
+      thd->query= next_packet;
       thd->query_id= next_query_id();
       thd->set_time(); /* Reset the query start time. */
       /* TODO: set thd->lex->sql_command to SQLCOM_END here */
       VOID(pthread_mutex_unlock(&LOCK_thread_count));
-      mysql_parse(thd, packet, length);
+      mysql_parse(thd, next_packet, length);
     }
 
     if (!(specialflag & SPECIAL_NO_PRIOR))
@@ -1840,16 +1839,12 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
   {
     char *fields, *pend;
     /* Locked closure of all tables */
-    TABLE_LIST *locked_tables= NULL;
     TABLE_LIST table_list;
     LEX_STRING conv_name;
-    /* Saved variable value */
-    my_bool old_innodb_table_locks= 
-              IF_INNOBASE_DB(thd->variables.innodb_table_locks, FALSE);
+
     /* used as fields initializator */
     lex_start(thd, 0, 0);
 
-
     statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS],
 			&LOCK_status);
     bzero((char*) &table_list,sizeof(table_list));
@@ -2045,7 +2040,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
     STATUS_VAR current_global_status_var;
     calc_sum_of_all_status(&current_global_status_var);
 
-    ulong uptime = (ulong) (thd->start_time - start_time);
+    ulong uptime = (ulong) (thd->start_time - server_start_time);
     sprintf((char*) buff,
 	    "Uptime: %lu  Threads: %d  Questions: %lu  Slow queries: %lu  Opens: %lu  Flush tables: %lu  Open tables: %u  Queries per second avg: %.3f",
 	    uptime,
@@ -2092,13 +2087,14 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
   {
     statistic_increment(thd->status_var.com_stat[SQLCOM_SET_OPTION],
 			&LOCK_status);
-    enum_mysql_set_option command= (enum_mysql_set_option) uint2korr(packet);
-    switch (command) {
-    case MYSQL_OPTION_MULTI_STATEMENTS_ON:
+    uint opt_command= uint2korr(packet);
+
+    switch (opt_command) {
+    case (int) MYSQL_OPTION_MULTI_STATEMENTS_ON:
       thd->client_capabilities|= CLIENT_MULTI_STATEMENTS;
       send_eof(thd);
       break;
-    case MYSQL_OPTION_MULTI_STATEMENTS_OFF:
+    case (int) MYSQL_OPTION_MULTI_STATEMENTS_OFF:
       thd->client_capabilities&= ~CLIENT_MULTI_STATEMENTS;
       send_eof(thd);
       break;
@@ -2441,7 +2437,7 @@ mysql_execute_command(THD *thd)
 {
   bool res= FALSE;
   bool need_start_waiting= FALSE; // have protection against global read lock
-  int  result= 0;
+  int  up_result= 0;
   LEX  *lex= thd->lex;
   /* first SELECT_LEX (have special meaning for many of non-SELECTcommands) */
   SELECT_LEX *select_lex= &lex->select_lex;
@@ -2507,6 +2503,30 @@ mysql_execute_command(THD *thd)
 #ifdef HAVE_REPLICATION
   if (unlikely(thd->slave_thread))
   {
+    if (lex->sql_command == SQLCOM_DROP_TRIGGER)
+    {
+      /*
+        When dropping a trigger, we need to load its table name
+        before checking slave filter rules.
+      */
+      add_table_for_trigger(thd, thd->lex->spname, 1, &all_tables);
+      
+      if (!all_tables)
+      {
+        /*
+          If table name cannot be loaded,
+          it means the trigger does not exists possibly because
+          CREATE TRIGGER was previously skipped for this trigger
+          according to slave filtering rules.
+          Returning success without producing any errors in this case.
+        */
+        DBUG_RETURN(0);
+      }
+      
+      // force searching in slave.cc:tables_ok() 
+      all_tables->updating= 1;
+    }
+    
     /*
       Check if statment should be skipped because of slave filtering
       rules
@@ -2585,7 +2605,7 @@ mysql_execute_command(THD *thd)
           new Item_int((ulonglong)thd->variables.select_limit);
     }
 
-    select_result *result=lex->result;
+    select_result *sel_result=lex->result;
     if (all_tables)
     {
       if (lex->orig_sql_command != SQLCOM_SHOW_STATUS_PROC &&
@@ -2612,11 +2632,11 @@ mysql_execute_command(THD *thd)
           to prepend EXPLAIN to any query and receive output for it,
           even if the query itself redirects the output.
         */
-	if (!(result= new select_send()))
+	if (!(sel_result= new select_send()))
 	  goto error;
 	else
-	  thd->send_explain_fields(result);
-	res= mysql_explain_union(thd, &thd->lex->unit, result);
+	  thd->send_explain_fields(sel_result);
+	res= mysql_explain_union(thd, &thd->lex->unit, sel_result);
 	if (lex->describe & DESCRIBE_EXTENDED)
 	{
 	  char buff[1024];
@@ -2627,17 +2647,17 @@ mysql_execute_command(THD *thd)
 	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
 		       ER_YES, str.ptr());
 	}
-	result->send_eof();
-        delete result;
+	sel_result->send_eof();
+        delete sel_result;
       }
       else
       {
-	if (!result && !(result= new select_send()))
+	if (!sel_result && !(sel_result= new select_send()))
           goto error;
 	query_cache_store_query(thd, all_tables);
-	res= handle_select(thd, lex, result, 0);
-        if (result != lex->result)
-          delete result;
+	res= handle_select(thd, lex, sel_result, 0);
+        if (sel_result != lex->result)
+          delete sel_result;
       }
     }
     break;
@@ -2990,7 +3010,7 @@ mysql_execute_command(THD *thd)
     }
     if (select_lex->item_list.elements)		// With select
     {
-      select_result *result;
+      select_result *sel_result;
 
       select_lex->options|= SELECT_NO_UNLOCK;
       unit->set_limit(select_lex);
@@ -3032,19 +3052,19 @@ mysql_execute_command(THD *thd)
           select_create is currently not re-execution friendly and
           needs to be created for every execution of a PS/SP.
         */
-        if ((result= new select_create(create_table,
-                                       &create_info,
-                                       &alter_info,
-                                       select_lex->item_list,
-                                       lex->duplicates,
-                                       lex->ignore)))
+        if ((sel_result= new select_create(create_table,
+                                           &create_info,
+                                           &alter_info,
+                                           select_lex->item_list,
+                                           lex->duplicates,
+                                           lex->ignore)))
         {
           /*
             CREATE from SELECT give its SELECT_LEX for SELECT,
             and item_list belong to SELECT
           */
-          res= handle_select(thd, lex, result, 0);
-          delete result;
+          res= handle_select(thd, lex, sel_result, 0);
+          delete sel_result;
         }
       }
     }
@@ -3399,22 +3419,23 @@ end_with_restore_list:
       break;
     DBUG_ASSERT(select_lex->offset_limit == 0);
     unit->set_limit(select_lex);
-    res= (result= mysql_update(thd, all_tables,
-                               select_lex->item_list,
-                               lex->value_list,
-                               select_lex->where,
-                               select_lex->order_list.elements,
-                               (ORDER *) select_lex->order_list.first,
-                               unit->select_limit_cnt,
-                               lex->duplicates, lex->ignore));
+    res= (up_result= mysql_update(thd, all_tables,
+                                  select_lex->item_list,
+                                  lex->value_list,
+                                  select_lex->where,
+                                  select_lex->order_list.elements,
+                                  (ORDER *) select_lex->order_list.first,
+                                  unit->select_limit_cnt,
+                                  lex->duplicates, lex->ignore));
     /* mysql_update return 2 if we need to switch to multi-update */
-    if (result != 2)
+    if (up_result != 2)
       break;
+    /* Fall through */
   case SQLCOM_UPDATE_MULTI:
   {
     DBUG_ASSERT(first_table == all_tables && first_table != 0);
     /* if we switched from normal update, rights are checked */
-    if (result != 2)
+    if (up_result != 2)
     {
       if ((res= multi_update_precheck(thd, all_tables)))
         break;
@@ -3498,7 +3519,7 @@ end_with_restore_list:
   case SQLCOM_REPLACE_SELECT:
   case SQLCOM_INSERT_SELECT:
   {
-    select_result *result;
+    select_result *sel_result;
     DBUG_ASSERT(first_table == all_tables && first_table != 0);
     if ((res= insert_precheck(thd, all_tables)))
       break;
@@ -3527,13 +3548,15 @@ end_with_restore_list:
       select_lex->context.table_list= 
         select_lex->context.first_name_resolution_table= second_table;
       res= mysql_insert_select_prepare(thd);
-      if (!res && (result= new select_insert(first_table, first_table->table,
-                                             &lex->field_list,
-                                             &lex->update_list,
-                                             &lex->value_list,
-                                             lex->duplicates, lex->ignore)))
+      if (!res && (sel_result= new select_insert(first_table,
+                                                 first_table->table,
+                                                 &lex->field_list,
+                                                 &lex->update_list,
+                                                 &lex->value_list,
+                                                 lex->duplicates,
+                                                 lex->ignore)))
       {
-	res= handle_select(thd, lex, result, OPTION_SETUP_TABLES_DONE);
+	res= handle_select(thd, lex, sel_result, OPTION_SETUP_TABLES_DONE);
         /*
           Invalidate the table in the query cache if something changed
           after unlocking when changes become visible.
@@ -3551,7 +3574,7 @@ end_with_restore_list:
           first_table->next_local= save_table;
           thd->lock=0;
         }
-        delete result;
+        delete sel_result;
       }
       /* revert changes for SP */
       select_lex->table_list.first= (byte*) first_table;
@@ -3616,7 +3639,7 @@ end_with_restore_list:
     DBUG_ASSERT(first_table == all_tables && first_table != 0);
     TABLE_LIST *aux_tables=
       (TABLE_LIST *)thd->lex->auxiliary_table_list.first;
-    multi_delete *result;
+    multi_delete *del_result;
 
     if (!thd->locked_tables &&
         !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
@@ -3641,8 +3664,8 @@ end_with_restore_list:
     if ((res= mysql_multi_delete_prepare(thd)))
       goto error;
 
-    if (!thd->is_fatal_error && (result= new multi_delete(aux_tables,
-							  lex->table_count)))
+    if (!thd->is_fatal_error &&
+        (del_result= new multi_delete(aux_tables, lex->table_count)))
     {
       res= mysql_select(thd, &select_lex->ref_pointer_array,
 			select_lex->get_table_list(),
@@ -3654,8 +3677,8 @@ end_with_restore_list:
 			select_lex->options | thd->options |
 			SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK |
                         OPTION_SETUP_TABLES_DONE,
-			result, unit, select_lex);
-      delete result;
+			del_result, unit, select_lex);
+      delete del_result;
     }
     else
       res= TRUE;                                // Error
@@ -4333,7 +4356,7 @@ end_with_restore_list:
   {
     uint namelen;
     char *name;
-    int result= SP_INTERNAL_ERROR;
+    int sp_result= SP_INTERNAL_ERROR;
 
     DBUG_ASSERT(lex->sphead != 0);
     DBUG_ASSERT(lex->sphead->m_db.str); /* Must be initialized in the parser */
@@ -4406,18 +4429,18 @@ end_with_restore_list:
 
     if (!lex->definer)
     {
-      bool res= FALSE;
+      bool local_res= FALSE;
       Query_arena original_arena;
       Query_arena *ps_arena = thd->activate_stmt_arena_if_needed(&original_arena);
 
       if (!(lex->definer= create_default_definer(thd)))
-        res= TRUE;
+        local_res= TRUE;
 
       if (ps_arena)
         thd->restore_active_arena(ps_arena, &original_arena);
 
       /* Error has been already reported. */
-      if (res)
+      if (local_res)
         goto create_sp_error;
 
       if (thd->slave_thread)
@@ -4457,8 +4480,8 @@ end_with_restore_list:
     }
 #endif /* NO_EMBEDDED_ACCESS_CHECKS */
 
-    res= (result= lex->sphead->create(thd));
-    switch (result) {
+    res= (sp_result= lex->sphead->create(thd));
+    switch (sp_result) {
     case SP_OK:
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
       /* only add privileges if really neccessary */
@@ -4498,7 +4521,7 @@ create_sp_error:
     lex->unit.cleanup();
     delete lex->sphead;
     lex->sphead= 0;
-    if (result != SP_OK )
+    if (sp_result != SP_OK )
       goto error;
     send_ok(thd);
     break; /* break super switch */
@@ -4610,7 +4633,7 @@ create_sp_error:
   case SQLCOM_ALTER_PROCEDURE:
   case SQLCOM_ALTER_FUNCTION:
     {
-      int result;
+      int sp_result;
       sp_head *sp;
       st_sp_chistics chistics;
 
@@ -4625,7 +4648,7 @@ create_sp_error:
       if (! sp)
       {
 	if (lex->spname->m_db.str)
-	  result= SP_KEY_NOT_FOUND;
+	  sp_result= SP_KEY_NOT_FOUND;
 	else
 	{
 	  my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
@@ -4650,7 +4673,7 @@ create_sp_error:
         {
           my_message(ER_BINLOG_UNSAFE_ROUTINE,
 		     ER(ER_BINLOG_UNSAFE_ROUTINE), MYF(0));
-          result= SP_INTERNAL_ERROR;
+          sp_result= SP_INTERNAL_ERROR;
         }
         else
         {
@@ -4660,15 +4683,15 @@ create_sp_error:
             follow the restrictions that log-bin-trust-function-creators=0
             already puts on CREATE FUNCTION.
           */
+          /* Conditionally writes to binlog */
           if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
-            /* Conditionally writes to binlog */
-            result= sp_update_procedure(thd, lex->spname, &lex->sp_chistics);
+            sp_result= sp_update_procedure(thd, lex->spname,
+                                           &lex->sp_chistics);
           else
-            /* Conditionally writes to binlog */
-            result= sp_update_function(thd, lex->spname, &lex->sp_chistics);
+            sp_result= sp_update_function(thd, lex->spname, &lex->sp_chistics);
         }
       }
-      switch (result)
+      switch (sp_result)
       {
       case SP_OK:
 	send_ok(thd);
@@ -4687,13 +4710,13 @@ create_sp_error:
   case SQLCOM_DROP_PROCEDURE:
   case SQLCOM_DROP_FUNCTION:
     {
-      int result;
+      int sp_result;
       int type= (lex->sql_command == SQLCOM_DROP_PROCEDURE ?
                  TYPE_ENUM_PROCEDURE : TYPE_ENUM_FUNCTION);
 
-      result= sp_routine_exists_in_table(thd, type, lex->spname);
+      sp_result= sp_routine_exists_in_table(thd, type, lex->spname);
       mysql_reset_errors(thd, 0);
-      if (result == SP_OK)
+      if (sp_result == SP_OK)
       {
         char *db= lex->spname->m_db.str;
 	char *name= lex->spname->m_name.str;
@@ -4714,12 +4737,11 @@ create_sp_error:
 		       ER(ER_PROC_AUTO_REVOKE_FAIL));
 	}
 #endif
-	if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
           /* Conditionally writes to binlog */
-	  result= sp_drop_procedure(thd, lex->spname); /* Conditionally writes to binlog */
+	if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
+	  sp_result= sp_drop_procedure(thd, lex->spname);
 	else
-          /* Conditionally writes to binlog */
-	  result= sp_drop_function(thd, lex->spname); /* Conditionally writes to binlog */
+	  sp_result= sp_drop_function(thd, lex->spname);
       }
       else
       {
@@ -4743,16 +4765,15 @@ create_sp_error:
 	}
 #endif
 	if (lex->spname->m_db.str)
-	  result= SP_KEY_NOT_FOUND;
+	  sp_result= SP_KEY_NOT_FOUND;
 	else
 	{
 	  my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
 	  goto error;
 	}
       }
-      res= result;
-      switch (result)
-      {
+      res= sp_result;
+      switch (sp_result) {
       case SP_OK:
 	send_ok(thd);
 	break;
@@ -5388,7 +5409,9 @@ check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
 {
   uint found=0;
   ulong found_access=0;
+#ifndef EMBEDDED_LIBRARY
   TABLE_LIST *org_tables= tables;
+#endif
   TABLE_LIST *first_not_own_table= thd->lex->first_not_own_table();
   Security_context *sctx= thd->security_ctx, *backup_ctx= thd->security_ctx;
   /*
@@ -6592,18 +6615,18 @@ void st_select_lex::set_lock_for_tables(thr_lock_type lock_type)
     0     on success
 */
 
-bool st_select_lex_unit::add_fake_select_lex(THD *thd)
+bool st_select_lex_unit::add_fake_select_lex(THD *thd_arg)
 {
   SELECT_LEX *first_sl= first_select();
   DBUG_ENTER("add_fake_select_lex");
   DBUG_ASSERT(!fake_select_lex);
 
-  if (!(fake_select_lex= new (thd->mem_root) SELECT_LEX()))
+  if (!(fake_select_lex= new (thd_arg->mem_root) SELECT_LEX()))
       DBUG_RETURN(1);
   fake_select_lex->include_standalone(this, 
                                       (SELECT_LEX_NODE**)&fake_select_lex);
   fake_select_lex->select_number= INT_MAX;
-  fake_select_lex->parent_lex= thd->lex; /* Used in init_query. */
+  fake_select_lex->parent_lex= thd_arg->lex; /* Used in init_query. */
   fake_select_lex->make_empty_select();
   fake_select_lex->linkage= GLOBAL_OPTIONS_TYPE;
   fake_select_lex->select_limit= 0;
@@ -6623,9 +6646,9 @@ bool st_select_lex_unit::add_fake_select_lex(THD *thd)
     */ 
     global_parameters= fake_select_lex;
     fake_select_lex->no_table_names_allowed= 1;
-    thd->lex->current_select= fake_select_lex;
+    thd_arg->lex->current_select= fake_select_lex;
   }
-  thd->lex->pop_context();
+  thd_arg->lex->pop_context();
   DBUG_RETURN(0);
 }
 
diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc
index a77f68e886e..0fdbd24e05c 100644
--- a/sql/sql_prepare.cc
+++ b/sql/sql_prepare.cc
@@ -975,19 +975,19 @@ static bool insert_params_from_vars_with_log(Prepared_statement *stmt,
     /* Insert @'escaped-varname' instead of parameter in the query */
     if (entry)
     {
-      char *begin, *ptr;
+      char *start, *ptr;
       buf.length(0);
       if (buf.reserve(entry->name.length*2+3))
         DBUG_RETURN(1);
 
-      begin= ptr= buf.c_ptr_quick();
+      start= ptr= buf.c_ptr_quick();
       *ptr++= '@';
       *ptr++= '\'';
       ptr+= escape_string_for_mysql(&my_charset_utf8_general_ci,
                                     ptr, 0, entry->name.str,
                                     entry->name.length);
       *ptr++= '\'';
-      buf.length(ptr - begin);
+      buf.length(ptr - start);
       val= &buf;
     }
     else
@@ -1025,7 +1025,6 @@ static bool mysql_test_insert(Prepared_statement *stmt,
                               enum_duplicates duplic)
 {
   THD *thd= stmt->thd;
-  LEX *lex= stmt->lex;
   List_iterator_fast<List_item> its(values_list);
   List_item *values;
   DBUG_ENTER("mysql_test_insert");
@@ -1571,21 +1570,16 @@ error:
 
 static bool mysql_insert_select_prepare_tester(THD *thd)
 {
-  TABLE_LIST *first;
-  bool res;
   SELECT_LEX *first_select= &thd->lex->select_lex;
+  TABLE_LIST *second_table= ((TABLE_LIST*)first_select->table_list.first)->
+    next_local;
+
   /* Skip first table, which is the table we are inserting in */
-  first_select->table_list.first= (byte*)(first=
-                                          ((TABLE_LIST*)first_select->
-                                           table_list.first)->next_local);
-  res= mysql_insert_select_prepare(thd);
-  /*
-    insert/replace from SELECT give its SELECT_LEX for SELECT,
-    and item_list belong to SELECT
-  */
-  thd->lex->select_lex.context.resolve_in_select_list= TRUE;
-  thd->lex->select_lex.context.table_list= first;
-  return res;
+  first_select->table_list.first= (byte *) second_table;
+  thd->lex->select_lex.context.table_list=
+    thd->lex->select_lex.context.first_name_resolution_table= second_table;
+
+  return mysql_insert_select_prepare(thd);
 }
 
 
@@ -2016,6 +2010,7 @@ void mysql_sql_stmt_prepare(THD *thd)
   uint query_len;
   DBUG_ENTER("mysql_sql_stmt_prepare");
   DBUG_ASSERT(thd->protocol == &thd->protocol_simple);
+  LINT_INIT(query_len);
 
   if ((stmt= (Prepared_statement*) thd->stmt_map.find_by_name(name)))
   {
@@ -2204,7 +2199,7 @@ void mysql_stmt_execute(THD *thd, char *packet_arg, uint packet_length)
 {
   uchar *packet= (uchar*)packet_arg; // GCC 4.0.1 workaround
   ulong stmt_id= uint4korr(packet);
-  ulong flags= (ulong) ((uchar) packet[4]);
+  ulong flags= (ulong) packet[4];
   /* Query text for binary, general or slow log, if any of them is open */
   String expanded_query;
 #ifndef EMBEDDED_LIBRARY
@@ -2528,7 +2523,9 @@ void mysql_stmt_get_longdata(THD *thd, char *packet, ulong packet_length)
   uint param_number;
   Prepared_statement *stmt;
   Item_param *param;
+#ifndef EMBEDDED_LIBRARY
   char *packet_end= packet + packet_length - 1;
+#endif
   DBUG_ENTER("mysql_stmt_get_longdata");
 
   statistic_increment(thd->status_var.com_stmt_send_long_data, &LOCK_status);
@@ -2582,8 +2579,8 @@ void mysql_stmt_get_longdata(THD *thd, char *packet, ulong packet_length)
  Select_fetch_protocol_prep
 ****************************************************************************/
 
-Select_fetch_protocol_prep::Select_fetch_protocol_prep(THD *thd)
-  :protocol(thd)
+Select_fetch_protocol_prep::Select_fetch_protocol_prep(THD *thd_arg)
+  :protocol(thd_arg)
 {}
 
 bool Select_fetch_protocol_prep::send_fields(List<Item> &list, uint flags)
diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc
index 01b1149a2b3..b451c612398 100644
--- a/sql/sql_repl.cc
+++ b/sql/sql_repl.cc
@@ -22,7 +22,9 @@
 
 int max_binlog_dump_events = 0; // unlimited
 my_bool opt_sporadic_binlog_dump_fail = 0;
+#ifndef DBUG_OFF
 static int binlog_dump_count = 0;
+#endif
 
 /*
     fake_rotate_event() builds a fake (=which does not exist physically in any
@@ -882,12 +884,14 @@ int start_slave(THD* thd , MASTER_INFO* mi,  bool net_report)
 
 int stop_slave(THD* thd, MASTER_INFO* mi, bool net_report )
 {
+  DBUG_ENTER("stop_slave");
+  
   int slave_errno;
   if (!thd)
     thd = current_thd;
 
   if (check_access(thd, SUPER_ACL, any_db,0,0,0,0))
-    return 1;
+    DBUG_RETURN(1);
   thd->proc_info = "Killing slave";
   int thread_mask;
   lock_slave_threads(mi);
@@ -921,12 +925,12 @@ int stop_slave(THD* thd, MASTER_INFO* mi, bool net_report )
   {
     if (net_report)
       my_message(slave_errno, ER(slave_errno), MYF(0));
-    return 1;
+    DBUG_RETURN(1);
   }
   else if (net_report)
     send_ok(thd);
 
-  return 0;
+  DBUG_RETURN(0);
 }
 
 
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index ed108828909..5202f35f4de 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -109,7 +109,6 @@ static uint build_bitmap_for_nested_joins(List<TABLE_LIST> *join_list,
 static COND *optimize_cond(JOIN *join, COND *conds,
                            List<TABLE_LIST> *join_list,
 			   Item::cond_result *cond_value);
-static bool resolve_nested_join (TABLE_LIST *table);
 static bool const_expression_in_where(COND *conds,Item *item, Item **comp_item);
 static bool open_tmp_table(TABLE *table);
 static bool create_myisam_tmp_table(TABLE *table,TMP_TABLE_PARAM *param,
@@ -269,6 +268,70 @@ bool handle_select(THD *thd, LEX *lex, select_result *result,
 
 
 /*
+  Fix fields referenced from inner selects.
+
+  SYNOPSIS
+    fix_inner_refs()
+    thd               Thread handle
+    all_fields        List of all fields used in select
+    select            Current select
+    ref_pointer_array Array of references to Items used in current select
+
+  DESCRIPTION
+    The function fixes fields referenced from inner selects and
+    also fixes references (Item_ref objects) to these fields. Each field
+    is fixed as a usual hidden field of the current select - it is added
+    to the all_fields list and the pointer to it is saved in the
+    ref_pointer_array if latter is provided.
+    After the field has been fixed we proceed with fixing references
+    (Item_ref objects) to this field from inner subqueries. If the
+    ref_pointer_array is provided then Item_ref objects is set to
+    reference element in that array with the pointer to the field.
+
+  RETURN
+    TRUE  an error occured
+    FALSE ok
+*/
+
+bool
+fix_inner_refs(THD *thd, List<Item> &all_fields, SELECT_LEX *select,
+                 Item **ref_pointer_array)
+{
+  Item_outer_ref *ref;
+  bool res= FALSE;
+  List_iterator<Item_outer_ref> ref_it(select->inner_refs_list);
+  while ((ref= ref_it++))
+  {
+    Item_field *item= ref->outer_field;
+    /*
+      TODO: this field item already might be present in the select list.
+      In this case instead of adding new field item we could use an
+      existing one. The change will lead to less operations for copying fields,
+      smaller temporary tables and less data passed through filesort.
+    */
+    if (ref_pointer_array)
+    {
+      int el= all_fields.elements;
+      ref_pointer_array[el]= (Item*)item;
+      /* Add the field item to the select list of the current select. */
+      all_fields.push_front((Item*)item);
+      /*
+        If it's needed reset each Item_ref item that refers this field with
+        a new reference taken from ref_pointer_array.
+      */
+      ref->ref= ref_pointer_array + el;
+    }
+    if (!ref->fixed && ref->fix_fields(thd, 0))
+    {
+      res= TRUE;
+      break;
+    }
+    thd->used_tables|= item->used_tables();
+  }
+  return res;
+}
+
+/*
   Function to setup clauses without sum functions
 */
 inline int setup_without_group(THD *thd, Item **ref_pointer_array,
@@ -395,6 +458,10 @@ JOIN::prepare(Item ***rref_pointer_array,
   if (having && having->with_sum_func)
     having->split_sum_func2(thd, ref_pointer_array, all_fields,
                             &having, TRUE);
+  if (select_lex->inner_refs_list.elements &&
+      fix_inner_refs(thd, all_fields, select_lex, ref_pointer_array))
+    DBUG_RETURN(-1);
+
   if (select_lex->inner_sum_func_list)
   {
     Item_sum *end=select_lex->inner_sum_func_list;
@@ -482,6 +549,9 @@ JOIN::prepare(Item ***rref_pointer_array,
     }
   }
 
+  if (!procedure && result && result->prepare(fields_list, unit_arg))
+    goto err;					/* purecov: inspected */
+
   /* Init join struct */
   count_field_types(&tmp_table_param, all_fields, 0);
   ref_pointer_array_size= all_fields.elements*sizeof(Item*);
@@ -495,9 +565,6 @@ JOIN::prepare(Item ***rref_pointer_array,
     goto err;
   }
 #endif
-  if (!procedure && result && result->prepare(fields_list, unit_arg))
-    goto err;					/* purecov: inspected */
-
   if (select_lex->olap == ROLLUP_TYPE && rollup_init())
     goto err;
   if (alloc_func_list())
@@ -2463,14 +2530,14 @@ make_join_statistics(JOIN *join, TABLE_LIST *tables, COND *conds,
     for( ; sargables->field ; sargables++)
     {
       Field *field= sargables->field;
-      JOIN_TAB *stat= field->table->reginfo.join_tab;
+      JOIN_TAB *join_tab= field->table->reginfo.join_tab;
       key_map possible_keys= field->key_start;
       possible_keys.intersect(field->table->keys_in_use_for_query);
       bool is_const= 1;
-      for (uint i=0; i< sargables->num_values; i++)
-        is_const&= sargables->arg_value[i]->const_item();
+      for (uint j=0; j < sargables->num_values; j++)
+        is_const&= sargables->arg_value[j]->const_item();
       if (is_const)
-        stat[0].const_keys.merge(possible_keys);
+        join_tab[0].const_keys.merge(possible_keys);
     }
   }
 
@@ -2854,15 +2921,9 @@ add_key_field(KEY_FIELD **key_fields,uint and_level, Item_func *cond,
           /*
             We can't use indexes if the effective collation
             of the operation differ from the field collation.
-
-            We also cannot use index on a text column, as the column may
-            contain 'x' 'x\t' 'x ' and 'read_next_same' will stop after
-            'x' when searching for WHERE col='x '
           */
           if (field->cmp_type() == STRING_RESULT &&
-              (((Field_str*)field)->charset() != cond->compare_collation() ||
-               ((*value)->type() != Item::NULL_ITEM &&
-                (field->flags & BLOB_FLAG) && !field->binary())))
+              ((Field_str*)field)->charset() != cond->compare_collation())
             return;
         }
       }
@@ -3463,16 +3524,16 @@ update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,
   */
   if (keyuse->elements)
   {
-    KEYUSE end,*prev,*save_pos,*use;
+    KEYUSE key_end,*prev,*save_pos,*use;
 
     qsort(keyuse->buffer,keyuse->elements,sizeof(KEYUSE),
 	  (qsort_cmp) sort_keyuse);
 
-    bzero((char*) &end,sizeof(end));		/* Add for easy testing */
-    VOID(insert_dynamic(keyuse,(gptr) &end));
+    bzero((char*) &key_end,sizeof(key_end));    /* Add for easy testing */
+    VOID(insert_dynamic(keyuse,(gptr) &key_end));
 
     use=save_pos=dynamic_element(keyuse,0,KEYUSE*);
-    prev=&end;
+    prev= &key_end;
     found_eq_constant=0;
     for (i=0 ; i < keyuse->elements-1 ; i++,use++)
     {
@@ -3500,7 +3561,7 @@ update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,
       save_pos++;
     }
     i=(uint) (save_pos-(KEYUSE*) keyuse->buffer);
-    VOID(set_dynamic(keyuse,(gptr) &end,i));
+    VOID(set_dynamic(keyuse,(gptr) &key_end,i));
     keyuse->elements=i;
   }
   return FALSE;
@@ -3682,7 +3743,6 @@ best_access_path(JOIN      *join,
   double records=           DBL_MAX;
   double tmp;
   ha_rows rec;
-
   DBUG_ENTER("best_access_path");
 
   if (s->keyuse)
@@ -3722,12 +3782,12 @@ best_access_path(JOIN      *join,
             found_part|= keyuse->keypart_map;
             if (!(keyuse->used_tables & ~join->const_table_map))
               const_part|= keyuse->keypart_map;
-            double tmp= prev_record_reads(join, (found_ref |
+            double tmp2= prev_record_reads(join, (found_ref |
                                                  keyuse->used_tables));
-            if (tmp < best_prev_record_reads)
+            if (tmp2 < best_prev_record_reads)
             {
               best_part_found_ref= keyuse->used_tables & ~join->const_table_map;
-              best_prev_record_reads= tmp;
+              best_prev_record_reads= tmp2;
             }
             if (rec > keyuse->ref_table_rows)
               rec= keyuse->ref_table_rows;
@@ -5133,13 +5193,15 @@ get_store_key(THD *thd, KEYUSE *keyuse, table_map used_tables,
 				    key_part->length,
 				    keyuse->val);
   }
-  else if (keyuse->val->type() == Item::FIELD_ITEM)
+  else if (keyuse->val->type() == Item::FIELD_ITEM ||
+           (keyuse->val->type() == Item::REF_ITEM &&
+            ((Item_ref*)keyuse->val)->ref_type() == Item_ref::OUTER_REF) )
     return new store_key_field(thd,
 			       key_part->field,
 			       key_buff + maybe_null,
 			       maybe_null ? key_buff : 0,
 			       key_part->length,
-			       ((Item_field*) keyuse->val)->field,
+			       ((Item_field*) keyuse->val->real_item())->field,
 			       keyuse->val->full_name());
   return new store_key_item(thd,
 			    key_part->field,
@@ -5778,37 +5840,42 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
 	*/     
         COND *on_expr= *first_inner_tab->on_expr_ref;
 
-        table_map used_tables= join->const_table_map |
-		               OUTER_REF_TABLE_BIT | RAND_TABLE_BIT;
+        table_map used_tables2= (join->const_table_map |
+                                 OUTER_REF_TABLE_BIT | RAND_TABLE_BIT);
 	for (tab= join->join_tab+join->const_tables; tab <= last_tab ; tab++)
         {
           current_map= tab->table->map;
-          used_tables|= current_map;
-          COND *tmp= make_cond_for_table(on_expr, used_tables, current_map);
-          if (tmp)
+          used_tables2|= current_map;
+          COND *tmp_cond= make_cond_for_table(on_expr, used_tables2,
+                                             current_map);
+          if (tmp_cond)
           {
             JOIN_TAB *cond_tab= tab < first_inner_tab ? first_inner_tab : tab;
             /*
               First add the guards for match variables of
               all embedding outer join operations.
 	    */
-            if (!(tmp= add_found_match_trig_cond(cond_tab->first_inner,
-                                                 tmp, first_inner_tab)))
+            if (!(tmp_cond= add_found_match_trig_cond(cond_tab->first_inner,
+                                                     tmp_cond,
+                                                     first_inner_tab)))
               DBUG_RETURN(1);
             /* 
               Now add the guard turning the predicate off for 
               the null complemented row.
 	    */ 
             DBUG_PRINT("info", ("Item_func_trig_cond"));
-            tmp= new Item_func_trig_cond(tmp, 
-                                         &first_inner_tab->not_null_compl);
-            DBUG_PRINT("info", ("Item_func_trig_cond 0x%lx", (ulong) tmp));
-            if (tmp)
-              tmp->quick_fix_field();
+            tmp_cond= new Item_func_trig_cond(tmp_cond,
+                                              &first_inner_tab->
+                                              not_null_compl);
+            DBUG_PRINT("info", ("Item_func_trig_cond 0x%lx",
+                                (ulong) tmp_cond));
+            if (tmp_cond)
+              tmp_cond->quick_fix_field();
 	    /* Add the predicate to other pushed down predicates */
             DBUG_PRINT("info", ("Item_cond_and"));
-            cond_tab->select_cond= !cond_tab->select_cond ? tmp :
-	                          new Item_cond_and(cond_tab->select_cond,tmp);
+            cond_tab->select_cond= !cond_tab->select_cond ? tmp_cond :
+	                          new Item_cond_and(cond_tab->select_cond,
+                                                    tmp_cond);
             DBUG_PRINT("info", ("Item_cond_and 0x%lx",
                                 (ulong)cond_tab->select_cond));
             if (!cond_tab->select_cond)
@@ -6125,7 +6192,7 @@ void JOIN_TAB::cleanup()
 
 void JOIN::join_free()
 {
-  SELECT_LEX_UNIT *unit;
+  SELECT_LEX_UNIT *tmp_unit;
   SELECT_LEX *sl;
   /*
     Optimization: if not EXPLAIN and we are done with the JOIN,
@@ -6137,8 +6204,10 @@ void JOIN::join_free()
 
   cleanup(full);
 
-  for (unit= select_lex->first_inner_unit(); unit; unit= unit->next_unit())
-    for (sl= unit->first_select(); sl; sl= sl->next_select())
+  for (tmp_unit= select_lex->first_inner_unit();
+       tmp_unit;
+       tmp_unit= tmp_unit->next_unit())
+    for (sl= tmp_unit->first_select(); sl; sl= sl->next_select())
     {
       Item_subselect *subselect= sl->master_unit()->item;
       bool full_local= full && (!subselect || subselect->is_evaluated());
@@ -6776,9 +6845,9 @@ static bool check_simple_equality(Item *left_item, Item *right_item,
       else 
       {
         /* None of the fields was found in multiple equalities */
-        Item_equal *item= new Item_equal((Item_field *) left_item,
-                                         (Item_field *) right_item);
-        cond_equal->current_level.push_back(item);
+        Item_equal *item_equal= new Item_equal((Item_field *) left_item,
+                                               (Item_field *) right_item);
+        cond_equal->current_level.push_back(item_equal);
       }
     }
     return TRUE;
@@ -6885,8 +6954,8 @@ static bool check_row_equality(Item *left_row, Item_row *right_row,
   for (uint i= 0 ; i < n; i++)
   {
     bool is_converted;
-    Item *left_item= left_row->el(i);
-    Item *right_item= right_row->el(i);
+    Item *left_item= left_row->element_index(i);
+    Item *right_item= right_row->element_index(i);
     if (left_item->type() == Item::ROW_ITEM &&
         right_item->type() == Item::ROW_ITEM)
       is_converted= check_row_equality((Item_row *) left_item,
@@ -7276,14 +7345,15 @@ static COND *build_equal_items(THD *thd, COND *cond,
     {
       if (table->on_expr)
       {
-        List<TABLE_LIST> *join_list= table->nested_join ?
-	                             &table->nested_join->join_list : NULL;
+        List<TABLE_LIST> *nested_join_list= table->nested_join ?
+          &table->nested_join->join_list : NULL;
         /*
           We can modify table->on_expr because its old value will
           be restored before re-execution of PS/SP.
         */
         table->on_expr= build_equal_items(thd, table->on_expr, inherited,
-                                          join_list, &table->cond_equal);
+                                          nested_join_list,
+                                          &table->cond_equal);
       }
     }
   }
@@ -7640,7 +7710,7 @@ change_cond_ref_to_const(THD *thd, I_List<COND_CMP> *save_list,
        value->result_type() != STRING_RESULT ||
        left_item->collation.collation == value->collation.collation))
   {
-    Item *tmp=value->new_item();
+    Item *tmp=value->clone_item();
     tmp->collation.set(right_item->collation);
     
     if (tmp)
@@ -7664,7 +7734,7 @@ change_cond_ref_to_const(THD *thd, I_List<COND_CMP> *save_list,
             value->result_type() != STRING_RESULT ||
             right_item->collation.collation == value->collation.collation))
   {
-    Item *tmp=value->new_item();
+    Item *tmp= value->clone_item();
     tmp->collation.set(left_item->collation);
     
     if (tmp)
@@ -8075,7 +8145,7 @@ static uint build_bitmap_for_nested_joins(List<TABLE_LIST> *join_list,
       */
       if (nested_join->join_list.elements != 1)
       {
-        nested_join->nj_map= 1 << first_unused++;
+        nested_join->nj_map= (nested_join_map) 1 << first_unused++;
         first_unused= build_bitmap_for_nested_joins(&nested_join->join_list,
                                                     first_unused);
       }
@@ -8285,7 +8355,6 @@ optimize_cond(JOIN *join, COND *conds, List<TABLE_LIST> *join_list,
               Item::cond_result *cond_value)
 {
   THD *thd= join->thd;
-  SELECT_LEX *select= thd->lex->current_select;    
   DBUG_ENTER("optimize_cond");
 
   if (!conds)
@@ -8699,7 +8768,8 @@ static Field *create_tmp_field_from_item(THD *thd, Item *item, TABLE *table,
       type they needed to be handled separately.
     */
     if ((type= item->field_type()) == MYSQL_TYPE_DATETIME ||
-        type == MYSQL_TYPE_TIME || type == MYSQL_TYPE_DATE)
+        type == MYSQL_TYPE_TIME || type == MYSQL_TYPE_DATE ||
+        type == MYSQL_TYPE_TIMESTAMP)
       new_field= item->tmp_table_field_from_field_type(table);
     /* 
       Make sure that the blob fits into a Field_varstring which has 
@@ -8806,8 +8876,7 @@ Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
   Item *orig_item= 0;
 
   if (type != Item::FIELD_ITEM &&
-      item->real_item()->type() == Item::FIELD_ITEM &&
-      !((Item_ref *) item)->depended_from)
+      item->real_item()->type() == Item::FIELD_ITEM)
   {
     orig_item= item;
     item= item->real_item();
@@ -10051,6 +10120,7 @@ do_select(JOIN *join,List<Item> *fields,TABLE *table,Procedure *procedure)
   enum_nested_loop_state error= NESTED_LOOP_OK;
   JOIN_TAB *join_tab;
   DBUG_ENTER("do_select");
+  LINT_INIT(join_tab);
 
   join->procedure=procedure;
   join->tmp_table= table;			/* Save for easy recursion */
@@ -10095,7 +10165,6 @@ do_select(JOIN *join,List<Item> *fields,TABLE *table,Procedure *procedure)
   else
   {
     DBUG_ASSERT(join->tables);
-    DBUG_ASSERT(join_tab);
     error= sub_select(join,join_tab,0);
     if (error == NESTED_LOOP_OK || error == NESTED_LOOP_NO_MORE_ROWS)
       error= sub_select(join,join_tab,1);
@@ -13465,10 +13534,8 @@ count_field_types(TMP_TABLE_PARAM *param, List<Item> &fields,
   param->quick_group=1;
   while ((field=li++))
   {
-    Item::Type type=field->type();
     Item::Type real_type= field->real_item()->type();
-    if (type == Item::FIELD_ITEM || (real_type == Item::FIELD_ITEM &&
-        !((Item_ref *) field)->depended_from))
+    if (real_type == Item::FIELD_ITEM)
       param->field_count++;
     else if (real_type == Item::SUM_FUNC_ITEM)
     {
@@ -14608,7 +14675,7 @@ int JOIN::rollup_send_data(uint idx)
     1   if write_data_failed()
 */
 
-int JOIN::rollup_write_data(uint idx, TABLE *table)
+int JOIN::rollup_write_data(uint idx, TABLE *table_arg)
 {
   uint i;
   for (i= send_group_parts ; i-- > idx ; )
@@ -14619,7 +14686,7 @@ int JOIN::rollup_write_data(uint idx, TABLE *table)
 	   ref_pointer_array_size);
     if ((!having || having->val_int()))
     {
-      int error;
+      int write_error;
       Item *item;
       List_iterator_fast<Item> it(rollup.fields[i]);
       while ((item= it++))
@@ -14628,10 +14695,10 @@ int JOIN::rollup_write_data(uint idx, TABLE *table)
           item->save_in_result_field(1);
       }
       copy_sum_funcs(sum_funcs_end[i+1], sum_funcs_end[i]);
-      if ((error= table->file->write_row(table->record[0])))
+      if ((write_error= table_arg->file->write_row(table_arg->record[0])))
       {
-	if (create_myisam_from_heap(thd, table, &tmp_table_param,
-				      error, 0))
+	if (create_myisam_from_heap(thd, table_arg, &tmp_table_param,
+                                    write_error, 0))
 	  return 1;		     
       }
     }
@@ -14812,9 +14879,9 @@ static void select_describe(JOIN *join, bool need_tmp_table, bool need_order,
       }
       else
       {
-        TABLE_LIST *tab=table->pos_in_table_list; 
-	item_list.push_back(new Item_string(tab->alias,
-					    strlen(tab->alias),
+        TABLE_LIST *real_table= table->pos_in_table_list; 
+	item_list.push_back(new Item_string(real_table->alias,
+					    strlen(real_table->alias),
 					    cs));
       }
       /* type */
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 659dd49d537..c4b06934fc3 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -28,11 +28,11 @@
 #include "ha_berkeley.h"			// For berkeley_show_logs
 #endif
 
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
 static const char *grant_names[]={
   "select","insert","update","delete","create","drop","reload","shutdown",
   "process","file","grant","references","index","alter"};
 
-#ifndef NO_EMBEDDED_ACCESS_CHECKS
 static TYPELIB grant_types = { sizeof(grant_names)/sizeof(char **),
                                "grant_types",
                                grant_names, NULL};
@@ -462,10 +462,10 @@ mysqld_show_create(THD *thd, TABLE_LIST *table_list)
 bool mysqld_show_create_db(THD *thd, char *dbname,
                            const HA_CREATE_INFO *create_info)
 {
-  Security_context *sctx= thd->security_ctx;
   char buff[2048];
   String buffer(buff, sizeof(buff), system_charset_info);
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
+  Security_context *sctx= thd->security_ctx;
   uint db_access;
 #endif
   HA_CREATE_INFO create;
@@ -794,7 +794,7 @@ static int
 store_create_info(THD *thd, TABLE_LIST *table_list, String *packet)
 {
   List<Item> field_list;
-  char tmp[MAX_FIELD_WIDTH], *for_str, buff[128], *end;
+  char tmp[MAX_FIELD_WIDTH], *for_str, buff[128];
   const char *alias;
   String type(tmp, sizeof(tmp), system_charset_info);
   Field **ptr,*field;
@@ -1036,8 +1036,9 @@ store_create_info(THD *thd, TABLE_LIST *table_list, String *packet)
       but may extrapolate its existence from that of an AUTO_INCREMENT column.
     */
 
-    if(create_info.auto_increment_value > 1)
+    if (create_info.auto_increment_value > 1)
     {
+      char *end;
       packet->append(" AUTO_INCREMENT=", 16);
       end= longlong10_to_str(create_info.auto_increment_value, buff,10);
       packet->append(buff, (uint) (end - buff));
@@ -1059,6 +1060,7 @@ store_create_info(THD *thd, TABLE_LIST *table_list, String *packet)
 
     if (share->min_rows)
     {
+      char *end;
       packet->append(STRING_WITH_LEN(" MIN_ROWS="));
       end= longlong10_to_str(share->min_rows, buff, 10);
       packet->append(buff, (uint) (end- buff));
@@ -1066,6 +1068,7 @@ store_create_info(THD *thd, TABLE_LIST *table_list, String *packet)
 
     if (share->max_rows && !table_list->schema_table)
     {
+      char *end;
       packet->append(STRING_WITH_LEN(" MAX_ROWS="));
       end= longlong10_to_str(share->max_rows, buff, 10);
       packet->append(buff, (uint) (end - buff));
@@ -1073,6 +1076,7 @@ store_create_info(THD *thd, TABLE_LIST *table_list, String *packet)
 
     if (share->avg_row_length)
     {
+      char *end;
       packet->append(STRING_WITH_LEN(" AVG_ROW_LENGTH="));
       end= longlong10_to_str(share->avg_row_length, buff,10);
       packet->append(buff, (uint) (end - buff));
@@ -1443,7 +1447,7 @@ static bool show_status_array(THD *thd, const char *wild,
         long nr;
         if (show_type == SHOW_SYS)
         {
-          show_type= ((sys_var*) value)->type();
+          show_type= ((sys_var*) value)->show_type();
           value=     (char*) ((sys_var*) value)->value_ptr(thd, value_type,
                                                            &null_lex_str);
         }
@@ -1489,7 +1493,7 @@ static bool show_status_array(THD *thd, const char *wild,
           break;
         }
         case SHOW_STARTTIME:
-          nr= (long) (thd->query_start() - start_time);
+          nr= (long) (thd->query_start() - server_start_time);
           end= int10_to_str(nr, buff, 10);
           break;
         case SHOW_QUESTION:
@@ -2118,19 +2122,21 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond)
   List<char> bases;
   List_iterator_fast<char> it(bases);
   COND *partial_cond;
-  Security_context *sctx= thd->security_ctx;
   uint derived_tables= lex->derived_tables; 
   int error= 1;
   db_type not_used;
   Open_tables_state open_tables_state_backup;
   bool save_view_prepare_mode= lex->view_prepare_mode;
   Query_tables_list query_tables_list_backup;
-  lex->view_prepare_mode= TRUE;
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
+  Security_context *sctx= thd->security_ctx;
+#endif
   DBUG_ENTER("get_all_tables");
 
   LINT_INIT(end);
   LINT_INIT(len);
 
+  lex->view_prepare_mode= TRUE;
   lex->reset_n_backup_query_tables_list(&query_tables_list_backup);
 
   /*
@@ -2368,7 +2374,9 @@ int fill_schema_shemata(THD *thd, TABLE_LIST *tables, COND *cond)
   bool with_i_schema;
   HA_CREATE_INFO create;
   TABLE *table= tables->table;
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
   Security_context *sctx= thd->security_ctx;
+#endif
   DBUG_ENTER("fill_schema_shemata");
 
   if (make_db_list(thd, &files, &idx_field_vals,
@@ -2507,20 +2515,21 @@ static int get_schema_tables_record(THD *thd, struct st_table_list *tables,
     if (file->create_time)
     {
       thd->variables.time_zone->gmt_sec_to_TIME(&time,
-                                                file->create_time);
+                                                (my_time_t) file->create_time);
       table->field[14]->store_time(&time, MYSQL_TIMESTAMP_DATETIME);
       table->field[14]->set_notnull();
     }
     if (file->update_time)
     {
       thd->variables.time_zone->gmt_sec_to_TIME(&time,
-                                                file->update_time);
+                                                (my_time_t) file->update_time);
       table->field[15]->store_time(&time, MYSQL_TIMESTAMP_DATETIME);
       table->field[15]->set_notnull();
     }
     if (file->check_time)
     {
-      thd->variables.time_zone->gmt_sec_to_TIME(&time, file->check_time);
+      thd->variables.time_zone->gmt_sec_to_TIME(&time,
+                                                (my_time_t) file->check_time);
       table->field[16]->store_time(&time, MYSQL_TIMESTAMP_DATETIME);
       table->field[16]->set_notnull();
     }
@@ -2720,7 +2729,7 @@ static int get_schema_column_record(THD *thd, struct st_table_list *tables,
         field->real_type() == MYSQL_TYPE_VARCHAR ||  // For varbinary type
         field->real_type() == MYSQL_TYPE_STRING)     // For binary type
     {
-      uint32 octet_max_length= field->max_length();
+      uint32 octet_max_length= field->max_display_length();
       if (is_blob && octet_max_length != (uint32) 4294967295U)
         octet_max_length /= field->charset()->mbmaxlen;
       longlong char_max_len= is_blob ? 
@@ -2750,10 +2759,10 @@ static int get_schema_column_record(THD *thd, struct st_table_list *tables,
     case FIELD_TYPE_LONG:
     case FIELD_TYPE_LONGLONG:
     case FIELD_TYPE_INT24:
-      field_length= field->max_length() - 1;
+      field_length= field->max_display_length() - 1;
       break;
     case FIELD_TYPE_BIT:
-      field_length= field->max_length();
+      field_length= field->max_display_length();
       decimals= -1;                             // return NULL
       break;
     case FIELD_TYPE_FLOAT:  
@@ -3420,8 +3429,8 @@ static int get_schema_key_column_usage_record(THD *thd,
 
     show_table->file->get_foreign_key_list(thd, &f_key_list);
     FOREIGN_KEY_INFO *f_key_info;
-    List_iterator_fast<FOREIGN_KEY_INFO> it(f_key_list);
-    while ((f_key_info= it++))
+    List_iterator_fast<FOREIGN_KEY_INFO> fkey_it(f_key_list);
+    while ((f_key_info= fkey_it++))
     {
       LEX_STRING *f_info;
       LEX_STRING *r_info;
diff --git a/sql/sql_string.cc b/sql/sql_string.cc
index ef50e5864a5..9d7df73cd7a 100644
--- a/sql/sql_string.cc
+++ b/sql/sql_string.cc
@@ -617,27 +617,26 @@ skip:
 }
 
 /*
-** replace substring with string
-** If wrong parameter or not enough memory, do nothing
+  Replace substring with string
+  If wrong parameter or not enough memory, do nothing
 */
 
-
 bool String::replace(uint32 offset,uint32 arg_length,const String &to)
 {
   return replace(offset,arg_length,to.ptr(),to.length());
 }
 
 bool String::replace(uint32 offset,uint32 arg_length,
-                     const char *to,uint32 length)
+                     const char *to, uint32 to_length)
 {
-  long diff = (long) length-(long) arg_length;
+  long diff = (long) to_length-(long) arg_length;
   if (offset+arg_length <= str_length)
   {
     if (diff < 0)
     {
-      if (length)
-	memcpy(Ptr+offset,to,length);
-      bmove(Ptr+offset+length,Ptr+offset+arg_length,
+      if (to_length)
+	memcpy(Ptr+offset,to,to_length);
+      bmove(Ptr+offset+to_length,Ptr+offset+arg_length,
 	    str_length-offset-arg_length);
     }
     else
@@ -649,8 +648,8 @@ bool String::replace(uint32 offset,uint32 arg_length,
 	bmove_upp(Ptr+str_length+diff,Ptr+str_length,
 		  str_length-offset-arg_length);
       }
-      if (length)
-	memcpy(Ptr+offset,to,length);
+      if (to_length)
+	memcpy(Ptr+offset,to,to_length);
     }
     str_length+=(uint32) diff;
   }
diff --git a/sql/sql_string.h b/sql/sql_string.h
index f4250f4c70a..c1d27cb1791 100644
--- a/sql/sql_string.h
+++ b/sql/sql_string.h
@@ -86,7 +86,8 @@ public:
   { /* never called */ }
   ~String() { free(); }
 
-  inline void set_charset(CHARSET_INFO *charset) { str_charset= charset; }
+  inline void set_charset(CHARSET_INFO *charset_arg)
+  { str_charset= charset_arg; }
   inline CHARSET_INFO *charset() const { return str_charset; }
   inline uint32 length() const { return str_length;}
   inline uint32 alloced_length() const { return Alloced_length;}
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 6f57ac1ec42..512d990347f 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -222,9 +222,10 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists,
   String wrong_tables;
   int error;
   bool some_tables_deleted=0, tmp_table_deleted=0, foreign_key_error=0;
-
   DBUG_ENTER("mysql_rm_table_part2");
 
+  LINT_INIT(alias);
+
   if (!drop_temporary && lock_table_names(thd, tables))
     DBUG_RETURN(1);
 
@@ -773,14 +774,14 @@ static int mysql_prepare_table(THD *thd, HA_CREATE_INFO *create_info,
 
         interval= sql_field->interval= typelib(stmt_root,
                                                sql_field->interval_list);
-        List_iterator<String> it(sql_field->interval_list);
+        List_iterator<String> int_it(sql_field->interval_list);
         String conv, *tmp;
         char comma_buf[2];
         int comma_length= cs->cset->wc_mb(cs, ',', (uchar*) comma_buf,
                                           (uchar*) comma_buf + 
                                           sizeof(comma_buf));
         DBUG_ASSERT(comma_length > 0);
-        for (uint i= 0; (tmp= it++); i++)
+        for (uint i= 0; (tmp= int_it++); i++)
         {
           uint lengthsp;
           if (String::needs_conversion(tmp->length(), tmp->charset(),
@@ -2160,7 +2161,7 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
                                                             HA_CHECK_OPT *),
                               int (view_operator_func)(THD *, TABLE_LIST*))
 {
-  TABLE_LIST *table, *save_next_global, *save_next_local;
+  TABLE_LIST *table;
   SELECT_LEX *select= &thd->lex->select_lex;
   List<Item> field_list;
   Item *item;
@@ -2191,30 +2192,33 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
     strxmov(table_name, db, ".", table->table_name, NullS);
     thd->open_options|= extra_open_options;
     table->lock_type= lock_type;
-    /* open only one table from local list of command */
-    save_next_global= table->next_global;
-    table->next_global= 0;
-    save_next_local= table->next_local;
-    table->next_local= 0;
-    select->table_list.first= (byte*)table;
-    /*
-      Time zone tables and SP tables can be add to lex->query_tables list,
-      so it have to be prepared.
-      TODO: Investigate if we can put extra tables into argument instead of
-      using lex->query_tables
-    */
-    lex->query_tables= table;
-    lex->query_tables_last= &table->next_global;
-    lex->query_tables_own_last= 0;
-    thd->no_warnings_for_error= no_warnings_for_error;
-    if (view_operator_func == NULL)
-      table->required_type=FRMTYPE_TABLE;
-    open_and_lock_tables(thd, table);
-    thd->no_warnings_for_error= 0;
-    table->next_global= save_next_global;
-    table->next_local= save_next_local;
-    thd->open_options&= ~extra_open_options;
 
+    /* open only one table from local list of command */
+    {
+      TABLE_LIST *save_next_global, *save_next_local;
+      save_next_global= table->next_global;
+      table->next_global= 0;
+      save_next_local= table->next_local;
+      table->next_local= 0;
+      select->table_list.first= (byte*)table;
+      /*
+        Time zone tables and SP tables can be add to lex->query_tables list,
+        so it have to be prepared.
+        TODO: Investigate if we can put extra tables into argument instead of
+        using lex->query_tables
+      */
+      lex->query_tables= table;
+      lex->query_tables_last= &table->next_global;
+      lex->query_tables_own_last= 0;
+      thd->no_warnings_for_error= no_warnings_for_error;
+      if (view_operator_func == NULL)
+        table->required_type=FRMTYPE_TABLE;
+      open_and_lock_tables(thd, table);
+      thd->no_warnings_for_error= 0;
+      table->next_global= save_next_global;
+      table->next_local= save_next_local;
+      thd->open_options&= ~extra_open_options;
+    }
     if (prepare_func)
     {
       switch ((*prepare_func)(thd, table, check_opt)) {
@@ -3011,7 +3015,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
                        uint order_num, ORDER *order, bool ignore)
 {
   TABLE *table,*new_table=0;
-  int error;
+  int error= 0;
   char tmp_name[80],old_name[32],new_name_buff[FN_REFLEN];
   char new_alias_buff[FN_REFLEN], *table_name, *db, *new_alias, *alias;
   char index_file[FN_REFLEN], data_file[FN_REFLEN];
@@ -3064,9 +3068,11 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
       DBUG_RETURN(1);
     VOID(pthread_mutex_lock(&LOCK_open));
     if (lock_table_names(thd, table_list))
+    {
+      error= 1;
       goto view_err;
+    }
     
-    error=0;
     if (!do_rename(thd, table_list, new_db, new_name, new_name, 1))
     {
       if (mysql_bin_log.is_open())
@@ -3165,7 +3171,6 @@ view_err:
   {
     switch (alter_info->keys_onoff) {
     case LEAVE_AS_IS:
-      error= 0;
       break;
     case ENABLE:
       /*
@@ -3193,10 +3198,10 @@ view_err:
     }
     if (error == HA_ERR_WRONG_COMMAND)
     {
+      error= 0;
       push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
 			  ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
 			  table->alias);
-      error= 0;
     }
 
     VOID(pthread_mutex_lock(&LOCK_open));
@@ -3236,10 +3241,10 @@ view_err:
 
     if (error == HA_ERR_WRONG_COMMAND)
     {
+      error= 0;
       push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
 			  ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
 			  table->alias);
-      error= 0;
     }
 
     if (!error)
diff --git a/sql/sql_trigger.cc b/sql/sql_trigger.cc
index 632f9933532..42a361cc464 100644
--- a/sql/sql_trigger.cc
+++ b/sql/sql_trigger.cc
@@ -106,10 +106,6 @@ const LEX_STRING trg_event_type_names[]=
 };
 
 
-static int
-add_table_for_trigger(THD *thd, sp_name *trig, bool if_exists,
-                      TABLE_LIST ** table);
-
 class Handle_old_incorrect_sql_modes_hook: public Unknown_key_hook
 {
 private:
@@ -800,8 +796,8 @@ bool Table_triggers_list::prepare_record1_accessors(TABLE *table)
 
 void Table_triggers_list::set_table(TABLE *new_table)
 {
-  table= new_table;
-  for (Field **field= table->triggers->record1_field ; *field ; field++)
+  trigger_table= new_table;
+  for (Field **field= new_table->triggers->record1_field ; *field ; field++)
   {
     (*field)->table= (*field)->orig_table= new_table;
     (*field)->table_name= &new_table->alias;
@@ -1182,7 +1178,7 @@ bool Table_triggers_list::get_trigger_info(THD *thd, trg_event_type event,
     1 Error
 */
 
-static int
+int
 add_table_for_trigger(THD *thd, sp_name *trig, bool if_exists,
                       TABLE_LIST **table)
 {
@@ -1365,7 +1361,8 @@ Table_triggers_list::change_table_name_in_triggers(THD *thd,
       It is OK to allocate some memory on table's MEM_ROOT since this
       table instance will be thrown out at the end of rename anyway.
     */
-    new_def.str= memdup_root(&table->mem_root, buff.ptr(), buff.length());
+    new_def.str= memdup_root(&trigger_table->mem_root, buff.ptr(),
+                             buff.length());
     new_def.length= buff.length();
     on_table_name->str= new_def.str + before_on_len;
     on_table_name->length= on_q_table_name_len;
@@ -1545,17 +1542,17 @@ bool Table_triggers_list::process_triggers(THD *thd, trg_event_type event,
     if (old_row_is_record1)
     {
       old_field= record1_field;
-      new_field= table->field;
+      new_field= trigger_table->field;
     }
     else
     {
       new_field= record1_field;
-      old_field= table->field;
+      old_field= trigger_table->field;
     }
 
     thd->reset_sub_statement_state(&statement_state, SUB_STMT_TRIGGER);
     err_status= sp_trigger->execute_trigger
-      (thd, table->s->db, table->s->table_name,
+      (thd, trigger_table->s->db, trigger_table->s->table_name,
        &subject_table_grants[event][time_type]);
     thd->restore_sub_statement_state(&statement_state);
   }
@@ -1591,7 +1588,7 @@ void Table_triggers_list::mark_fields_used(THD *thd, trg_event_type event)
     {
       /* We cannot mark fields which does not present in table. */
       if (trg_field->field_idx != (uint)-1)
-        table->field[trg_field->field_idx]->query_id = thd->query_id;
+        trigger_table->field[trg_field->field_idx]->query_id = thd->query_id;
     }
   }
 }
@@ -1622,7 +1619,7 @@ bool Table_triggers_list::is_updated_in_before_update_triggers(Field *fld)
   {
     if (trg_fld->get_settable_routine_parameter() &&
         trg_fld->field_idx != (uint)-1 &&
-        table->field[trg_fld->field_idx]->eq(fld))
+        trigger_table->field[trg_fld->field_idx]->eq(fld))
       return TRUE;
   }
   return FALSE;
diff --git a/sql/sql_trigger.h b/sql/sql_trigger.h
index 91ce571e3f5..19b2b24a3fe 100644
--- a/sql/sql_trigger.h
+++ b/sql/sql_trigger.h
@@ -42,8 +42,9 @@ class Table_triggers_list: public Sql_alloc
   */
   Field             **new_field;
   Field             **old_field;
+
   /* TABLE instance for which this triggers list object was created */
-  TABLE *table;
+  TABLE *trigger_table;
   /*
     Names of triggers.
     Should correspond to order of triggers on definitions_list,
@@ -83,7 +84,7 @@ public:
   List<LEX_STRING>  definers_list;
 
   Table_triggers_list(TABLE *table_arg):
-    record1_field(0), table(table_arg)
+    record1_field(0), trigger_table(table_arg)
   {
     bzero((char *)bodies, sizeof(bodies));
     bzero((char *)trigger_fields, sizeof(trigger_fields));
@@ -138,3 +139,7 @@ private:
 
 extern const LEX_STRING trg_action_time_type_names[];
 extern const LEX_STRING trg_event_type_names[];
+
+int
+add_table_for_trigger(THD *thd, sp_name *trig, bool if_exists,
+                      TABLE_LIST **table);
diff --git a/sql/sql_union.cc b/sql/sql_union.cc
index 8b7dde2f818..16df0059217 100644
--- a/sql/sql_union.cc
+++ b/sql/sql_union.cc
@@ -111,7 +111,7 @@ bool select_union::flush()
 */
 
 bool
-select_union::create_result_table(THD *thd, List<Item> *column_types,
+select_union::create_result_table(THD *thd_arg, List<Item> *column_types,
                                   bool is_union_distinct, ulonglong options,
                                   const char *alias)
 {
@@ -119,7 +119,7 @@ select_union::create_result_table(THD *thd, List<Item> *column_types,
   tmp_table_param.init();
   tmp_table_param.field_count= column_types->elements;
 
-  if (! (table= create_tmp_table(thd, &tmp_table_param, *column_types,
+  if (! (table= create_tmp_table(thd_arg, &tmp_table_param, *column_types,
                                  (ORDER*) 0, is_union_distinct, 1,
                                  options, HA_POS_ERROR, (char*) alias)))
     return TRUE;
@@ -141,12 +141,14 @@ select_union::create_result_table(THD *thd, List<Item> *column_types,
 */
 
 void
-st_select_lex_unit::init_prepare_fake_select_lex(THD *thd) 
+st_select_lex_unit::init_prepare_fake_select_lex(THD *thd_arg) 
 {
-  thd->lex->current_select= fake_select_lex;
+  thd_arg->lex->current_select= fake_select_lex;
   fake_select_lex->table_list.link_in_list((byte *)&result_table_list,
 					   (byte **)
 					   &result_table_list.next_local);
+  fake_select_lex->context.table_list= fake_select_lex->context.first_name_resolution_table= 
+    fake_select_lex->get_table_list();
   for (ORDER *order= (ORDER *)global_parameters->order_list.first;
        order;
        order=order->next)
@@ -197,7 +199,7 @@ bool st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
     DBUG_RETURN(FALSE);
   }
   prepared= 1;
-  res= FALSE;
+  saved_error= FALSE;
   
   thd_arg->lex->current_select= sl= first_sl;
   found_rows_for_union= first_sl->options & OPTION_FOUND_ROWS;
@@ -238,23 +240,25 @@ bool st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
 
     can_skip_order_by= is_union && !(sl->braces && sl->explicit_limit);
 
-    res= join->prepare(&sl->ref_pointer_array,
-		       (TABLE_LIST*) sl->table_list.first, sl->with_wild,
-		       sl->where,
-                      (can_skip_order_by ? 0 : sl->order_list.elements) +
-                       sl->group_list.elements,
-                       can_skip_order_by ?
-                       (ORDER*) 0 : (ORDER *)sl->order_list.first,
-		       (ORDER*) sl->group_list.first,
-		       sl->having,
-		       (is_union ? (ORDER*) 0 :
-                        (ORDER*) thd_arg->lex->proc_list.first),
-		       sl, this);
+    saved_error= join->prepare(&sl->ref_pointer_array,
+                               (TABLE_LIST*) sl->table_list.first,
+                               sl->with_wild,
+                               sl->where,
+                               (can_skip_order_by ? 0 :
+                                sl->order_list.elements) +
+                               sl->group_list.elements,
+                               can_skip_order_by ?
+                               (ORDER*) 0 : (ORDER *)sl->order_list.first,
+                               (ORDER*) sl->group_list.first,
+                               sl->having,
+                               (is_union ? (ORDER*) 0 :
+                                (ORDER*) thd_arg->lex->proc_list.first),
+                               sl, this);
     /* There are no * in the statement anymore (for PS) */
     sl->with_wild= 0;
     last_procedure= join->procedure;
 
-    if ((res= (res || thd_arg->is_fatal_error)))
+    if (saved_error || (saved_error= thd_arg->is_fatal_error))
       goto err;
     /*
       Use items list of underlaid select for derived tables to preserve
@@ -349,12 +353,12 @@ bool st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
 
       arena= thd->activate_stmt_arena_if_needed(&backup_arena);
       
-      res= table->fill_item_list(&item_list);
+      saved_error= table->fill_item_list(&item_list);
 
       if (arena)
         thd->restore_active_arena(arena, &backup_arena);
 
-      if (res)
+      if (saved_error)
         goto err;
 
       if (thd->stmt_arena->is_stmt_prepare())
@@ -373,7 +377,7 @@ bool st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
 	fake_select_lex->item_list= item_list;
 
 	thd_arg->lex->current_select= fake_select_lex;
-	res= fake_select_lex->join->
+	saved_error= fake_select_lex->join->
 	  prepare(&fake_select_lex->ref_pointer_array,
 		  (TABLE_LIST*) fake_select_lex->table_list.first,
 		  0, 0,
@@ -398,7 +402,7 @@ bool st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
 
   thd_arg->lex->current_select= lex_select_save;
 
-  DBUG_RETURN(res || thd_arg->is_fatal_error);
+  DBUG_RETURN(saved_error || thd_arg->is_fatal_error);
 
 err:
   thd_arg->lex->current_select= lex_select_save;
@@ -440,7 +444,7 @@ bool st_select_lex_unit::exec()
       thd->lex->current_select= sl;
 
       if (optimized)
-	res= sl->join->reinit();
+	saved_error= sl->join->reinit();
       else
       {
         set_limit(sl);
@@ -463,9 +467,9 @@ bool st_select_lex_unit::exec()
         sl->join->select_options= 
           (select_limit_cnt == HA_POS_ERROR || sl->braces) ?
           sl->options & ~OPTION_FOUND_ROWS : sl->options | found_rows_for_union;
-	res= sl->join->optimize();
+	saved_error= sl->join->optimize();
       }
-      if (!res)
+      if (!saved_error)
       {
 	records_at_start= table->file->records;
 	sl->join->exec();
@@ -475,11 +479,11 @@ bool st_select_lex_unit::exec()
 	    DBUG_RETURN(TRUE);
 	  table->no_keyread=1;
 	}
-	res= sl->join->error;
+	saved_error= sl->join->error;
 	offset_limit_cnt= (ha_rows)(sl->offset_limit ?
                                     sl->offset_limit->val_uint() :
                                     0);
-	if (!res)
+	if (!saved_error)
 	{
 	  examined_rows+= thd->examined_row_count;
 	  if (union_result->flush())
@@ -489,10 +493,10 @@ bool st_select_lex_unit::exec()
 	  }
 	}
       }
-      if (res)
+      if (saved_error)
       {
 	thd->lex->current_select= lex_select_save;
-	DBUG_RETURN(res);
+	DBUG_RETURN(saved_error);
       }
       /* Needed for the following test and for records_at_start in next loop */
       int error= table->file->info(HA_STATUS_VARIABLE);
@@ -518,7 +522,7 @@ bool st_select_lex_unit::exec()
   optimized= 1;
 
   /* Send result to 'result' */
-  res= TRUE;
+  saved_error= TRUE;
   {
     List<Item_func_match> empty_list;
     empty_list.empty();
@@ -559,17 +563,17 @@ bool st_select_lex_unit::exec()
 	}
 	join->init(thd, item_list, fake_select_lex->options, result);
       }
-      res= mysql_select(thd, &fake_select_lex->ref_pointer_array,
-			&result_table_list,
-			0, item_list, NULL,
-			global_parameters->order_list.elements,
-			(ORDER*)global_parameters->order_list.first,
-			(ORDER*) NULL, NULL, (ORDER*) NULL,
-			fake_select_lex->options | SELECT_NO_UNLOCK,
-			result, this, fake_select_lex);
+      saved_error= mysql_select(thd, &fake_select_lex->ref_pointer_array,
+                            &result_table_list,
+                            0, item_list, NULL,
+                            global_parameters->order_list.elements,
+                            (ORDER*)global_parameters->order_list.first,
+                            (ORDER*) NULL, NULL, (ORDER*) NULL,
+                            fake_select_lex->options | SELECT_NO_UNLOCK,
+                            result, this, fake_select_lex);
 
       fake_select_lex->table_list.empty();
-      if (!res)
+      if (!saved_error)
       {
 	thd->limit_found_rows = (ulonglong)table->file->records + add_rows;
         thd->examined_row_count+= examined_rows;
@@ -581,7 +585,7 @@ bool st_select_lex_unit::exec()
     }
   }
   thd->lex->current_select= lex_select_save;
-  DBUG_RETURN(res);
+  DBUG_RETURN(saved_error);
 }
 
 
@@ -658,18 +662,18 @@ void st_select_lex_unit::reinit_exec_mechanism()
     TRUE  - error
 */
 
-bool st_select_lex_unit::change_result(select_subselect *result,
+bool st_select_lex_unit::change_result(select_subselect *new_result,
                                        select_subselect *old_result)
 {
   bool res= FALSE;
   for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
   {
     if (sl->join && sl->join->result == old_result)
-      if (sl->join->change_result(result))
+      if (sl->join->change_result(new_result))
 	return TRUE;
   }
   if (fake_select_lex && fake_select_lex->join)
-    res= fake_select_lex->join->change_result(result);
+    res= fake_select_lex->join->change_result(new_result);
   return (res);
 }
 
@@ -749,4 +753,3 @@ void st_select_lex::cleanup_all_joins(bool full)
     for (sl= unit->first_select(); sl; sl= sl->next_select())
       sl->cleanup_all_joins(full);
 }
-
diff --git a/sql/sql_update.cc b/sql/sql_update.cc
index 1db77f8704c..4858184557b 100644
--- a/sql/sql_update.cc
+++ b/sql/sql_update.cc
@@ -64,7 +64,6 @@ static bool check_fields(THD *thd, List<Item> &items)
   List_iterator<Item> it(items);
   Item *item;
   Item_field *field;
-  Name_resolution_context *context= &thd->lex->select_lex.context;
 
   while ((item= it++))
   {
@@ -134,6 +133,7 @@ int mysql_update(THD *thd,
   READ_RECORD	info;
   SELECT_LEX    *select_lex= &thd->lex->select_lex;
   bool need_reopen;
+  List<Item> all_fields;
   DBUG_ENTER("mysql_update");
 
   LINT_INIT(timestamp_query_id);
@@ -226,6 +226,10 @@ int mysql_update(THD *thd,
     DBUG_RETURN(1);				/* purecov: inspected */
   }
 
+  if (select_lex->inner_refs_list.elements &&
+    fix_inner_refs(thd, all_fields, select_lex, select_lex->ref_pointer_array))
+    DBUG_RETURN(-1);
+
   if (conds)
   {
     Item::cond_result cond_value;
diff --git a/sql/sql_view.cc b/sql/sql_view.cc
index fd2d6c89785..7143df8474a 100644
--- a/sql/sql_view.cc
+++ b/sql/sql_view.cc
@@ -861,7 +861,8 @@ bool mysql_make_view(THD *thd, File_parser *parser, TABLE_LIST *table,
   Query_arena *arena, backup;
   TABLE_LIST *top_view= table->top_table();
   int res;
-  bool result;
+  bool result, view_is_mergeable;
+  TABLE_LIST *view_main_select_tables;
   DBUG_ENTER("mysql_make_view");
   DBUG_PRINT("info", ("table: 0x%lx (%s)", (ulong) table, table->table_name));
 
@@ -1088,9 +1089,10 @@ bool mysql_make_view(THD *thd, File_parser *parser, TABLE_LIST *table,
       table->next_global= view_tables;
     }
 
-    bool view_is_mergeable= (table->algorithm != VIEW_ALGORITHM_TMPTABLE &&
-                             lex->can_be_merged());
-    TABLE_LIST *view_main_select_tables;
+    view_is_mergeable= (table->algorithm != VIEW_ALGORITHM_TMPTABLE &&
+                        lex->can_be_merged());
+    LINT_INIT(view_main_select_tables);
+
     if (view_is_mergeable)
     {
       /*
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index b4147d2905c..473a300feeb 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -46,6 +46,7 @@ const LEX_STRING null_lex_str={0,0};
 
 #define yyoverflow(A,B,C,D,E,F) {ulong val= *(F); if (my_yyoverflow((B), (D), &val)) { yyerror((char*) (A)); return 2; } else { *(F)= (YYSIZE_T)val; }}
 
+#undef 	WARN_DEPRECATED			/* this macro is also defined in mysql_priv.h */
 #define WARN_DEPRECATED(A,B)                                        \
   push_warning_printf(((THD *)yythd), MYSQL_ERROR::WARN_LEVEL_WARN, \
 		      ER_WARN_DEPRECATED_SYNTAX,                    \
@@ -992,6 +993,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 	old_or_new_charset_name_or_default
 	collation_name
 	collation_name_or_default
+	opt_load_data_charset
 
 %type <variable> internal_variable_name
 
@@ -3262,6 +3264,10 @@ charset_name_or_default:
 	charset_name { $$=$1;   }
 	| DEFAULT    { $$=NULL; } ;
 
+opt_load_data_charset:
+	/* Empty */ { $$= NULL; }
+	| charset charset_name_or_default { $$= $2; }
+	;
 
 old_or_new_charset_name:
 	ident_or_text
@@ -4188,8 +4194,13 @@ select_into:
 	| select_from into;
 
 select_from:
-	  FROM join_table_list where_clause group_clause having_clause
+        FROM join_table_list where_clause group_clause having_clause
 	       opt_order_clause opt_limit_clause procedure_clause
+          {
+            Select->context.table_list=
+              Select->context.first_name_resolution_table= 
+                (TABLE_LIST *) Select->table_list.first;
+          }
         | FROM DUAL_SYM where_clause opt_limit_clause
           /* oracle compatibility: oracle always requires FROM clause,
              and DUAL is system table without fields.
@@ -4922,9 +4933,9 @@ simple_expr:
           }
           udf_expr_list ')'
           {
+            LEX *lex= Lex;
 #ifdef HAVE_DLOPEN
             udf_func *udf;
-            LEX *lex= Lex;
 
             if (NULL != (udf= lex->current_select->udf_list.pop()))
             {
@@ -5003,7 +5014,6 @@ simple_expr:
             else
 #endif /* HAVE_DLOPEN */
             {
-	      LEX *lex= Lex;
               THD *thd= lex->thd;
               LEX_STRING db;
               if (thd->copy_db_to(&db.str, &db.length))
@@ -5462,7 +5472,6 @@ join_table:
 	| table_ref normal_join table_ref
 	  USING
 	  {
-	    SELECT_LEX *sel= Select;
             YYERROR_UNLESS($1 && $3);
 	  }
 	  '(' using_list ')'
@@ -5493,7 +5502,6 @@ join_table:
           }
 	| table_ref LEFT opt_outer JOIN_SYM table_factor
 	  {
-	    SELECT_LEX *sel= Select;
             YYERROR_UNLESS($1 && $5);
 	  }
 	  USING '(' using_list ')'
@@ -5531,7 +5539,6 @@ join_table:
           }
 	| table_ref RIGHT opt_outer JOIN_SYM table_factor
 	  {
-	    SELECT_LEX *sel= Select;
             YYERROR_UNLESS($1 && $5);
 	  }
 	  USING '(' using_list ')'
@@ -7241,6 +7248,8 @@ load_data:
           lex->update_list.empty();
           lex->value_list.empty();
         }
+        opt_load_data_charset
+	{ Lex->exchange->cs= $12; }
         opt_field_term opt_line_term opt_ignore_lines opt_field_or_var_spec
         opt_load_data_set_spec
         {}
@@ -7926,6 +7935,7 @@ keyword_sp:
 	| COMPACT_SYM		{}
 	| COMPRESSED_SYM	{}
 	| CONCURRENT		{}
+	| CONNECTION_SYM	{}
 	| CONSISTENT_SYM	{}
 	| CUBE_SYM		{}
 	| DATA_SYM		{}
@@ -9218,7 +9228,6 @@ subselect:
         }
         | '(' subselect_start subselect ')'
           {
-            LEX *lex= Lex;
 	    THD *thd= YYTHD;
             /*
               note that a local variable can't be used for
@@ -9270,6 +9279,12 @@ subselect_end:
 	  lex->current_select = lex->current_select->return_after_parsing();
           lex->nest_level--;
           lex->current_select->n_child_sum_items += child->n_sum_items;
+          /*
+            A subselect can add fields to an outer select. Reserve space for
+            them.
+          */
+          lex->current_select->select_n_where_fields+=
+            child->select_n_where_fields;
 	};
 
 /**************************************************************************
diff --git a/sql/table.cc b/sql/table.cc
index e2cb0bea300..970f5b2267c 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -892,17 +892,17 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat,
   if (share->blob_fields)
   {
     Field **ptr;
-    uint i, *save;
+    uint k, *save;
 
     /* Store offsets to blob fields to find them fast */
     if (!(share->blob_field= save=
 	  (uint*) alloc_root(&outparam->mem_root,
                              (uint) (share->blob_fields* sizeof(uint)))))
       goto err;
-    for (i=0, ptr= outparam->field ; *ptr ; ptr++, i++)
+    for (k=0, ptr= outparam->field ; *ptr ; ptr++, k++)
     {
       if ((*ptr)->flags & BLOB_FLAG)
-	(*save++)= i;
+	(*save++)= k;
     }
   }
 
@@ -2161,19 +2161,17 @@ int st_table_list::view_check_option(THD *thd, bool ignore_failure)
 {
   if (check_option && check_option->val_int() == 0)
   {
-    TABLE_LIST *view= top_table();
+    TABLE_LIST *main_view= top_table();
     if (ignore_failure)
     {
       push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
                           ER_VIEW_CHECK_FAILED, ER(ER_VIEW_CHECK_FAILED),
-                          view->view_db.str, view->view_name.str);
+                          main_view->view_db.str, main_view->view_name.str);
       return(VIEW_CHECK_SKIP);
     }
-    else
-    {
-      my_error(ER_VIEW_CHECK_FAILED, MYF(0), view->view_db.str, view->view_name.str);
-      return(VIEW_CHECK_ERROR);
-    }
+    my_error(ER_VIEW_CHECK_FAILED, MYF(0), main_view->view_db.str,
+             main_view->view_name.str);
+    return(VIEW_CHECK_ERROR);
   }
   return(VIEW_CHECK_OK);
 }
@@ -2185,19 +2183,20 @@ int st_table_list::view_check_option(THD *thd, bool ignore_failure)
 
   SYNOPSIS
     st_table_list::check_single_table()
-    table	reference on variable where to store found table
+    table_arg	reference on variable where to store found table
 		(should be 0 on call, to find table, or point to table for
 		unique test)
     map         bit mask of tables
-    view        view for which we are looking table
+    view_arg    view for which we are looking table
 
   RETURN
     FALSE table not found or found only one
     TRUE  found several tables
 */
 
-bool st_table_list::check_single_table(st_table_list **table, table_map map,
-                                       st_table_list *view)
+bool st_table_list::check_single_table(st_table_list **table_arg,
+                                       table_map map,
+                                       st_table_list *view_arg)
 {
   for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
   {
@@ -2205,13 +2204,13 @@ bool st_table_list::check_single_table(st_table_list **table, table_map map,
     {
       if (tbl->table->map & map)
       {
-	if (*table)
+	if (*table_arg)
 	  return TRUE;
-        *table= tbl;
-        tbl->check_option= view->check_option;
+        *table_arg= tbl;
+        tbl->check_option= view_arg->check_option;
       }
     }
-    else if (tbl->check_single_table(table, map, view))
+    else if (tbl->check_single_table(table_arg, map, view_arg))
       return TRUE;
   }
   return FALSE;
@@ -2536,18 +2535,19 @@ bool st_table_list::prepare_security(THD *thd)
   while ((tbl= tb++))
   {
     DBUG_ASSERT(tbl->referencing_view);
-    char *db, *table_name;
+    char *local_db, *local_table_name;
     if (tbl->view)
     {
-      db= tbl->view_db.str;
-      table_name= tbl->view_name.str;
+      local_db= tbl->view_db.str;
+      local_table_name= tbl->view_name.str;
     }
     else
     {
-      db= tbl->db;
-      table_name= tbl->table_name;
+      local_db= tbl->db;
+      local_table_name= tbl->table_name;
     }
-    fill_effective_table_privileges(thd, &tbl->grant, db, table_name);
+    fill_effective_table_privileges(thd, &tbl->grant, local_db,
+                                    local_table_name);
     if (tbl->table)
       tbl->table->grant= grant;
   }
@@ -2907,12 +2907,13 @@ Field_iterator_table_ref::get_or_create_column_ref(TABLE_LIST *parent_table_ref)
   uint field_count;
   TABLE_LIST *add_table_ref= parent_table_ref ?
                              parent_table_ref : table_ref;
-
+  LINT_INIT(field_count);
+  
   if (field_it == &table_field_it)
   {
     /* The field belongs to a stored table. */
-    Field *field= table_field_it.field();
-    nj_col= new Natural_join_column(field, table_ref);
+    Field *tmp_field= table_field_it.field();
+    nj_col= new Natural_join_column(tmp_field, table_ref);
     field_count= table_ref->table->s->fields;
   }
   else if (field_it == &view_field_it)
@@ -3023,16 +3024,16 @@ void st_table_list::reinit_before_use(THD *thd)
   schema_table_state= NOT_PROCESSED;
 
   TABLE_LIST *embedded; /* The table at the current level of nesting. */
-  TABLE_LIST *embedding= this; /* The parent nested table reference. */
+  TABLE_LIST *parent_embedding= this; /* The parent nested table reference. */
   do
   {
-    embedded= embedding;
+    embedded= parent_embedding;
     if (embedded->prep_on_expr)
       embedded->on_expr= embedded->prep_on_expr->copy_andor_structure(thd);
-    embedding= embedded->embedding;
+    parent_embedding= embedded->embedding;
   }
-  while (embedding &&
-         embedding->nested_join->join_list.head() == embedded);
+  while (parent_embedding &&
+         parent_embedding->nested_join->join_list.head() == embedded);
 }
 
 /*
diff --git a/sql/tztime.cc b/sql/tztime.cc
index ac1fa4ddff8..70f7cc5ea86 100644
--- a/sql/tztime.cc
+++ b/sql/tztime.cc
@@ -1772,8 +1772,8 @@ end_with_setting_default_tz:
   /* If we have default time zone try to load it */
   if (default_tzname)
   {
-    String tmp_tzname(default_tzname, &my_charset_latin1);
-    if (!(global_system_variables.time_zone= my_tz_find(&tmp_tzname, tables)))
+    String tmp_tzname2(default_tzname, &my_charset_latin1);
+    if (!(global_system_variables.time_zone= my_tz_find(&tmp_tzname2, tables)))
     {
       sql_print_error("Fatal error: Illegal or unknown default time zone '%s'",
                       default_tzname);
diff --git a/sql/udf_example.def b/sql/udf_example.def
index ee107d58e51..7a87147d7b6 100644
--- a/sql/udf_example.def
+++ b/sql/udf_example.def
@@ -1,5 +1,4 @@
 LIBRARY		udf_example
-DESCRIPTION	'MySQL Sample for UDF'
 VERSION		1.0
 EXPORTS
   lookup
diff --git a/sql/unireg.cc b/sql/unireg.cc
index 31276c58ce8..06b2e0c10a2 100644
--- a/sql/unireg.cc
+++ b/sql/unireg.cc
@@ -82,7 +82,7 @@ bool mysql_create_frm(THD *thd, my_string file_name,
   uchar fileinfo[64],forminfo[288],*keybuff;
   TYPELIB formnames;
   uchar *screen_buff;
-  char buff[2];
+  char buff[128];
   DBUG_ENTER("mysql_create_frm");
 
   formnames.type_names=0;
@@ -149,7 +149,6 @@ bool mysql_create_frm(THD *thd, my_string file_name,
                                               create_info->comment.length, 60);
   if (tmp_len < create_info->comment.length)
   {
-    char buff[128];
     (void) my_snprintf(buff, sizeof(buff), "Too long comment for table '%s'",
                        table);
     if ((thd->variables.sql_mode &
@@ -178,13 +177,13 @@ bool mysql_create_frm(THD *thd, my_string file_name,
     goto err;
 
   int2store(buff, create_info->connect_string.length);
-  if (my_write(file, (const byte*)buff, sizeof(buff), MYF(MY_NABP)) ||
+  if (my_write(file, (const byte*)buff, 2, MYF(MY_NABP)) ||
       my_write(file, (const byte*)create_info->connect_string.str,
                create_info->connect_string.length, MYF(MY_NABP)))
       goto err;
 
   int2store(buff, str_db_type.length);
-  if (my_write(file, (const byte*)buff, sizeof(buff), MYF(MY_NABP)) ||
+  if (my_write(file, (const byte*)buff, 2, MYF(MY_NABP)) ||
       my_write(file, (const byte*)str_db_type.str,
                str_db_type.length, MYF(MY_NABP)))
     goto err;
@@ -474,11 +473,11 @@ static bool pack_header(uchar *forminfo, enum db_type table_type,
   create_field *field;
   while ((field=it++))
   {
-
     uint tmp_len= system_charset_info->cset->charpos(system_charset_info,
                                                      field->comment.str,
                                                      field->comment.str +
-                                                     field->comment.length, 255);
+                                                     field->comment.length,
+                                                     255);
     if (tmp_len < field->comment.length)
     {
       char buff[128];
@@ -547,8 +546,9 @@ static bool pack_header(uchar *forminfo, enum db_type table_type,
         for (uint pos= 0; pos < field->interval->count; pos++)
         {
           char *dst;
-          uint length= field->save_interval->type_lengths[pos], hex_length;
           const char *src= field->save_interval->type_names[pos];
+          uint hex_length;
+          length= field->save_interval->type_lengths[pos];
           hex_length= length * 2;
           field->interval->type_lengths[pos]= hex_length;
           field->interval->type_names[pos]= dst= sql_alloc(hex_length + 1);
@@ -839,7 +839,10 @@ static bool make_empty_rec(THD *thd, File file,enum db_type table_type,
 			       field->field_name,
 			       &table);
     if (!regfield)
+    {
+      error= 1;
       goto err;                                 // End of memory
+    }
 
     if (!(field->flags & NOT_NULL_FLAG))
     {