Merge mysql.com:/home/wax/mysql/mysql-4.1

into mysql.com:/home/wax/mysql/mysql-4.1test2

21 files changed, 329 insertions, 98 deletions

diff --git a/sql/field.cc b/sql/field.cc
index 7357bc06f11..e2f75034e52 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -245,6 +245,7 @@ static Field::field_cast_enum field_cast_date[]=
  Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
 static Field::field_cast_enum field_cast_newdate[]=
 {Field::FIELD_CAST_NEWDATE,
+ Field::FIELD_CAST_DATE,
  Field::FIELD_CAST_DATETIME,
  Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
  Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
@@ -3511,9 +3512,17 @@ void Field_time::sql_type(String &res) const
 
 int Field_year::store(const char *from, uint len,CHARSET_INFO *cs)
 {
-  int not_used;				// We can ignore result from str2int
+  int err;
   char *end;
-  long nr= my_strntol(cs, from, len, 10, &end, &not_used);
+  long nr= my_strntol(cs, from, len, 10, &end, &err);
+
+  if (err)
+  {
+    if (table->in_use->count_cuted_fields)
+      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
+    *ptr= 0;
+    return 0;
+  }
 
   if (nr < 0 || nr >= 100 && nr <= 1900 || nr > 2155)
   {
@@ -6024,6 +6033,40 @@ Field *make_field(char *ptr, uint32 field_length,
 }
 
 
+/*
+  Check if field_type is appropriate field type
+  to create field for tmp table using
+  item->tmp_table_field() method
+
+  SYNOPSIS
+    field_types_to_be_kept()
+    field_type     - field type
+
+  NOTE
+    it is used in function get_holder_example_field()
+    from item.cc
+
+  RETURN
+    1 - can use item->tmp_table_field() method
+    0 - can not use item->tmp_table_field() method
+
+*/
+
+bool field_types_to_be_kept(enum_field_types field_type)
+{
+  switch (field_type)
+  {
+    case FIELD_TYPE_DATE:
+    case FIELD_TYPE_NEWDATE:
+    case FIELD_TYPE_TIME:
+    case FIELD_TYPE_DATETIME:
+      return 1;
+    default:
+      return 0;
+  }
+}
+
+
 /* Create a field suitable for create of table */
 
 create_field::create_field(Field *old_field,Field *orig_field)
diff --git a/sql/field.h b/sql/field.h
index 27a01a69273..fd0f2f9c2f1 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -1265,6 +1265,7 @@ int set_field_to_null(Field *field);
 int set_field_to_null_with_conversions(Field *field, bool no_conversions);
 bool test_if_int(const char *str, int length, const char *int_end,
 		 CHARSET_INFO *cs);
+bool field_types_to_be_kept(enum_field_types field_type);
 
 /*
   The following are for the interface with the .frm file
diff --git a/sql/ha_innodb.cc b/sql/ha_innodb.cc
index 1d75ce99aee..702139624ff 100644
--- a/sql/ha_innodb.cc
+++ b/sql/ha_innodb.cc
@@ -5282,8 +5282,27 @@ ha_innobase::store_lock(
 		are not simple SELECTs; note that select_lock_type in this
 		case may get strengthened in ::external_lock() to LOCK_X. */
 
-		prebuilt->select_lock_type = LOCK_S;
-		prebuilt->stored_select_lock_type = LOCK_S;
+		if (srv_locks_unsafe_for_binlog &&
+		    prebuilt->trx->isolation_level != TRX_ISO_SERIALIZABLE &&
+		    (lock_type == TL_READ || lock_type == TL_READ_NO_INSERT) &&
+		    thd->lex->sql_command != SQLCOM_SELECT &&
+		    thd->lex->sql_command != SQLCOM_UPDATE_MULTI &&
+		    thd->lex->sql_command != SQLCOM_DELETE_MULTI ) {
+
+			/* In case we have innobase_locks_unsafe_for_binlog
+			option set and isolation level of the transaction
+			is not set to serializable and MySQL is doing
+			INSERT INTO...SELECT without FOR UPDATE or IN
+			SHARE MODE we use consistent read for select. 
+			Similarly, in case of DELETE...SELECT and
+			UPDATE...SELECT when these are not multi table.*/
+
+			prebuilt->select_lock_type = LOCK_NONE;
+			prebuilt->stored_select_lock_type = LOCK_NONE;
+		} else {
+			prebuilt->select_lock_type = LOCK_S;
+			prebuilt->stored_select_lock_type = LOCK_S;
+		}
 
 	} else if (lock_type != TL_IGNORE) {
 
diff --git a/sql/ha_myisam.h b/sql/ha_myisam.h
index 972d6b18e19..1e6cf2f4ada 100644
--- a/sql/ha_myisam.h
+++ b/sql/ha_myisam.h
@@ -88,8 +88,12 @@ class ha_myisam: public handler
     ft_handler->please->reinit_search(ft_handler);
     return 0;
   }
-  FT_INFO *ft_init_ext(uint flags, uint inx,const byte *key, uint keylen)
-  { return ft_init_search(flags,file,inx,(byte*) key,keylen, table->record[0]); }
+  FT_INFO *ft_init_ext(uint flags, uint inx,String *key)
+  {
+    return ft_init_search(flags,file,inx,
+                          (byte *)key->ptr(), key->length(), key->charset(),
+                          table->record[0]);
+  }
   int ft_read(byte *buf);
   int rnd_init(bool scan);
   int rnd_next(byte *buf);
diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc
index a959cbaf434..9e34baae198 100644
--- a/sql/ha_ndbcluster.cc
+++ b/sql/ha_ndbcluster.cc
@@ -3503,6 +3503,52 @@ static int create_ndb_column(NDBCOL &col,
   Create a table in NDB Cluster
  */
 
+static void ndb_set_fragmentation(NDBTAB &tab, TABLE *form, uint pk_length)
+{
+  if (form->max_rows == 0) /* default setting, don't set fragmentation */
+    return;
+  /**
+   * get the number of fragments right
+   */
+  uint no_fragments;
+  {
+#if MYSQL_VERSION_ID >= 50000
+    uint acc_row_size= 25 + /*safety margin*/ 2;
+#else
+    uint acc_row_size= pk_length*4;
+    /* add acc overhead */
+    if (pk_length <= 8)  /* main page will set the limit */
+      acc_row_size+= 25 + /*safety margin*/ 2;
+    else                /* overflow page will set the limit */
+      acc_row_size+= 4 + /*safety margin*/ 4;
+#endif
+    ulonglong acc_fragment_size= 512*1024*1024;
+    ulonglong max_rows= form->max_rows;
+#if MYSQL_VERSION_ID >= 50100
+    no_fragments= (max_rows*acc_row_size)/acc_fragment_size+1;
+#else
+    no_fragments= ((max_rows*acc_row_size)/acc_fragment_size+1
+		   +1/*correct rounding*/)/2;
+#endif
+  }
+  {
+    uint no_nodes= g_ndb_cluster_connection->no_db_nodes();
+    NDBTAB::FragmentType ftype;
+    if (no_fragments > 2*no_nodes)
+    {
+      ftype= NDBTAB::FragAllLarge;
+      if (no_fragments > 4*no_nodes)
+	push_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
+		     "Ndb might have problems storing the max amount of rows specified");
+    }
+    else if (no_fragments > no_nodes)
+      ftype= NDBTAB::FragAllMedium;
+    else
+      ftype= NDBTAB::FragAllSmall;
+    tab.setFragmentType(ftype);
+  }
+}
+
 int ha_ndbcluster::create(const char *name, 
 			  TABLE *form, 
 			  HA_CREATE_INFO *info)
@@ -3605,7 +3651,9 @@ int ha_ndbcluster::create(const char *name,
       break;
     }
   }
-  
+
+  ndb_set_fragmentation(tab, form, pk_length);
+
   if ((my_errno= check_ndb_connection()))
     DBUG_RETURN(my_errno);
   
diff --git a/sql/handler.h b/sql/handler.h
index 245defe61e0..0426312f404 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -373,8 +373,7 @@ public:
   int compare_key(key_range *range);
   virtual int ft_init() { return HA_ERR_WRONG_COMMAND; }
   void ft_end() { ft_handler=NULL; }
-  virtual FT_INFO *ft_init_ext(uint flags,uint inx,const byte *key,
-                               uint keylen)
+  virtual FT_INFO *ft_init_ext(uint flags, uint inx,String *key)
     { return NULL; }
   virtual int ft_read(byte *buf) { return HA_ERR_WRONG_COMMAND; }
   virtual int rnd_next(byte *buf)=0;
diff --git a/sql/item.cc b/sql/item.cc
index ab29c147dfb..d61d628e8fa 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -2639,7 +2639,53 @@ void Item_cache_row::bring_value()
 }
 
 
