Don't do signal() on windows (Causes instability problems)

Safer, a bit faster filesort.
Code changes to avoid calls to current_thd() (faster code).
Removed all compiler warnings from readline.


BitKeeper/etc/ignore:
  Add my_global.h back.
Docs/manual.texi:
  4.0.1 Changelog
include/my_sys.h:
  Added strmake_root
libmysql/libmysql.c:
  Don't do signal() on windows (Causes instability problems)
mysys/my_alloc.c:
  Added strmake_root
readline/bind.c:
  Remove warnings
readline/complete.c:
  Remove warnings
readline/display.c:
  Remove warnings
readline/funmap.c:
  Remove warnings
readline/histexpand.c:
  Remove warnings
readline/histfile.c:
  Remove warnings
readline/history.h:
  Remove warnings
readline/histsearch.c:
  Remove warnings
readline/isearch.c:
  Remove warnings
readline/kill.c:
  Remove warnings
readline/macro.c:
  Remove warnings
readline/readline.c:
  Remove warnings
readline/readline.h:
  Remove warnings
readline/rltty.c:
  Remove warnings
readline/search.c:
  Remove warnings
readline/shell.c:
  Remove warnings
readline/terminal.c:
  Remove warnings
readline/tilde.c:
  Remove warnings
readline/tilde.h:
  Remove warnings
readline/undo.c:
  Remove warnings
readline/util.c:
  Remove warnings
readline/vi_mode.c:
  Remove warnings
sql-bench/server-cfg.sh:
  Added use of truncate table
sql-bench/test-insert.sh:
  Added use of truncate table
  Changed some tests to use keys instead of 'range'
sql-bench/test-wisconsin.sh:
  Cleanup
sql/field.cc:
  Add 'thd' to send() (To avoid usage of 'current_thd')
sql/field.h:
  Add 'thd' to send() (To avoid usage of 'current_thd')
sql/filesort.cc:
  Safer memory allocation;  Don't allocate pointer to buffers directly, but use an IO_CACHE instead.
  This will allow us to use more memory for keys and will also work better if the number of rows that is to be sorted is much larger than expected.
sql/item.cc:
  Add 'thd' to send() (To avoid usage of 'current_thd')
sql/item.h:
  Add 'thd' to send() (To avoid usage of 'current_thd')
sql/item_func.h:
  Cleanup
sql/opt_range.cc:
  Use mem_root instead of sql_alloc() to get more speed
sql/sql_class.cc:
  Add 'thd' to send() (To avoid usage of 'current_thd')
sql/sql_class.h:
  Added strmake()
sql/sql_handler.cc:
  Add 'thd' to send() (To avoid usage of 'current_thd')
sql/sql_lex.cc:
  Use mem_root instead of sql_alloc() to get more speed
sql/sql_select.cc:
  Add 'thd' to send() (To avoid usage of 'current_thd')
tests/fork2_test.pl:
  Fixed typos
tests/fork_big.pl:
  Fixed typos
tests/insert_and_repair.pl:
  Fixed typos
tests/rename_test.pl:
  Fixed typos
tests/test_delayed_insert.pl:
  Fixed typos

12 files changed, 121 insertions, 91 deletions

diff --git a/sql/field.cc b/sql/field.cc
index 85a5076e09a..07f521abf3e 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -248,7 +248,7 @@ void Field::copy_from_tmp(int row_offset)
 }
 
 
-bool Field::send(String *packet)
+bool Field::send(THD *thd, String *packet)
 {
   if (is_null())
     return net_store_null(packet);
@@ -256,7 +256,7 @@ bool Field::send(String *packet)
   String tmp(buff,sizeof(buff));
   val_str(&tmp,&tmp);
   CONVERT *convert;
-  if ((convert=current_thd->convert_set))
+  if ((convert=thd->convert_set))
     return convert->store(packet,tmp.ptr(),tmp.length());
   return net_store_data(packet,tmp.ptr(),tmp.length());
 }
diff --git a/sql/field.h b/sql/field.h
index 47bf5cc02ef..ddcc281d0c8 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -154,7 +154,7 @@ public:
       ptr-=row_offset;
       return tmp;
     }