-Item_type_holder::Item_type_holder(THD *thd, Item *item)
+/*
+  Returns field for temporary table dependind on item type
+
+  SYNOPSIS
+    get_holder_example_field()
+    thd            - thread handler
+    item           - pointer to item
+    table          - empty table object
+
+  NOTE
+    It is possible to return field for Item_func 
+    items only if field type of this item is 
+    date or time or datetime type.
+    also see function field_types_to_be_kept() from
+    field.cc
+
+  RETURN
+    # - field
+    0 - no field
+*/
+
+Field *get_holder_example_field(THD *thd, Item *item, TABLE *table)
+{
+  DBUG_ASSERT(table);
+
+  Item_func *tmp_item= 0;
+  if (item->type() == Item::FIELD_ITEM)
+    return (((Item_field*) item)->field);
+  if (item->type() == Item::FUNC_ITEM)
+    tmp_item= (Item_func *) item;
+  else if (item->type() == Item::SUM_FUNC_ITEM)
+  {
+    Item_sum *item_sum= (Item_sum *) item;
+    if (item_sum->keep_field_type())
+    {
+      if (item_sum->args[0]->type() == Item::FIELD_ITEM)
+        return (((Item_field*) item_sum->args[0])->field);
+      if (item_sum->args[0]->type() == Item::FUNC_ITEM)
+        tmp_item= (Item_func *) item_sum->args[0];
+    }
+  }
+  return (tmp_item && field_types_to_be_kept(tmp_item->field_type()) ?
+          tmp_item->tmp_table_field(table) : 0);
+}
+
+
+Item_type_holder::Item_type_holder(THD *thd, Item *item, TABLE *table)
   :Item(thd, item), item_type(item->result_type()),
    orig_type(item_type)
 {
@@ -2649,10 +2695,7 @@ Item_type_holder::Item_type_holder(THD *thd, Item *item)
     It is safe assign pointer on field, because it will be used just after
     all JOIN::prepare calls and before any SELECT execution
   */
-  if (item->type() == Item::FIELD_ITEM)
-    field_example= ((Item_field*) item)->field;
-  else
-    field_example= 0;
+  field_example= get_holder_example_field(thd, item, table);
   max_length= real_length(item);
   maybe_null= item->maybe_null;
   collation.set(item->collation);
@@ -2692,25 +2735,23 @@ inline bool is_attr_compatible(Item *from, Item *to)
           (to->maybe_null || !from->maybe_null) &&
           (to->result_type() != STRING_RESULT ||
            from->result_type() != STRING_RESULT ||
-           my_charset_same(from->collation.collation,
-                           to->collation.collation)));
+          (from->collation.collation == to->collation.collation)));
 }
 
 