-  bool send(String *packet);
+  bool send(THD *thd, String *packet);
   virtual char *pack(char* to, const char *from, uint max_length=~(uint) 0)
   {
     uint length=pack_length();
diff --git a/sql/filesort.cc b/sql/filesort.cc
index 92886242a4a..fe0ab603214 100644
--- a/sql/filesort.cc
+++ b/sql/filesort.cc
@@ -37,15 +37,13 @@ if (my_b_write((file),(byte*) (from),param->ref_length)) \
 	/* functions defined in this file */
 
 static char **make_char_array(register uint fields, uint length, myf my_flag);
+static BUFFPEK *read_buffpek_from_file(IO_CACHE *buffer_file, uint count);
 static ha_rows find_all_keys(SORTPARAM *param,SQL_SELECT *select,
-			     uchar * *sort_keys,
-			     BUFFPEK *buffpek,uint *maxbuffer,
+			     uchar * *sort_keys, IO_CACHE *buffer_file,
 			     IO_CACHE *tempfile,IO_CACHE *indexfile);
 static int write_keys(SORTPARAM *param,uchar * *sort_keys,
-		      uint count,BUFFPEK *buffpek,
-		      IO_CACHE *tempfile);
-static void make_sortkey(SORTPARAM *param,uchar *to,
-			 byte *ref_pos);
+		      uint count, IO_CACHE *buffer_file, IO_CACHE *tempfile);
+static void make_sortkey(SORTPARAM *param,uchar *to, byte *ref_pos);
 static int merge_index(SORTPARAM *param,uchar *sort_buffer,
 		       BUFFPEK *buffpek,
 		       uint maxbuffer,IO_CACHE *tempfile,
@@ -70,11 +68,12 @@ ha_rows filesort(TABLE *table, SORT_FIELD *sortorder, uint s_length,
 		 ha_rows *examined_rows)
 {
   int error;
-  uint memavl,old_memavl,maxbuffer,skr;
+  ulong memavl;
+  uint maxbuffer,skr;
   BUFFPEK *buffpek;
   ha_rows records;
   uchar **sort_keys;
-  IO_CACHE tempfile,*selected_records_file,*outfile;
+  IO_CACHE tempfile, buffpek_pointers, *selected_records_file, *outfile; 
   SORTPARAM param;
   DBUG_ENTER("filesort");
   DBUG_EXECUTE("info",TEST_filesort(sortorder,s_length,special););
@@ -84,8 +83,10 @@ ha_rows filesort(TABLE *table, SORT_FIELD *sortorder, uint s_length,
 
   outfile= table->io_cache;
   my_b_clear(&tempfile);
-  buffpek= (BUFFPEK *) NULL; sort_keys= (uchar **) NULL; error= 1;
-  maxbuffer=1;
+  my_b_clear(&buffpek_pointers);
+  buffpek=0;
+  sort_keys= (uchar **) NULL;
+  error= 1;
   bzero((char*) &param,sizeof(param));
   param.ref_length= table->file->ref_length;
   param.sort_length=sortlength(sortorder,s_length)+ param.ref_length;
@@ -136,51 +137,34 @@ ha_rows filesort(TABLE *table, SORT_FIELD *sortorder, uint s_length,
   memavl=sortbuff_size;
   while (memavl >= MIN_SORT_MEMORY)
   {
-    if ((ulonglong) (records+1)*(param.sort_length+sizeof(char*))+sizeof(BUFFPEK)*10 <
-	(ulonglong) memavl)
-      param.keys=(uint) records+1;
-    else
-    {
-      maxbuffer=1;
-      do
-      {
-	skr=maxbuffer;
-	if (memavl < sizeof(BUFFPEK)*maxbuffer)
-	{
-	  my_error(ER_OUT_OF_SORTMEMORY,MYF(ME_ERROR+ME_WAITTANG));
-	  goto err;
-	}
-	param.keys=(memavl-sizeof(BUFFPEK)*maxbuffer)/
-	  (param.sort_length+sizeof(char*));
-      }
-      while ((maxbuffer= (uint) (records/param.keys+1)) != skr);
-    }
-    if ((sort_keys= (uchar **) make_char_array(param.keys,param.sort_length,
+    ulong old_memavl;
+    ulong keys= memavl/(param.sort_length+sizeof(char*));
+    param.keys=(uint) min(records+1, keys);
+    if ((sort_keys= (uchar **) make_char_array(param.keys, param.sort_length,
 					       MYF(0))))
-      if ((buffpek = (BUFFPEK*) my_malloc((uint) sizeof(BUFFPEK)*
-					  (maxbuffer+10),
-					  MYF(0))))
-	break;
-      else
-	my_free((gptr) sort_keys,MYF(0));
+      break;
     old_memavl=memavl;
     if ((memavl=memavl/4*3) < MIN_SORT_MEMORY && old_memavl > MIN_SORT_MEMORY)
       memavl=MIN_SORT_MEMORY;
   }
-  param.keys--;
-  maxbuffer+=10;			/* Some extra range */
-
   if (memavl < MIN_SORT_MEMORY)
   {
     my_error(ER_OUTOFMEMORY,MYF(ME_ERROR+ME_WAITTANG),sortbuff_size);
     goto err;
   }
+  if (open_cached_file(&buffpek_pointers,mysql_tmpdir,TEMP_PREFIX,
+		       DISK_BUFFER_SIZE, MYF(MY_WME)))
+    goto err;
+
+  param.keys--;
   param.sort_form= table;
   param.end=(param.local_sortorder=sortorder)+s_length;
-  if ((records=find_all_keys(&param,select,sort_keys,buffpek,&maxbuffer,
+  if ((records=find_all_keys(&param,select,sort_keys, &buffpek_pointers,
 			     &tempfile, selected_records_file)) ==
       HA_POS_ERROR)
     goto err;
+  maxbuffer= my_b_tell(&buffpek_pointers)/sizeof(*buffpek);
+
   if (maxbuffer == 0)			// The whole set is in memory
   {
     if (save_index(&param,sort_keys,(uint) records))
@@ -188,6 +172,9 @@ ha_rows filesort(TABLE *table, SORT_FIELD *sortorder, uint s_length,
   }
   else
   {
+    if (!(buffpek=read_buffpek_from_file(&buffpek_pointers, maxbuffer)))
+      goto err;
+    close_cached_file(&buffpek_pointers);
 	/* Open cached file if it isn't open */
     if (! my_b_inited(outfile) &&
 	open_cached_file(outfile,mysql_tmpdir,TEMP_PREFIX,READ_RECORD_BUFFER,
@@ -195,8 +182,13 @@ ha_rows filesort(TABLE *table, SORT_FIELD *sortorder, uint s_length,
       goto err;
     reinit_io_cache(outfile,WRITE_CACHE,0L,0,0);
 
+    /*
+      Use also the space previously used by string pointers in sort_buffer
+      for temporary key storage.
+    */
     param.keys=((param.keys*(param.sort_length+sizeof(char*))) /
 		param.sort_length-1);
+    maxbuffer--;				// Offset from 0
     if (merge_many_buff(&param,(uchar*) sort_keys,buffpek,&maxbuffer,
 			&tempfile))
       goto err;
@@ -219,6 +211,7 @@ ha_rows filesort(TABLE *table, SORT_FIELD *sortorder, uint s_length,
   x_free((gptr) sort_keys);
   x_free((gptr) buffpek);
   close_cached_file(&tempfile);
+  close_cached_file(&buffpek_pointers);
   if (my_b_inited(outfile))
   {
     if (flush_io_cache(outfile))
@@ -263,11 +256,33 @@ static char **make_char_array(register uint fields, uint length, myf my_flag)
 } /* make_char_array */
 
 
+	/* Read all buffer pointers into memory */
+
+static BUFFPEK *read_buffpek_from_file(IO_CACHE *buffpek_pointers, uint count)
+{
+  ulong length;
+  BUFFPEK *tmp;
+  DBUG_ENTER("read_buffpek_from_file");
+  tmp=(BUFFPEK*) my_malloc(length=sizeof(BUFFPEK)*count, MYF(MY_WME));
+  if (tmp)
+  {
+    if (reinit_io_cache(buffpek_pointers,READ_CACHE,0L,0,0) ||
+	my_b_read(buffpek_pointers, (char*) tmp, length))
+    {
+      my_free((char*) tmp, MYF(0));
+      tmp=0;
+    }      
+  }
+  DBUG_RETURN(tmp);
+}  
+
+
+
 	/* Search after sort_keys and place them in a temp. file */
 
 static ha_rows find_all_keys(SORTPARAM *param, SQL_SELECT *select,
 			     uchar **sort_keys,
-			     BUFFPEK *buffpek, uint *maxbuffer,
+			     IO_CACHE *buffpek_pointers,
 			     IO_CACHE *tempfile, IO_CACHE *indexfile)
 {
   int error,flag,quick_select;
@@ -349,9 +364,8 @@ static ha_rows find_all_keys(SORTPARAM *param, SQL_SELECT *select,
     {
       if (idx == param->keys)
       {
-	if (indexpos >= *maxbuffer ||
-	    write_keys(param,sort_keys,idx,buffpek+indexpos,tempfile))
-	      DBUG_RETURN(HA_POS_ERROR);
+	if (write_keys(param,sort_keys,idx,buffpek_pointers,tempfile))
+	  DBUG_RETURN(HA_POS_ERROR);
 	idx=0; indexpos++;
 	if (param->ref_length == param->sort_length &&
 	    my_b_tell(tempfile)/param->sort_length >= param->max_rows)
@@ -373,11 +387,9 @@ static ha_rows find_all_keys(SORTPARAM *param, SQL_SELECT *select,
     file->print_error(error,MYF(ME_ERROR | ME_WAITTANG)); /* purecov: inspected */
     DBUG_RETURN(HA_POS_ERROR);			/* purecov: inspected */
   }
-  if (indexpos)
-    if (indexpos >= *maxbuffer ||
-	write_keys(param,sort_keys,idx,buffpek+indexpos,tempfile))
-      DBUG_RETURN(HA_POS_ERROR);		/* purecov: inspected */
-  *maxbuffer=indexpos;
+  if (indexpos &&
+      write_keys(param,sort_keys,idx,buffpek_pointers,tempfile))
+    DBUG_RETURN(HA_POS_ERROR);			/* purecov: inspected */
   DBUG_RETURN(my_b_inited(tempfile) ?
 	      (ha_rows) (my_b_tell(tempfile)/param->sort_length) :
 	      idx);
@@ -387,9 +399,10 @@ static ha_rows find_all_keys(SORTPARAM *param, SQL_SELECT *select,
 	/* Skriver en buffert med nycklar till filen */
 
 static int write_keys(SORTPARAM *param, register uchar **sort_keys, uint count,
-		      BUFFPEK *buffpek, IO_CACHE *tempfile)
+		      IO_CACHE *buffpek_pointers, IO_CACHE *tempfile)
 {
   uint sort_length;
+  BUFFPEK buffpek;
   DBUG_ENTER("write_keys");
 
   sort_length=param->sort_length;
@@ -401,15 +414,20 @@ static int write_keys(SORTPARAM *param, register uchar **sort_keys, uint count,
   if (!my_b_inited(tempfile) &&
       open_cached_file(tempfile,mysql_tmpdir,TEMP_PREFIX,DISK_BUFFER_SIZE,
 			MYF(MY_WME)))
-    DBUG_RETURN(1);				/* purecov: inspected */
-  buffpek->file_pos=my_b_tell(tempfile);
+    goto err;					/* purecov: inspected */
+  buffpek.file_pos=my_b_tell(tempfile);
   if ((ha_rows) count > param->max_rows)
     count=(uint) param->max_rows;		/* purecov: inspected */
-  buffpek->count=(ha_rows) count;
+  buffpek.count=(ha_rows) count;
   for (uchar **end=sort_keys+count ; sort_keys != end ; sort_keys++)
     if (my_b_write(tempfile,(byte*) *sort_keys,(uint) sort_length))
-      DBUG_RETURN(1);
+      goto err;
+  if (my_b_write(buffpek_pointers, (char*) &buffpek, sizeof(buffpek)))
+    goto err;
   DBUG_RETURN(0);
+
+err:
+  DBUG_RETURN(1);
 } /* write_keys */
 
 
diff --git a/sql/item.cc b/sql/item.cc
index 5eae3a9b542..1f8d653e612 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -569,19 +569,19 @@ void Item_varbinary::make_field(Send_field *tmp_field)
 ** pack data in buffer for sending
 */
 
-bool Item::send(String *packet)
+bool Item::send(THD *thd, String *packet)
 {
   char buff[MAX_FIELD_WIDTH];
+  CONVERT *convert;
   String s(buff,sizeof(buff)),*res;
   if (!(res=val_str(&s)))
     return net_store_null(packet);
-  CONVERT *convert;
-  if ((convert=current_thd->convert_set))
+  if ((convert=thd->convert_set))
     return convert->store(packet,res->ptr(),res->length());
   return net_store_data(packet,res->ptr(),res->length());
 }
 
-bool Item_null::send(String *packet)
+bool Item_null::send(THD *thd, String *packet)
 {
   return net_store_null(packet);
 }
diff --git a/sql/item.h b/sql/item.h
index 27611a3cce5..df2b1aa243d 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -56,7 +56,7 @@ public:
   virtual bool save_in_field(Field *field);
   virtual void save_org_in_field(Field *field)
     { (void) save_in_field(field); }
-  virtual bool send(String *str);
+  virtual bool send(THD *thd, String *str);
   virtual bool eq(const Item *) const;
   virtual Item_result result_type () const { return REAL_RESULT; }
   virtual enum Type type() const =0;
@@ -118,7 +118,7 @@ public:
   double val_result();
   longlong val_int_result();
   String *str_result(String* tmp);
-  bool send(String *str_arg) { return result_field->send(str_arg); }
+  bool send(THD *thd, String *str_arg) { return result_field->send(thd,str_arg); }
   void make_field(Send_field *field);
   bool fix_fields(THD *,struct st_table_list *);
   bool save_in_field(Field *field);
@@ -149,7 +149,7 @@ public:
   bool save_in_field(Field *field);
   enum Item_result result_type () const
   { return STRING_RESULT; }
-  bool send(String *str);
+  bool send(THD *thd, String *str);
   bool basic_const_item() const { return 1; }
   Item *new_item() { return new Item_null(name); }
   bool is_null() { return 1; }
@@ -346,7 +346,7 @@ public:
   {  
     return (null_value=(*ref)->get_date(ltime,fuzzydate));
   }
-  bool send(String *tmp)		{ return (*ref)->send(tmp); }
+  bool send(THD *thd, String *tmp)	{ return (*ref)->send(thd, tmp); }
   void make_field(Send_field *field)	{ (*ref)->make_field(field); }
   bool fix_fields(THD *,struct st_table_list *);
   bool save_in_field(Field *field)	{ return (*ref)->save_in_field(field); }
diff --git a/sql/item_func.h b/sql/item_func.h
index ccc71d7f5fe..b02d6ccaa8c 100644
--- a/sql/item_func.h
+++ b/sql/item_func.h
@@ -898,7 +898,10 @@ public:
   const char *func_name() const { return "match_nl"; }
   double val();
   int ft_handler_init(const byte *query, uint querylen, bool presort)
-   { ft_handler=table->file->ft_init_ext(FT_NL,key, query, querylen, presort); }
+   {
+     ft_handler=table->file->ft_init_ext(FT_NL,key, query, querylen, presort);
+     return 0;
+   }
 };
 
 class Item_func_match_bool :public Item_func_match
@@ -908,6 +911,9 @@ public:
   const char *func_name() const { return "match_bool"; }
   double val();
   int ft_handler_init(const byte *query, uint querylen, bool presort)
-   { ft_handler=table->file->ft_init_ext(FT_BOOL,key, query, querylen, presort); }
+   {
+     ft_handler=table->file->ft_init_ext(FT_BOOL,key, query, querylen, presort);
+     return 0;
+   }
 };
 
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index cc659623f1d..b06356bfe8b 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -280,20 +280,21 @@ public:
 
 
 typedef struct st_qsel_param {
-  uint baseflag,keys,max_key_part;
-  table_map prev_tables,read_tables,current_table;
   TABLE *table;
-  bool quick;				// Don't calulate possible keys
   KEY_PART *key_parts,*key_parts_end,*key[MAX_KEY];
+  MEM_ROOT *mem_root;
+  table_map prev_tables,read_tables,current_table;
+  uint baseflag,keys,max_key_part;
   uint real_keynr[MAX_KEY];
   char min_key[MAX_KEY_LENGTH+MAX_FIELD_WIDTH],
     max_key[MAX_KEY_LENGTH+MAX_FIELD_WIDTH];
+  bool quick;				// Don't calulate possible keys
 } PARAM;
 
 static SEL_TREE * get_mm_parts(PARAM *param,Field *field,
 			       Item_func::Functype type,Item *value,
 			       Item_result cmp_type);
-static SEL_ARG *get_mm_leaf(Field *field,KEY_PART *key_part,
+static SEL_ARG *get_mm_leaf(PARAM *param,Field *field,KEY_PART *key_part,
 			    Item_func::Functype type,Item *value);
 static bool like_range(const char *ptr,uint length,char wild_prefix,
 		       uint field_length, char *min_str,char *max_str,
@@ -626,6 +627,7 @@ int SQL_SELECT::test_quick_select(key_map keys_to_use, table_map prev_tables,
     param.current_table= head->map;
     param.table=head;
     param.keys=0;
+    param.mem_root= &alloc;
 
     current_thd->no_errors=1;			// Don't warn about NULL
     init_sql_alloc(&alloc,2048,0);
@@ -894,7 +896,7 @@ get_mm_parts(PARAM *param,Field *field, Item_func::Functype type,Item *value,
 	tree=new SEL_TREE();
       if (!value || !(value->used_tables() & ~param->read_tables))
       {
-	sel_arg=get_mm_leaf(key_part->field,key_part,type,value);
+	sel_arg=get_mm_leaf(param,key_part->field,key_part,type,value);
 	if (!sel_arg)
 	  continue;
 	if (sel_arg->type == SEL_ARG::IMPOSSIBLE)
@@ -914,7 +916,7 @@ get_mm_parts(PARAM *param,Field *field, Item_func::Functype type,Item *value,
 
 
 static SEL_ARG *
-get_mm_leaf(Field *field,KEY_PART *key_part,
+get_mm_leaf(PARAM *param, Field *field, KEY_PART *key_part,
 	    Item_func::Functype type,Item *value)
 {
   uint maybe_null=(uint) field->real_maybe_null();
@@ -959,7 +961,7 @@ get_mm_leaf(Field *field,KEY_PART *key_part,
 	field_length=length;
     }
     length+=offset;
-    if (!(min_str= (char*) sql_alloc(length*2)))
+    if (!(min_str= (char*) alloc_root(param->mem_root, length*2)))
       DBUG_RETURN(0);
     max_str=min_str+length;
     if (maybe_null)
@@ -1026,7 +1028,8 @@ get_mm_leaf(Field *field,KEY_PART *key_part,
     if (type == Item_func::EQUAL_FUNC)
     {
       /* convert column_name <=> NULL -> column_name IS NULL */
-      char *str= (char*) sql_alloc(1);		// Get local copy of key
+      // Get local copy of key
+      char *str= (char*) alloc_root(param->mem_root,1);
       if (!*str)
 	DBUG_RETURN(0);
       *str = 1;
@@ -1035,7 +1038,8 @@ get_mm_leaf(Field *field,KEY_PART *key_part,
     DBUG_RETURN(&null_element);			// NULL is never true
   }
   // Get local copy of key
-  char *str= (char*) sql_alloc(key_part->part_length+maybe_null);
+  char *str= (char*) alloc_root(param->mem_root,
+				key_part->part_length+maybe_null);
   if (!str)
     DBUG_RETURN(0);
   if (maybe_null)
@@ -2235,7 +2239,7 @@ get_quick_select(PARAM *param,uint idx,SEL_ARG *key_tree)
     else
     {
       quick->key_parts=(KEY_PART*)
-	sql_memdup(param->key[idx],
+	memdup_root(&quick->alloc,(char*) param->key[idx],
 		   sizeof(KEY_PART)*
 		   param->table->key_info[param->real_keynr[idx]].key_parts);
     }
@@ -2406,7 +2410,7 @@ QUICK_SELECT *get_quick_select_for_ref(TABLE *table, TABLE_REF *ref)
 		 (key_info->flags & HA_NOSAME)) ? EQ_RANGE : 0);
 
   if (!(quick->key_parts=key_part=(KEY_PART *)
-	sql_alloc(sizeof(KEY_PART)*ref->key_parts)))
+	alloc_root(&quick->alloc,sizeof(KEY_PART)*ref->key_parts)))
     goto err;
 
   for (part=0 ; part < ref->key_parts ;part++,key_part++)
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 006e7364b3b..d76461b6faf 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -292,7 +292,7 @@ bool select_send::send_data(List<Item> &items)
   Item *item;
   while ((item=li++))
   {
-    if (item->send(packet))
+    if (item->send(thd, packet))
     {
       packet->free();				// Free used
       my_error(ER_OUT_OF_RESOURCES,MYF(0));
diff --git a/sql/sql_class.h b/sql/sql_class.h
index f2e174d85c1..e4756284bf5 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -385,7 +385,9 @@ public:
   }
   inline char *strdup(const char *str)
   { return strdup_root(&mem_root,str); }
-  inline char *memdup(const char *str, unsigned int size)
+  inline char *strmake(const char *str, uint size)
+  { return strmake_root(&mem_root,str,size); }
+  inline char *memdup(const char *str, uint size)
   { return memdup_root(&mem_root,str,size); }
 };
 
diff --git a/sql/sql_handler.cc b/sql/sql_handler.cc
index 668c5f07839..f40ebfe43ed 100644
--- a/sql/sql_handler.cc
+++ b/sql/sql_handler.cc
@@ -202,7 +202,7 @@ int mysql_ha_read(THD *thd, TABLE_LIST *tables,
         it.rewind();
         while ((item=it++))
         {
-          if (item->send(packet))
+          if (item->send(thd,packet))
           {
             packet->free();                             // Free used
             my_error(ER_OUT_OF_RESOURCES,MYF(0));
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index c3f98713c45..0a553945ea1 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -201,7 +201,7 @@ LEX_STRING get_token(LEX *lex,uint length)
   LEX_STRING tmp;
   yyUnget();			// ptr points now after last token char
   tmp.length=lex->yytoklen=length;
-  tmp.str=(char*) sql_strmake((char*) lex->tok_start,tmp.length);
+  tmp.str=(char*) lex->thd->strmake((char*) lex->tok_start,tmp.length);
   return tmp;
 }
 
@@ -250,7 +250,7 @@ static char *get_text(LEX *lex)
 
       str=lex->tok_start+1;
       end=lex->ptr-1;
-      if (!(start=(uchar*) sql_alloc((uint) (end-str)+1)))
+      if (!(start=(uchar*) lex->thd->alloc((uint) (end-str)+1)))
 	return (char*) "";		// Sql_alloc has set error flag
       if (!found_escape)
       {
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index e31b5c029e4..41c4ccd75b2 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -2049,10 +2049,11 @@ get_best_combination(JOIN *join)
   KEYUSE *keyuse;
   KEY *keyinfo;
   uint table_count;
+  THD *thd=join->thd;
 
   table_count=join->tables;
   if (!(join->join_tab=join_tab=
-	(JOIN_TAB*) join->thd->alloc(sizeof(JOIN_TAB)*table_count)))
+	(JOIN_TAB*) thd->alloc(sizeof(JOIN_TAB)*table_count)))
     return TRUE;
 
   join->const_tables=0;				/* for checking */
@@ -2130,10 +2131,10 @@ get_best_combination(JOIN *join)
       j->ref.key_parts=keyparts;
       j->ref.key_length=length;
       j->ref.key=(int) key;
-      if (!(j->ref.key_buff= (byte*) sql_calloc(ALIGN_SIZE(length)*2)) ||
-	  !(j->ref.key_copy= (store_key**) sql_alloc((sizeof(store_key*) *
+      if (!(j->ref.key_buff= (byte*) thd->calloc(ALIGN_SIZE(length)*2)) ||
+	  !(j->ref.key_copy= (store_key**) thd->alloc((sizeof(store_key*) *
 						      (keyparts+1)))) ||
-	  !(j->ref.items=    (Item**) sql_alloc(sizeof(Item*)*keyparts)))
+	  !(j->ref.items=    (Item**) thd->alloc(sizeof(Item*)*keyparts)))
       {
 	return TRUE;
       }
@@ -2153,7 +2154,6 @@ get_best_combination(JOIN *join)
       }
       else
       {
-	THD *thd=join->thd;
 	for (i=0 ; i < keyparts ; keyuse++,i++)
 	{
 	  while (keyuse->keypart != i ||
@@ -2358,7 +2358,7 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
       {
 	DBUG_EXECUTE("where",print_where(tmp,tab->table->table_name););
 	SQL_SELECT *sel=tab->select=(SQL_SELECT*)
-	  sql_memdup((gptr) select, sizeof(SQL_SELECT));
+	  join->thd->memdup((gptr) select, sizeof(SQL_SELECT));
 	if (!sel)
 	  DBUG_RETURN(1);			// End of memory
 	tab->select_cond=sel->cond=tmp;
@@ -2439,8 +2439,8 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
 					 current_map)))
 	    {
 	      DBUG_EXECUTE("where",print_where(tmp,"cache"););
-	      tab->cache.select=(SQL_SELECT*) sql_memdup((gptr) sel,
-						    sizeof(SQL_SELECT));
+	      tab->cache.select=(SQL_SELECT*)
+		join->thd->memdup((gptr) sel, sizeof(SQL_SELECT));
 	      tab->cache.select->cond=tmp;
 	      tab->cache.select->read_tables=join->const_table_map;
 	    }