-bool Item_type_holder::join_types(THD *thd, Item *item)
+bool Item_type_holder::join_types(THD *thd, Item *item, TABLE *table)
 {
   uint32 new_length= real_length(item);
   bool use_new_field= 0, use_expression_type= 0;
   Item_result new_result_type= type_convertor[item_type][item->result_type()];
-  bool item_is_a_field= item->type() == Item::FIELD_ITEM;
-
+  Field *field= get_holder_example_field(thd, item, table);
+  bool item_is_a_field= field;
   /*
     Check if both items point to fields: in this case we
     can adjust column types of result table in the union smartly.
   */
   if (field_example && item_is_a_field)
   {
-    Field *field= ((Item_field *)item)->field;
     /* Can 'field_example' field store data of the column? */
     if ((use_new_field=
          (!field->field_cast_compatible(field_example->field_cast_type()) ||
@@ -2751,7 +2792,7 @@ bool Item_type_holder::join_types(THD *thd, Item *item)
         It is safe to assign a pointer to field here, because it will be used
         before any table is closed.
       */
-      field_example= ((Item_field*) item)->field;
+      field_example= field;
     }
 
     old_cs= collation.collation->name;
diff --git a/sql/item.h b/sql/item.h
index 237a8f7efac..e0de7452eec 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -1321,14 +1321,14 @@ protected:
   Item_result orig_type;
   Field *field_example;
 public:
-  Item_type_holder(THD*, Item*);
+  Item_type_holder(THD*, Item*, TABLE *);
 
   Item_result result_type () const { return item_type; }
   enum Type type() const { return TYPE_HOLDER; }
   double val();
   longlong val_int();
   String *val_str(String*);
-  bool join_types(THD *thd, Item *);
+  bool join_types(THD *thd, Item *, TABLE *);
   Field *example() { return field_example; }
   static uint32 real_length(Item *item);
   void cleanup()
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index c5e6d520ab7..2b9a612da18 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -1503,7 +1503,11 @@ void in_string::set(uint pos,Item *item)
   String *str=((String*) base)+pos;
   String *res=item->val_str(str);
   if (res && res != str)
+  {
+    if (res->uses_buffer_owned_by(str))
+      res->copy();
     *str= *res;
+  }
   if (!str->charset())
   {
     CHARSET_INFO *cs;
@@ -1960,6 +1964,36 @@ bool Item_cond::walk(Item_processor processor, byte *arg)
   return Item_func::walk(processor, arg);
 }
 
+
+/*
+  Move SUM items out from item tree and replace with reference
+
+  SYNOPSIS
+  split_sum_func()
+  thd			Thread handler
+  ref_pointer_array	Pointer to array of reference fields
+  fields		All fields in select
+
+  NOTES
+   This function is run on all expression (SELECT list, WHERE, HAVING etc)
+   that have or refer (HAVING) to a SUM expression.
+
+   The split is done to get an unique item for each SUM function
+   so that we can easily find and calculate them.
+   (Calculation done by update_sum_func() and copy_sum_funcs() in
+   sql_select.cc)
+
+   All found SUM items are added FIRST in the fields list and
+   we replace the item with a reference.
+
+   We also replace all functions without side effects (like RAND() or UDF's)
+   that uses columns as arguments.
+   For functions with side effects, we just remember any fields referred
+   by the function to ensure that we get a copy of the field value for the
+   first accepted row. This ensures that we can do things like
+   SELECT a*SUM(b) FROM t1 WHERE a=1
+*/
+
 void Item_cond::split_sum_func(THD *thd, Item **ref_pointer_array,
                                List<Item> &fields)
 {
@@ -1969,10 +2003,22 @@ void Item_cond::split_sum_func(THD *thd, Item **ref_pointer_array,
   const_item_cache=0;
   while ((item=li++))
   {
-    if (item->with_sum_func && item->type() != SUM_FUNC_ITEM)
+    /* with_sum_func is set for items that contains a SUM expression */
+    if (item->type() != SUM_FUNC_ITEM &&
+        (item->with_sum_func ||
+         (item->used_tables() & PSEUDO_TABLE_BITS)))
       item->split_sum_func(thd, ref_pointer_array, fields);
-    else if (item->used_tables() || item->type() == SUM_FUNC_ITEM)
+    else if (item->type() == SUM_FUNC_ITEM ||
+             (item->used_tables() && item->type() != REF_ITEM))
     {
+      /*
+        Replace item with a reference so that we can easily calculate
+        it (in case of sum functions) or copy it (in case of fields)
+
+        The test above is to ensure we don't do a reference for things
+        that are constants or are not yet calculated as in:
+        SELECT RAND() as r1, SUM(a) as r2 FROM t1 HAVING r1 > 1 AND r2 > 0
+      */
       Item **ref= li.ref();
       uint el= fields.elements;
       ref_pointer_array[el]= item;
diff --git a/sql/item_func.cc b/sql/item_func.cc
index bff49541252..d5d0ac8cd49 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -351,6 +351,7 @@ bool Item_func::walk (Item_processor processor, byte *argument)
   return (this->*processor)(argument);
 }
 
+
 void Item_func::split_sum_func(THD *thd, Item **ref_pointer_array,
                                List<Item> &fields)
 {
@@ -358,9 +359,12 @@ void Item_func::split_sum_func(THD *thd, Item **ref_pointer_array,
   for (arg= args, arg_end= args+arg_count; arg != arg_end ; arg++)
   {
     Item *item=* arg;
-    if (item->with_sum_func && item->type() != SUM_FUNC_ITEM)
+    if (item->type() != SUM_FUNC_ITEM &&
+        (item->with_sum_func ||
+         (item->used_tables() & PSEUDO_TABLE_BITS)))
       item->split_sum_func(thd, ref_pointer_array, fields);
-    else if (item->used_tables() || item->type() == SUM_FUNC_ITEM)
+    else if (item->type() == SUM_FUNC_ITEM ||
+             (item->used_tables() && item->type() != REF_ITEM))
     {
       uint el= fields.elements;
       ref_pointer_array[el]= item;
@@ -2298,14 +2302,10 @@ longlong Item_func_last_insert_id::val_int()
     longlong value=args[0]->val_int();
     current_thd->insert_id(value);
     null_value=args[0]->null_value;
-    return value;
   }
   else
-  {
-    Item *it= get_system_var(current_thd, OPT_SESSION, "last_insert_id", 14,
-			     "last_insert_id()");
-    return it->val_int();
-  }
+    current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return current_thd->insert_id();
 }
 
 /* This function is just used to test speed of different functions */
@@ -3047,9 +3047,7 @@ void Item_func_match::init_search(bool no_order)
 
   if (join_key && !no_order)
     flags|=FT_SORTED;
-  ft_handler=table->file->ft_init_ext(flags, key,
-				      (byte*) ft_tmp->ptr(),
-				      ft_tmp->length());
+  ft_handler=table->file->ft_init_ext(flags, key, ft_tmp);
 
   if (join_key)
     table->file->ft_handler=ft_handler;
@@ -3091,12 +3089,12 @@ bool Item_func_match::fix_fields(THD *thd, TABLE_LIST *tlist, Item **ref)
   }
   /*
     Check that all columns come from the same table.
-    We've already checked that columns in MATCH are fields so 
+    We've already checked that columns in MATCH are fields so
     PARAM_TABLE_BIT can only appear from AGAINST argument.
   */
   if ((used_tables_cache & ~PARAM_TABLE_BIT) != item->used_tables())
     key=NO_SUCH_KEY;
-  
+
   if (key == NO_SUCH_KEY && !(flags & FT_BOOL))
   {
     my_error(ER_WRONG_ARGUMENTS,MYF(0),"MATCH");
diff --git a/sql/item_row.cc b/sql/item_row.cc
index 4e4957b980e..0ace0fc0451 100644
--- a/sql/item_row.cc
+++ b/sql/item_row.cc
@@ -84,15 +84,20 @@ bool Item_row::fix_fields(THD *thd, TABLE_LIST *tabl, Item **ref)
   return 0;
 }
 
+
 void Item_row::split_sum_func(THD *thd, Item **ref_pointer_array,
                               List<Item> &fields)
 {
   Item **arg, **arg_end;
   for (arg= items, arg_end= items+arg_count; arg != arg_end ; arg++)
   {
-    if ((*arg)->with_sum_func && (*arg)->type() != SUM_FUNC_ITEM)
-      (*arg)->split_sum_func(thd, ref_pointer_array, fields);
-    else if ((*arg)->used_tables() || (*arg)->type() == SUM_FUNC_ITEM)
+    Item *item= *arg;
+    if (item->type() != SUM_FUNC_ITEM &&
+        (item->with_sum_func ||
+         (item->used_tables() & PSEUDO_TABLE_BITS)))
+      item->split_sum_func(thd, ref_pointer_array, fields);
+    else if (item->type() == SUM_FUNC_ITEM ||
+             (item->used_tables() && item->type() != REF_ITEM))
     {
       uint el= fields.elements;
       ref_pointer_array[el]=*arg;
diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
index cee3316886a..b22b65eddd0 100644
--- a/sql/item_strfunc.cc
+++ b/sql/item_strfunc.cc
@@ -1758,9 +1758,12 @@ String *Item_func_elt::val_str(String *str)
 void Item_func_make_set::split_sum_func(THD *thd, Item **ref_pointer_array,
 					List<Item> &fields)
 {
-  if (item->with_sum_func && item->type() != SUM_FUNC_ITEM)
+  if (item->type() != SUM_FUNC_ITEM &&
+      (item->with_sum_func ||
+       (item->used_tables() & PSEUDO_TABLE_BITS)))
     item->split_sum_func(thd, ref_pointer_array, fields);
-  else if (item->used_tables() || item->type() == SUM_FUNC_ITEM)
+  else if (item->type() == SUM_FUNC_ITEM ||
+           (item->used_tables() && item->type() != REF_ITEM))
   {
     uint el= fields.elements;
     ref_pointer_array[el]=item;
@@ -2614,18 +2617,13 @@ String *Item_func_quote::val_str(String *str)
   for (from= (char*) arg->ptr(), end= from + arg_length; from < end; from++)
     new_length+= get_esc_bit(escmask, (uchar) *from);
 
-  /*
-    We have to use realloc() instead of alloc() as we want to keep the
-    old result in arg
-  */
-  if (arg->realloc(new_length))
+  if (tmp_value.alloc(new_length))
     goto null;
 
   /*
-    As 'arg' and 'str' may be the same string, we must replace characters
-    from the end to the beginning
+    We replace characters from the end to the beginning
   */
-  to= (char*) arg->ptr() + new_length - 1;
+  to= (char*) tmp_value.ptr() + new_length - 1;
   *to--= '\'';
   for (start= (char*) arg->ptr(),end= start + arg_length; end-- != start; to--)
   {
@@ -2653,10 +2651,10 @@ String *Item_func_quote::val_str(String *str)
     }
   }
   *to= '\'';
-  arg->length(new_length);
-  str->set_charset(collation.collation);
+  tmp_value.length(new_length);
+  tmp_value.set_charset(collation.collation);
   null_value= 0;
-  return arg;
+  return &tmp_value;
 
 null:
   null_value= 1;
diff --git a/sql/item_strfunc.h b/sql/item_strfunc.h
index 698536a61c7..c1c0969672c 100644
--- a/sql/item_strfunc.h
+++ b/sql/item_strfunc.h
@@ -588,6 +588,7 @@ public:
 
 class Item_func_quote :public Item_str_func
 {
+  String tmp_value;
 public:
   Item_func_quote(Item *a) :Item_str_func(a) {}
   const char *func_name() const { return "quote"; }
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 7434897ab90..fe1f268e277 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -485,62 +485,58 @@ void close_temporary(TABLE *table,bool delete_table)
 void close_temporary_tables(THD *thd)
 {
   TABLE *table,*next;
-  char *query, *end;
-  uint query_buf_size; 
-  bool found_user_tables = 0;
+  char *query, *name_in_query, *end;
+  uint greatest_key_length= 0;
 
   if (!thd->temporary_tables)
     return;
   
+  /*
+    We write a DROP TEMPORARY TABLE for each temp table left, so that our
+    replication slave can clean them up. Not one multi-table DROP TABLE binlog
+    event: this would cause problems if slave uses --replicate-*-table.
+  */
   LINT_INIT(end);
-  query_buf_size= 50;   // Enough for DROP ... TABLE IF EXISTS
 
+  /* We'll re-use always same buffer so make it big enough for longest name */
   for (table=thd->temporary_tables ; table ; table=table->next)
-    /*
-      We are going to add 4 ` around the db/table names, so 1 does not look
-      enough; indeed it is enough, because table->key_length is greater (by 8,
-      because of server_id and thread_id) than db||table.
-    */
-    query_buf_size+= table->key_length+1;
+    greatest_key_length= max(greatest_key_length, table->key_length);
 
-  if ((query = alloc_root(thd->mem_root, query_buf_size)))
+  if ((query = alloc_root(thd->mem_root, greatest_key_length+50)))
     // Better add "if exists", in case a RESET MASTER has been done
-    end=strmov(query, "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS ");
+    name_in_query= strmov(query, "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS `");
 
   for (table=thd->temporary_tables ; table ; table=next)
   {
-    if (query) // we might be out of memory, but this is not fatal
+    /*
+      In we are OOM for 'query' this is not fatal. We skip temporary tables
+      not created directly by the user.
+    */
+    if (query && mysql_bin_log.is_open() && (table->real_name[0] != '#'))
     {
-      // skip temporary tables not created directly by the user
-      if (table->real_name[0] != '#')
-	found_user_tables = 1;
       /*
         Here we assume table_cache_key always starts
         with \0 terminated db name
       */
-      end = strxmov(end,"`",table->table_cache_key,"`.`",
-                    table->real_name,"`,", NullS);
+      end = strxmov(name_in_query, table->table_cache_key, "`.`",
+                    table->real_name, "`", NullS);
+      Query_log_event qinfo(thd, query, (ulong)(end-query), 0, FALSE);
+      /*
+        Imagine the thread had created a temp table, then was doing a SELECT, and
+        the SELECT was killed. Then it's not clever to mark the statement above as
+        "killed", because it's not really a statement updating data, and there
+        are 99.99% chances it will succeed on slave. And, if thread is
+        killed now, it's not clever either.
+        If a real update (one updating a persistent table) was killed on the
+        master, then this real update will be logged with error_code=killed,
+        rightfully causing the slave to stop.
+      */
+      qinfo.error_code= 0;
+      mysql_bin_log.write(&qinfo);
     }
     next=table->next;
     close_temporary(table);
   }
-  if (query && found_user_tables && mysql_bin_log.is_open())
-  {
-    /* The -1 is to remove last ',' */
-    thd->clear_error();
-    Query_log_event qinfo(thd, query, (ulong)(end-query)-1, 0, FALSE);
-    /*
-      Imagine the thread had created a temp table, then was doing a SELECT, and
-      the SELECT was killed. Then it's not clever to mark the statement above as
-      "killed", because it's not really a statement updating data, and there
-      are 99.99% chances it will succeed on slave.
-      If a real update (one updating a persistent table) was killed on the
-      master, then this real update will be logged with error_code=killed,
-      rightfully causing the slave to stop.
-    */
-    qinfo.error_code= 0;
-    mysql_bin_log.write(&qinfo);
-  }
   thd->temporary_tables=0;
 }
 
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 85cd24c4fbb..e66eeb279d2 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -660,6 +660,8 @@ static int check_connection(THD *thd)
   DBUG_PRINT("info",
              ("New connection received on %s", vio_description(net->vio)));
 
+  vio_in_addr(net->vio,&thd->remote.sin_addr);
+
   if (!thd->host)                           // If TCP/IP connection
   {
     char ip[30];
@@ -704,7 +706,6 @@ static int check_connection(THD *thd)
     DBUG_PRINT("info",("Host: %s",thd->host));
     thd->host_or_ip= thd->host;
     thd->ip= 0;
-    bzero((char*) &thd->remote, sizeof(struct sockaddr));
   }
   vio_keepalive(net->vio, TRUE);
   ulong pkt_len= 0;
diff --git a/sql/sql_string.h b/sql/sql_string.h
index a8fb9574c0b..9136dddbbf2 100644
--- a/sql/sql_string.h
+++ b/sql/sql_string.h
@@ -182,6 +182,11 @@ public:
   {
     if (&s != this)
     {
+      /*
+        It is forbidden to do assignments like 
+        some_string = substring_of_that_string
+       */
+      DBUG_ASSERT(!s.uses_buffer_owned_by(this));
       free();
       Ptr=s.Ptr ; str_length=s.str_length ; Alloced_length=s.Alloced_length;
       alloced=0;
@@ -313,4 +318,9 @@ public:
 
   /* Swap two string objects. Efficient way to exchange data without memcpy. */
   void swap(String &s);
+
+  inline bool uses_buffer_owned_by(const String *s) const
+  {
+    return (s->alloced && Ptr >= s->Ptr && Ptr < s->Ptr + s->str_length);
+  }
 };
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index f3c107c2696..5f3875ba934 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -2272,7 +2272,10 @@ int mysql_create_like_table(THD* thd, TABLE_LIST* table,
     strxmov(src_path, (*tmp_table)->path, reg_ext, NullS);
   else
   {
-    fn_format( src_path, src_table, src_db, reg_ext, MYF(MY_UNPACK_FILENAME));
+    strxmov(src_path, mysql_data_home, "/", src_db, "/", src_table,
+	    reg_ext, NullS);
+    /* Resolve symlinks (for windows) */
+    fn_format(src_path, src_path, "", "", MYF(MY_UNPACK_FILENAME));
     if (access(src_path, F_OK))
     {
       my_error(ER_BAD_TABLE_ERROR, MYF(0), src_table);
@@ -2299,7 +2302,9 @@ int mysql_create_like_table(THD* thd, TABLE_LIST* table,
   }
   else
   {
-    fn_format( dst_path, table_name, db, reg_ext, MYF(MY_UNPACK_FILENAME));
+    strxmov(dst_path, mysql_data_home, "/", db, "/", table_name,
+	    reg_ext, NullS);
+    fn_format(dst_path, dst_path, "", "", MYF(MY_UNPACK_FILENAME));
     if (!access(dst_path, F_OK))
       goto table_exists;
   }
diff --git a/sql/sql_union.cc b/sql/sql_union.cc
index 027a21db7ac..882316d57d7 100644
--- a/sql/sql_union.cc
+++ b/sql/sql_union.cc
@@ -148,6 +148,7 @@ int st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
   SELECT_LEX *sl, *first_select;
   select_result *tmp_result;
   bool is_union;
+  TABLE *empty_table= 0;
   DBUG_ENTER("st_select_lex_unit::prepare");
 
   describe= test(additional_options & SELECT_DESCRIBE);
@@ -239,13 +240,21 @@ int st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
       goto err;
     if (sl == first_select)
     {
+      /*
+        We need to create an empty table object. It is used
+        to create tmp_table fields in Item_type_holder.
+        The main reason of this is that we can't create
+        field object without table.
+      */
+      DBUG_ASSERT(!empty_table);
+      empty_table= (TABLE*) thd->calloc(sizeof(TABLE));
       types.empty();
       List_iterator_fast<Item> it(sl->item_list);
       Item *item_tmp;
       while ((item_tmp= it++))
       {
 	/* Error's in 'new' will be detected after loop */
-	types.push_back(new Item_type_holder(thd_arg, item_tmp));
+	types.push_back(new Item_type_holder(thd_arg, item_tmp, empty_table));
       }
 
       if (thd_arg->is_fatal_error)
@@ -264,7 +273,8 @@ int st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
       Item *type, *item_tmp;
       while ((type= tp++, item_tmp= it++))
       {
-	if (((Item_type_holder*)type)->join_types(thd_arg, item_tmp))
+        if (((Item_type_holder*)type)->join_types(thd_arg, item_tmp,
+                                                  empty_table))
 	  DBUG_RETURN(-1);
       }
     }
diff --git a/sql/sql_update.cc b/sql/sql_update.cc
index 0ec71bdfba3..663f2d2be34 100644
--- a/sql/sql_update.cc
+++ b/sql/sql_update.cc
@@ -167,7 +167,10 @@ int mysql_update(THD *thd,
   else if ((used_index=table->file->key_used_on_scan) < MAX_KEY)
     used_key_is_modified=check_if_key_used(table, used_index, fields);
   else
+  {
     used_key_is_modified=0;
+    used_index= MAX_KEY;
+  }
   if (used_key_is_modified || order)
   {
     /*
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 1e51d8fb82d..e70efe14557 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -2455,10 +2455,11 @@ select_into:
 select_from:
 	  FROM join_table_list where_clause group_clause having_clause
 	       opt_order_clause opt_limit_clause procedure_clause
-        | FROM DUAL_SYM /* oracle compatibility: oracle always requires FROM
-                           clause, and DUAL is system table without fields.
-                           Is "SELECT 1 FROM DUAL" any better than
-                           "SELECT 1" ? Hmmm :) */
+        | FROM DUAL_SYM opt_limit_clause
+          /* oracle compatibility: oracle always requires FROM clause,
+             and DUAL is system table without fields.
+             Is "SELECT 1 FROM DUAL" any better than "SELECT 1" ?
+          Hmmm :) */
 	;
 
 select_options:
diff --git a/sql/unireg.h b/sql/unireg.h
index 4ab2ba26b15..70df9a89c8f 100644
--- a/sql/unireg.h
+++ b/sql/unireg.h
@@ -72,6 +72,8 @@
 #define PARAM_TABLE_BIT	(((table_map) 1) << (sizeof(table_map)*8-3))
 #define OUTER_REF_TABLE_BIT	(((table_map) 1) << (sizeof(table_map)*8-2))
 #define RAND_TABLE_BIT	(((table_map) 1) << (sizeof(table_map)*8-1))
+#define PSEUDO_TABLE_BITS (PARAM_TABLE_BIT | OUTER_REF_TABLE_BIT | \
+                           RAND_TABLE_BIT)
 #define MAX_FIELDS	4096			/* Limit in the .frm file */
 
 #define MAX_SORT_MEMORY (2048*1024-MALLOC_OVERHEAD)