MDEV-6152: Remove calls to current_thd while creating Item

- Part 4: Removing calls to sql_alloc() and sql_calloc() Other things: - Added current_thd in some places to make it clear that it's called (easier to remove later) - Move memory allocation from Item_func_case::fix_length_and_dec() to Item_func_case::fix_fields() - Added mem_root to some new calls - Fixed some wrong UNINIT_VAR() calls - Fixed a bug in generate_partition_syntax() in case of errors - Added mem_root to argument to new thread_info - Simplified my_parse_error() call in sql_yacc.yy
2025-12-24 11:21:21 +03:00 · 2015-08-27 10:07:32 +03:00
parent 3cb578c001
commit 3bca8db4f9
22 changed files with 296 additions and 253 deletions
--- a/include/my_global.h
+++ b/include/my_global.h
@@ -477,6 +477,13 @@ extern "C" int madvise(void *addr, size_t len, int behav);
 #define UNINIT_VAR(x) x
 #endif

+/* This is only to be used when reseting variables in a class constructor */
+#if defined(_lint) || defined(FORCE_INIT_OF_VARS)
+#define LINT_INIT(x) x= 0
+#else
+#define LINT_INIT(x)
+#endif
+
 #if !defined(HAVE_UINT)
 #undef HAVE_UINT
 #define HAVE_UINT
--- a/sql/ha_partition.cc
+++ b/sql/ha_partition.cc
@@ -1693,8 +1693,8 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
    } while (++i < num_parts);
  }
  if (m_reorged_parts &&
-      !(m_reorged_file= (handler**)sql_calloc(sizeof(handler*)*
-                                              (m_reorged_parts + 1))))
+      !(m_reorged_file= (handler**) thd->calloc(sizeof(handler*)*
+                                                (m_reorged_parts + 1))))
  {
    mem_alloc_error(sizeof(handler*)*(m_reorged_parts+1));
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
@@ -1725,8 +1725,9 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
      }
    } while (++i < num_parts);
  }
-  if (!(new_file_array= (handler**)sql_calloc(sizeof(handler*)*
-                                            (2*(num_remain_partitions + 1)))))
+  if (!(new_file_array= ((handler**)
+                         thd->calloc(sizeof(handler*)*
+                                     (2*(num_remain_partitions + 1))))))
  {
    mem_alloc_error(sizeof(handler*)*2*(num_remain_partitions+1));
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -2397,18 +2397,21 @@ const char *Item_ident::full_name() const
  char *tmp;
  if (!table_name || !field_name)
    return field_name ? field_name : name ? name : "tmp_field";
+
  if (db_name && db_name[0])
  {
-    tmp=(char*) sql_alloc((uint) strlen(db_name)+(uint) strlen(table_name)+
-			  (uint) strlen(field_name)+3);
+    THD *thd= current_thd;
+    tmp=(char*) thd->alloc((uint) strlen(db_name)+(uint) strlen(table_name)+
+			   (uint) strlen(field_name)+3);
    strxmov(tmp,db_name,".",table_name,".",field_name,NullS);
  }
  else
  {
    if (table_name[0])
    {
-      tmp= (char*) sql_alloc((uint) strlen(table_name) +
-			     (uint) strlen(field_name) + 2);
+      THD *thd= current_thd;
+      tmp= (char*) thd->alloc((uint) strlen(table_name) +
+			      (uint) strlen(field_name) + 2);
      strxmov(tmp, table_name, ".", field_name, NullS);
    }
    else
@@ -6276,10 +6279,11 @@ inline uint char_val(char X)
 }


-void Item_hex_constant::hex_string_init(const char *str, uint str_length)
+void Item_hex_constant::hex_string_init(THD *thd, const char *str,
+                                        uint str_length)
 {
  max_length=(str_length+1)/2;
-  char *ptr=(char*) sql_alloc(max_length+1);
+  char *ptr=(char*) thd->alloc(max_length+1);
  if (!ptr)
  {
    str_value.set("", 0, &my_charset_bin);
@@ -6372,12 +6376,12 @@ Item_bin_string::Item_bin_string(THD *thd, const char *str, uint str_length):
  Item_hex_hybrid(thd)
 {
  const char *end= str + str_length - 1;
+  char *ptr;
  uchar bits= 0;
  uint power= 1;

  max_length= (str_length + 7) >> 3;
-  char *ptr= (char*) sql_alloc(max_length + 1);
-  if (!ptr)
+  if (!(ptr= (char*) thd->alloc(max_length + 1)))
    return;
  str_value.set(ptr, max_length, &my_charset_bin);

@@ -8260,9 +8264,10 @@ bool Item_default_value::fix_fields(THD *thd, Item **items)
    my_error(ER_NO_DEFAULT_FOR_FIELD, MYF(0), field_arg->field->field_name);
    goto error;
  }
-  if (!(def_field= (Field*) sql_alloc(field_arg->field->size_of())))
+  if (!(def_field= (Field*) thd->alloc(field_arg->field->size_of())))
    goto error;
-  memcpy((void *)def_field, (void *)field_arg->field, field_arg->field->size_of());
+  memcpy((void *)def_field, (void *)field_arg->field,
+         field_arg->field->size_of());
  def_field->move_field_offset((my_ptrdiff_t)
                               (def_field->table->s->default_values -
                                def_field->table->record[0]));
@@ -8402,10 +8407,11 @@ bool Item_insert_value::fix_fields(THD *thd, Item **items)

  if (field_arg->field->table->insert_values)
  {
-    Field *def_field= (Field*) sql_alloc(field_arg->field->size_of());
+    Field *def_field= (Field*) thd->alloc(field_arg->field->size_of());
    if (!def_field)
      return TRUE;
-    memcpy((void *)def_field, (void *)field_arg->field, field_arg->field->size_of());
+    memcpy((void *)def_field, (void *)field_arg->field,
+           field_arg->field->size_of());
    def_field->move_field_offset((my_ptrdiff_t)
                                 (def_field->table->insert_values -
                                  def_field->table->record[0]));
--- a/sql/item.h
+++ b/sql/item.h
@@ -3172,16 +3172,16 @@ public:
 class Item_hex_constant: public Item_basic_constant
 {
 private:
-  void hex_string_init(const char *str, uint str_length);
+  void hex_string_init(THD *thd, const char *str, uint str_length);
 public:
  Item_hex_constant(THD *thd): Item_basic_constant(thd)
  {
-    hex_string_init("", 0);
+    hex_string_init(thd, "", 0);
  }
  Item_hex_constant(THD *thd, const char *str, uint str_length):
    Item_basic_constant(thd)
  {
-    hex_string_init(str, str_length);
+    hex_string_init(thd, str, str_length);
  }
  enum Type type() const { return VARBIN_ITEM; }
  enum Item_result result_type () const { return STRING_RESULT; }
@@ -3409,7 +3409,7 @@ class Item_args
 {
 protected:
  Item **args, *tmp_arg[2];
-  void set_arguments(List<Item> &list);
+  void set_arguments(THD *thd, List<Item> &list);
  bool walk_args(Item_processor processor, bool walk_subquery, uchar *arg)
  {
    for (uint i= 0; i < arg_count; i++)
@@ -3463,9 +3463,9 @@ public:
      args[0]= a; args[1]= b; args[2]= c; args[3]= d; args[4]= e;
    }
  }
-  Item_args(List<Item> &list)
+  Item_args(THD *thd, List<Item> &list)
  {
-    set_arguments(list);
+    set_arguments(thd, list);
  }
  Item_args(THD *thd, const Item_args *other);
  inline Item **arguments() const { return args; }
@@ -3560,7 +3560,7 @@ public:
  Item_func_or_sum(THD *thd, Item_func_or_sum *item):
    Item_result_field(thd, item), Item_args(thd, item) { }
  Item_func_or_sum(THD *thd, List<Item> &list):
-    Item_result_field(thd), Item_args(list) { }
+    Item_result_field(thd), Item_args(thd, list) { }
  bool walk(Item_processor processor, bool walk_subquery, uchar *arg)
  {
    if (walk_args(processor, walk_subquery, arg))
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -2790,7 +2790,7 @@ Item_func_case::Item_func_case(THD *thd, List<Item> &list,
    else_expr_num= list.elements;
    list.push_back(else_expr_arg, thd->mem_root);
  }
-  set_arguments(list);
+  set_arguments(thd, list);
  bzero(&cmp_items, sizeof(cmp_items));
 }

@@ -2949,6 +2949,10 @@ bool Item_func_case::fix_fields(THD *thd, Item **ref)
    Item_func_case::val_int() -> Item_func_case::find_item()
  */
  uchar buff[MAX_FIELD_WIDTH*2+sizeof(String)*2+sizeof(String*)*2+sizeof(double)*2+sizeof(longlong)*2];
+
+  if (!(arg_buffer= (Item**) thd->alloc(sizeof(Item*)*(ncases+1))))
+    return TRUE;
+
  bool res= Item_func::fix_fields(thd, ref);
  /*
    Call check_stack_overrun after fix_fields to be sure that stack variable
@@ -3002,14 +3006,11 @@ static void change_item_tree_if_needed(THD *thd,

 void Item_func_case::fix_length_and_dec()
 {
-  Item **agg;
+  Item **agg= arg_buffer;
  uint nagg;
  uint found_types= 0;
  THD *thd= current_thd;

-  if (!(agg= (Item**) sql_alloc(sizeof(Item*)*(ncases+1))))
-    return;
-
  if (else_expr_num == -1 || args[else_expr_num]->maybe_null)
    maybe_null= 1;

@@ -3052,8 +3053,9 @@ void Item_func_case::fix_length_and_dec()
    if (else_expr_num != -1) 
      agg_num_lengths(args[else_expr_num]);
    max_length= my_decimal_precision_to_length_no_truncation(max_length +
-                                                             decimals, decimals,
-                                               unsigned_flag);
+                                                             decimals,
+                                                             decimals,
+                                                             unsigned_flag);
  }
  
  /*
@@ -3501,9 +3503,9 @@ Item *in_string::create_item(THD *thd)
 }


-in_row::in_row(uint elements, Item * item)
+in_row::in_row(THD *thd, uint elements, Item * item)
 {
-  base= (char*) new cmp_item_row[count= elements];
+  base= (char*) new (thd->mem_root) cmp_item_row[count= elements];
  size= sizeof(cmp_item_row);
  compare= (qsort2_cmp) cmp_row;
  /*
@@ -3532,7 +3534,7 @@ void in_row::set(uint pos, Item *item)
 {
  DBUG_ENTER("in_row::set");
  DBUG_PRINT("enter", ("pos: %u  item: 0x%lx", pos, (ulong) item));
-  ((cmp_item_row*) base)[pos].store_value_by_template(&tmp, item);
+  ((cmp_item_row*) base)[pos].store_value_by_template(current_thd, &tmp, item);
  DBUG_VOID_RETURN;
 }

@@ -3745,7 +3747,7 @@ void cmp_item_row::store_value(Item *item)
 }


-void cmp_item_row::store_value_by_template(cmp_item *t, Item *item)
+void cmp_item_row::store_value_by_template(THD *thd, cmp_item *t, Item *item)
 {
  cmp_item_row *tmpl= (cmp_item_row*) t;
  if (tmpl->n != item->cols())
@@ -3754,7 +3756,7 @@ void cmp_item_row::store_value_by_template(cmp_item *t, Item *item)
    return;
  }
  n= tmpl->n;
-  if ((comparators= (cmp_item **) sql_alloc(sizeof(cmp_item *)*n)))
+  if ((comparators= (cmp_item **) thd->alloc(sizeof(cmp_item *)*n)))
  {
    item->bring_value();
    item->null_value= 0;
@@ -3762,7 +3764,7 @@ 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],
+      comparators[i]->store_value_by_template(thd, tmpl->comparators[i],
 					      item->element_index(i));
      item->null_value|= item->element_index(i)->null_value;
    }
@@ -4006,12 +4008,12 @@ void Item_func_in::fix_length_and_dec()

      if (const_itm && !nulls_in_row())
      {
-        array= new in_row(arg_count-1, 0);
+        array= new (thd->mem_root) in_row(thd, arg_count-1, 0);
        cmp= &((in_row*)array)->tmp;
      }
      else
      {
-        if (!(cmp= new cmp_item_row))
+        if (!(cmp= new (thd->mem_root) cmp_item_row))
          return;
        cmp_items[ROW_RESULT]= cmp;
      }
@@ -4028,7 +4030,7 @@ void Item_func_in::fix_length_and_dec()
            cmp= ((in_row*)array)->tmp.comparators + col;
          else
            cmp= ((cmp_item_row*)cmp_items[ROW_RESULT])->comparators + col;
-          *cmp= new cmp_item_datetime(date_arg);
+          *cmp= new (thd->mem_root) cmp_item_datetime(date_arg);
        }
      }
    }
@@ -4067,14 +4069,14 @@ void Item_func_in::fix_length_and_dec()
    }
    switch (cmp_type) {
    case STRING_RESULT:
-      array=new in_string(arg_count-1,(qsort2_cmp) srtcmp_in, 
-                          cmp_collation.collation);
+      array=new (thd->mem_root) in_string(arg_count-1,(qsort2_cmp) srtcmp_in, 
+                                          cmp_collation.collation);
      break;
    case INT_RESULT:
-      array= new in_longlong(arg_count-1);
+      array= new (thd->mem_root) in_longlong(arg_count-1);
      break;
    case REAL_RESULT:
-      array= new in_double(arg_count-1);
+      array= new (thd->mem_root) in_double(arg_count-1);
      break;
    case ROW_RESULT:
      /*
@@ -4085,11 +4087,11 @@ void Item_func_in::fix_length_and_dec()
      ((in_row*)array)->tmp.store_value(args[0]);
      break;
    case DECIMAL_RESULT:
-      array= new in_decimal(arg_count - 1);
+      array= new (thd->mem_root) in_decimal(arg_count - 1);
      break;
    case TIME_RESULT:
      date_arg= find_date_time_item(args, arg_count, 0);
-      array= new in_datetime(date_arg, arg_count - 1);
+      array= new (thd->mem_root) in_datetime(date_arg, arg_count - 1);
      break;
    case IMPOSSIBLE_RESULT:
      DBUG_ASSERT(0);
@@ -5063,16 +5065,18 @@ bool Item_func_like::find_selective_predicates_list_processor(uchar *arg)
    (find_selective_predicates_list_processor_data *) arg;
  if (use_sampling && used_tables() == data->table->map)
  {
-    COND_STATISTIC *stat= (COND_STATISTIC *)sql_alloc(sizeof(COND_STATISTIC));
-    if (!stat)
+    THD *thd= data->table->in_use;
+    COND_STATISTIC *stat;
+    Item *arg0;
+    if (!(stat= (COND_STATISTIC *) thd->alloc(sizeof(COND_STATISTIC))))
      return TRUE;
    stat->cond= this;
-    Item *arg0= args[0]->real_item();
+    arg0= args[0]->real_item();
    if (args[1]->const_item() && arg0->type() == FIELD_ITEM)
      stat->field_arg= ((Item_field *)arg0)->field;
    else
      stat->field_arg= NULL;
-    data->list.push_back(stat);
+    data->list.push_back(stat, thd->mem_root);
  }
  return FALSE;
 }
--- a/sql/item_cmpfunc.h
+++ b/sql/item_cmpfunc.h
@@ -1105,7 +1105,7 @@ public:
  static cmp_item* get_comparator(Item_result type, Item * warn_item,
                                  CHARSET_INFO *cs);
  virtual cmp_item *make_same()= 0;
-  virtual void store_value_by_template(cmp_item *tmpl, Item *item)
+  virtual void store_value_by_template(THD *thd, cmp_item *tmpl, Item *item)
  {
    store_value(item);
  }
@@ -1300,6 +1300,7 @@ class Item_func_case :public Item_func_hybrid_field_type
  DTCollation cmp_collation;
  cmp_item *cmp_items[6]; /* For all result types */
  cmp_item *case_item;
+  Item **arg_buffer;
 public:
  Item_func_case(THD *thd, List<Item> &list, Item *first_expr_arg,
                 Item *else_expr_arg);
@@ -1405,7 +1406,7 @@ public:
  int cmp(Item *arg);
  int compare(cmp_item *arg);
  cmp_item *make_same();
-  void store_value_by_template(cmp_item *tmpl, Item *);
+  void store_value_by_template(THD *thd, cmp_item *tmpl, Item *);
  friend void Item_func_in::fix_length_and_dec();
 };

@@ -1414,7 +1415,7 @@ class in_row :public in_vector
 {
  cmp_item_row tmp;
 public:
-  in_row(uint elements, Item *);
+  in_row(THD *thd, uint elements, Item *);
  ~in_row();
  void set(uint pos,Item *item);
  uchar *get_value(Item *item);
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -89,14 +89,14 @@ static inline bool test_if_sum_overflows_ull(ulonglong arg1, ulonglong arg2)
 }


-void Item_args::set_arguments(List<Item> &list)
+void Item_args::set_arguments(THD *thd, List<Item> &list)
 {
  arg_count= list.elements;
  if (arg_count <= 2)
  {
    args= tmp_arg;
  }
-  else if (!(args= (Item**) sql_alloc(sizeof(Item*) * arg_count)))
+  else if (!(args= (Item**) thd->alloc(sizeof(Item*) * arg_count)))
  {
    arg_count= 0;
    return;
@@ -3501,7 +3501,7 @@ udf_handler::fix_fields(THD *thd, Item_func_or_sum *func,
  if ((f_args.arg_count=arg_count))
  {
    if (!(f_args.arg_type= (Item_result*)
-	  sql_alloc(f_args.arg_count*sizeof(Item_result))))
+	  thd->alloc(f_args.arg_count*sizeof(Item_result))))

    {
      free_udf(u_d);
@@ -3543,13 +3543,14 @@ udf_handler::fix_fields(THD *thd, Item_func_or_sum *func,
    }
    //TODO: why all following memory is not allocated with 1 call of sql_alloc?
    if (!(buffers=new String[arg_count]) ||
-	!(f_args.args= (char**) sql_alloc(arg_count * sizeof(char *))) ||
-	!(f_args.lengths= (ulong*) sql_alloc(arg_count * sizeof(long))) ||
-	!(f_args.maybe_null= (char*) sql_alloc(arg_count * sizeof(char))) ||
-	!(num_buffer= (char*) sql_alloc(arg_count *
+	!(f_args.args= (char**) thd->alloc(arg_count * sizeof(char *))) ||
+	!(f_args.lengths= (ulong*) thd->alloc(arg_count * sizeof(long))) ||
+	!(f_args.maybe_null= (char*) thd->alloc(arg_count * sizeof(char))) ||
+	!(num_buffer= (char*) thd->alloc(arg_count *
 					ALIGN_SIZE(sizeof(double)))) ||
-	!(f_args.attributes= (char**) sql_alloc(arg_count * sizeof(char *))) ||
-	!(f_args.attribute_lengths= (ulong*) sql_alloc(arg_count *
+	!(f_args.attributes= (char**) thd->alloc(arg_count *
+                                                 sizeof(char *))) ||
+	!(f_args.attribute_lengths= (ulong*) thd->alloc(arg_count *
 						       sizeof(long))))
    {
      free_udf(u_d);
@@ -6507,7 +6508,7 @@ Item_func_sp::Item_func_sp(THD *thd, Name_resolution_context *context_arg,
 {
  maybe_null= 1;
  m_name->init_qname(current_thd);
-  dummy_table= (TABLE*) sql_calloc(sizeof(TABLE)+ sizeof(TABLE_SHARE));
+  dummy_table= (TABLE*) thd->calloc(sizeof(TABLE)+ sizeof(TABLE_SHARE));
  dummy_table->s= (TABLE_SHARE*) (dummy_table+1);
 }

@@ -6519,7 +6520,7 @@ Item_func_sp::Item_func_sp(THD *thd, Name_resolution_context *context_arg,
 {
  maybe_null= 1;
  m_name->init_qname(current_thd);
-  dummy_table= (TABLE*) sql_calloc(sizeof(TABLE)+ sizeof(TABLE_SHARE));
+  dummy_table= (TABLE*) thd->calloc(sizeof(TABLE)+ sizeof(TABLE_SHARE));
  dummy_table->s= (TABLE_SHARE*) (dummy_table+1);
 }

@@ -6631,7 +6632,7 @@ Item_func_sp::init_result_field(THD *thd)
  if (sp_result_field->pack_length() > sizeof(result_buf))
  {
    void *tmp;
-    if (!(tmp= sql_alloc(sp_result_field->pack_length())))
+    if (!(tmp= thd->alloc(sp_result_field->pack_length())))
      DBUG_RETURN(TRUE);
    sp_result_field->move_field((uchar*) tmp);
  }
--- a/sql/item_func.h
+++ b/sql/item_func.h
@@ -103,7 +103,7 @@ public:
  Item_func(THD *thd, List<Item> &list):
    Item_func_or_sum(thd, list), allowed_arg_cols(1)
  {
-    set_arguments(list);
+    set_arguments(thd, list);
  }
  // Constructor used for Item_cond_and/or (see Item comment)
  Item_func(THD *thd, Item_func *item)
@@ -134,10 +134,10 @@ public:
  bool eq(const Item *item, bool binary_cmp) const;
  virtual Item *key_item() const { return args[0]; }
  virtual bool const_item() const { return const_item_cache; }
-  void set_arguments(List<Item> &list)
+  void set_arguments(THD *thd, List<Item> &list)
  {
    allowed_arg_cols= 1;
-    Item_args::set_arguments(list);
+    Item_args::set_arguments(thd, list);
    sync_with_sum_func_and_with_field(list);
    list.empty();                                     // Fields are used
  }
--- a/sql/item_row.h
+++ b/sql/item_row.h
@@ -36,7 +36,7 @@ class Item_row: public Item,
  bool with_null;
 public:
  Item_row(THD *thd, List<Item> &list):
-   Item(thd), Item_args(list), not_null_tables_cache(0), with_null(0)
+  Item(thd), Item_args(thd, list), not_null_tables_cache(0), with_null(0)
  { }
  Item_row(THD *thd, Item_row *item):
    Item(thd),
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -404,7 +404,7 @@ bool Item_sum::collect_outer_ref_processor(uchar *param)
 Item_sum::Item_sum(THD *thd, List<Item> &list): Item_func_or_sum(thd, list),
  forced_const(FALSE)
 {
-  if (!(orig_args= (Item **) sql_alloc(sizeof(Item *) * arg_count)))
+  if (!(orig_args= (Item **) thd->alloc(sizeof(Item *) * arg_count)))
  {
    args= NULL;
  }
@@ -3197,8 +3197,8 @@ Item_func_group_concat(THD *thd, Name_resolution_context *context_arg,
           (for possible order items in temporary tables)
    order - arg_count_order
  */
-  if (!(args= (Item**) sql_alloc(sizeof(Item*) * arg_count * 2 +
-                                 sizeof(ORDER*)*arg_count_order)))
+  if (!(args= (Item**) thd->alloc(sizeof(Item*) * arg_count * 2 +
+                                  sizeof(ORDER*)*arg_count_order)))
    return;

  order= (ORDER**)(args + arg_count);
--- a/sql/opt_subselect.h
+++ b/sql/opt_subselect.h
@@ -95,12 +95,13 @@ public:
    bound_sj_equalities(0),
    quick_uses_applicable_index(FALSE)
  {
-    UNINIT_VAR(quick_max_loose_keypart); /* Protected by quick_uses_applicable_index */
+    /* Protected by quick_uses_applicable_index */
+    LINT_INIT(quick_max_loose_keypart);
    /* The following are protected by best_loose_scan_cost!= DBL_MAX */
-    UNINIT_VAR(best_loose_scan_key);
-    UNINIT_VAR(best_loose_scan_records);
-    UNINIT_VAR(best_max_loose_keypart);
-    UNINIT_VAR(best_loose_scan_start_key);
+    LINT_INIT(best_loose_scan_key);
+    LINT_INIT(best_loose_scan_records);
+    LINT_INIT(best_max_loose_keypart);
+    LINT_INIT(best_loose_scan_start_key);
  }
  
  void init(JOIN *join, JOIN_TAB *s, table_map remaining_tables)
@@ -122,7 +123,7 @@ public:
        s->emb_sj_nest->sj_in_exprs < 64 && 
        ((remaining_tables & s->emb_sj_nest->sj_inner_tables) ==        // (2)
         s->emb_sj_nest->sj_inner_tables) &&                            // (2)
-        join->cur_sj_inner_tables == 0 &&                                  // (3)
+        join->cur_sj_inner_tables == 0 &&                               // (3)
        !(remaining_tables & 
          s->emb_sj_nest->nested_join->sj_corr_tables) &&               // (4)
        remaining_tables & s->emb_sj_nest->nested_join->sj_depends_on &&// (5)
--- a/sql/partition_info.cc
+++ b/sql/partition_info.cc
@@ -1222,8 +1222,8 @@ bool partition_info::check_range_constants(THD *thd)
    part_column_list_val *UNINIT_VAR(current_largest_col_val);
    uint num_column_values= part_field_list.elements;
    uint size_entries= sizeof(part_column_list_val) * num_column_values;
-    range_col_array= (part_column_list_val*)sql_calloc(num_parts *
-                                                       size_entries);
+    range_col_array= (part_column_list_val*) thd->calloc(num_parts *
+                                                         size_entries);
    if (unlikely(range_col_array == NULL))
    {
      mem_alloc_error(num_parts * size_entries);
@@ -1260,7 +1260,7 @@ bool partition_info::check_range_constants(THD *thd)
    longlong part_range_value;
    bool signed_flag= !part_expr->unsigned_flag;

-    range_int_array= (longlong*)sql_alloc(num_parts * sizeof(longlong));
+    range_int_array= (longlong*) thd->alloc(num_parts * sizeof(longlong));
    if (unlikely(range_int_array == NULL))
    {
      mem_alloc_error(num_parts * sizeof(longlong));
@@ -1474,7 +1474,7 @@ bool partition_info::check_list_constants(THD *thd)
  size_entries= column_list ?
        (num_column_values * sizeof(part_column_list_val)) :
        sizeof(LIST_PART_ENTRY);
-  ptr= sql_calloc((num_list_values+1) * size_entries);
+  ptr= thd->calloc((num_list_values+1) * size_entries);
  if (unlikely(ptr == NULL))
  {
    mem_alloc_error(num_list_values * size_entries);
@@ -1972,7 +1972,7 @@ bool partition_info::check_partition_field_length()
    the binary collation.
 */

-bool partition_info::set_up_charset_field_preps()
+bool partition_info::set_up_charset_field_preps(THD *thd)
 {
  Field *field, **ptr;
  uchar **char_ptrs;
@@ -1998,14 +1998,14 @@ bool partition_info::set_up_charset_field_preps()
      }
    }
    size= tot_part_fields * sizeof(char*);
-    if (!(char_ptrs= (uchar**)sql_calloc(size)))
+    if (!(char_ptrs= (uchar**)thd->calloc(size)))
      goto error;
    part_field_buffers= char_ptrs;
-    if (!(char_ptrs= (uchar**)sql_calloc(size)))
+    if (!(char_ptrs= (uchar**)thd->calloc(size)))
      goto error;
    restore_part_field_ptrs= char_ptrs;
    size= (tot_part_fields + 1) * sizeof(Field*);
-    if (!(char_ptrs= (uchar**)sql_alloc(size)))
+    if (!(char_ptrs= (uchar**)thd->alloc(size)))
      goto error;
    part_charset_field_array= (Field**)char_ptrs;
    ptr= part_field_array;
@@ -2016,7 +2016,7 @@ bool partition_info::set_up_charset_field_preps()
      {
        uchar *field_buf;
        size= field->pack_length();
-        if (!(field_buf= (uchar*) sql_calloc(size)))
+        if (!(field_buf= (uchar*) thd->calloc(size)))
          goto error;
        part_charset_field_array[i]= field;
        part_field_buffers[i++]= field_buf;
@@ -2038,14 +2038,14 @@ bool partition_info::set_up_charset_field_preps()
      }
    }
    size= tot_subpart_fields * sizeof(char*);
-    if (!(char_ptrs= (uchar**) sql_calloc(size)))
+    if (!(char_ptrs= (uchar**) thd->calloc(size)))
      goto error;
    subpart_field_buffers= char_ptrs;
-    if (!(char_ptrs= (uchar**) sql_calloc(size)))
+    if (!(char_ptrs= (uchar**) thd->calloc(size)))
      goto error;
    restore_subpart_field_ptrs= char_ptrs;
    size= (tot_subpart_fields + 1) * sizeof(Field*);
-    if (!(char_ptrs= (uchar**) sql_alloc(size)))
+    if (!(char_ptrs= (uchar**) thd->alloc(size)))
      goto error;
    subpart_charset_field_array= (Field**)char_ptrs;
    ptr= subpart_field_array;
@@ -2057,7 +2057,7 @@ bool partition_info::set_up_charset_field_preps()
      if (!field_is_partition_charset(field))
        continue;
      size= field->pack_length();
-      if (!(field_buf= (uchar*) sql_calloc(size)))
+      if (!(field_buf= (uchar*) thd->calloc(size)))
        goto error;
      subpart_charset_field_array[i]= field;
      subpart_field_buffers[i++]= field_buf;
@@ -2686,14 +2686,13 @@ bool partition_info::fix_column_value_functions(THD *thd,
        }
        thd->got_warning= save_got_warning;
        thd->variables.sql_mode= save_sql_mode;
-        if (!(val_ptr= (uchar*) sql_calloc(len)))
+        if (!(val_ptr= (uchar*) thd->memdup(field->ptr, len)))
        {
          mem_alloc_error(len);
          result= TRUE;
          goto end;
        }
        col_val->column_value= val_ptr;
-        memcpy(val_ptr, field->ptr, len);
      }
    }
    col_val->fixed= 2;
--- a/sql/partition_info.h
+++ b/sql/partition_info.h
@@ -335,7 +335,7 @@ public:
  bool set_part_expr(char *start_token, Item *item_ptr,
                     char *end_token, bool is_subpart);
  static int compare_column_values(const void *a, const void *b);
-  bool set_up_charset_field_preps();
+  bool set_up_charset_field_preps(THD *thd);
  bool check_partition_field_length();
  bool init_column_part(THD *thd);
  bool add_column_list_value(THD *thd, Item *item);
--- a/sql/sql_db.cc
+++ b/sql/sql_db.cc
@@ -1721,7 +1721,7 @@ bool mysql_upgrade_db(THD *thd, LEX_STRING *old_db)

      table_str.length= filename_to_tablename(file->name,
                                              tname, sizeof(tname)-1);
-      table_str.str= (char*) sql_memdup(tname, table_str.length + 1);
+      table_str.str= (char*) thd->memdup(tname, table_str.length + 1);
      Table_ident *old_ident= new Table_ident(thd, *old_db, table_str, 0);
      Table_ident *new_ident= new Table_ident(thd, new_db, table_str, 0);
      if (!old_ident || !new_ident ||
--- a/sql/sql_delete.cc
+++ b/sql/sql_delete.cc
@@ -906,7 +906,7 @@ multi_delete::multi_delete(THD *thd_arg, TABLE_LIST *dt, uint num_of_tables_arg)
    num_of_tables(num_of_tables_arg), error(0),
    do_delete(0), transactional_tables(0), normal_tables(0), error_handled(0)
 {
-  tempfiles= (Unique **) sql_calloc(sizeof(Unique *) * num_of_tables);
+  tempfiles= (Unique **) thd_arg->calloc(sizeof(Unique *) * num_of_tables);
 }


--- a/sql/sql_join_cache.cc
+++ b/sql/sql_join_cache.cc
@@ -328,8 +328,8 @@ int JOIN_CACHE::alloc_fields()
 {
  uint ptr_cnt= external_key_arg_fields+blobs+1;
  uint fields_size= sizeof(CACHE_FIELD)*fields;
-  field_descr= (CACHE_FIELD*) sql_alloc(fields_size +
-                                        sizeof(CACHE_FIELD*)*ptr_cnt);
+  field_descr= (CACHE_FIELD*) join->thd->alloc(fields_size +
+                                               sizeof(CACHE_FIELD*)*ptr_cnt);
  blob_ptr= (CACHE_FIELD **) ((uchar *) field_descr + fields_size);
  return (field_descr == NULL);
 }  
@@ -2679,7 +2679,7 @@ int JOIN_CACHE_HASHED::init(bool for_explain)
  if ((rc= JOIN_CACHE::init(for_explain)) || for_explain)
    DBUG_RETURN (rc); 

-  if (!(key_buff= (uchar*) sql_alloc(key_length)))
+  if (!(key_buff= (uchar*) join->thd->alloc(key_length)))
    DBUG_RETURN(1);

  /* Take into account a reference to the next record in the key chain */
--- a/sql/sql_partition.cc
+++ b/sql/sql_partition.cc
@@ -1756,7 +1756,7 @@ bool fix_partition_func(THD *thd, TABLE *table,
    goto end;
  if (unlikely(set_up_partition_bitmaps(thd, part_info)))
    goto end;
-  if (unlikely(part_info->set_up_charset_field_preps()))
+  if (unlikely(part_info->set_up_charset_field_preps(thd)))
  {
    my_error(ER_PARTITION_FUNCTION_IS_NOT_ALLOWED, MYF(0));
    goto end;
@@ -2653,8 +2653,7 @@ char *generate_partition_syntax(partition_info *part_info,
  {
    if (!use_sql_alloc)
      my_free(buf);
-    else
-      buf= NULL;
+    buf= NULL;
  }
  else
    buf[*buf_length]= 0;
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -22484,7 +22484,7 @@ setup_copy_fields(THD *thd, TMP_TABLE_PARAM *param,
          another extra byte to not get warnings from purify in
          Field_string::val_int
        */
-	if (!(tmp= (uchar*) sql_alloc(field->pack_length()+2)))
+	if (!(tmp= (uchar*) thd->alloc(field->pack_length()+2)))
 	  goto err;
        if (copy)
        {
@@ -22739,7 +22739,7 @@ change_to_use_tmp_fields(THD *thd, Item **ref_pointer_array,
        new_field->update_null_value();
        List<Item> list;
        list.push_back(new_field, thd->mem_root);
-        suv->set_arguments(list);
+        suv->set_arguments(thd, list);
        item_field= suv;
      }
      else
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -2333,10 +2333,8 @@ static int show_create_view(THD *thd, TABLE_LIST *table, String *buff)

 class thread_info :public ilink {
 public:
-  static void *operator new(size_t size)
-  {
-    return (void*) sql_alloc((uint) size);
-  }
+  static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
+  { return alloc_root(mem_root, size); }
  static void operator delete(void *ptr __attribute__((unused)),
                              size_t size __attribute__((unused)))
  { TRASH(ptr, size); }
@@ -2440,7 +2438,7 @@ void mysqld_list_processes(THD *thd,const char *user, bool verbose)
        (!user || (!tmp->system_thread &&
                   tmp_sctx->user && !strcmp(tmp_sctx->user, user))))
    {
-      thread_info *thd_info= new thread_info;
+      thread_info *thd_info= new (thd->mem_root) thread_info;

      thd_info->thread_id=tmp->thread_id;
      thd_info->user= thd->strdup(tmp_sctx->user ? tmp_sctx->user :
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -3648,8 +3648,8 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
    DBUG_RETURN(TRUE);
  }

-  (*key_info_buffer)= key_info= (KEY*) sql_calloc(sizeof(KEY) * (*key_count));
-  key_part_info=(KEY_PART_INFO*) sql_calloc(sizeof(KEY_PART_INFO)*key_parts);
+  (*key_info_buffer)= key_info= (KEY*) thd->calloc(sizeof(KEY) * (*key_count));
+  key_part_info=(KEY_PART_INFO*) thd->calloc(sizeof(KEY_PART_INFO)*key_parts);
  if (!*key_info_buffer || ! key_part_info)
    DBUG_RETURN(TRUE);				// Out of memory

--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -96,7 +96,7 @@ int yylex(void *yylval, void *yythd);
 #define MYSQL_YYABORT_UNLESS(A)                  \
  if (!(A))                                      \
  {                                              \
-    my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));\
+    my_parse_error(thd, ER_SYNTAX_ERROR);        \
    MYSQL_YYABORT;                               \
  }

@@ -140,25 +140,31 @@ int yylex(void *yylval, void *yythd);
  parser.
 */

-void my_parse_error(const char *s, const char *yytext=0)
+static void my_parse_error_intern(THD *thd, const char *err_text,
+                                  const char *yytext)
 {
-  THD *thd= current_thd;
-  Lex_input_stream *lip= & thd->m_parser_state->m_lip;
-
+  Lex_input_stream *lip= &thd->m_parser_state->m_lip;
  if (!yytext)
-    yytext= lip->get_tok_start();
-  if (!yytext)
-    yytext= "";
-
+  {
+    if (!(yytext= lip->get_tok_start()))
+      yytext= "";
+  }
  /* Push an error into the error stack */
-  ErrConvString err(yytext, strlen(yytext), thd->variables.character_set_client);
-  my_printf_error(ER_PARSE_ERROR,  ER_THD(thd, ER_PARSE_ERROR), MYF(0), s,
-                  err.ptr(), lip->yylineno);
+  ErrConvString err(yytext, strlen(yytext),
+                    thd->variables.character_set_client);
+  my_printf_error(ER_PARSE_ERROR,  ER_THD(thd, ER_PARSE_ERROR), MYF(0),
+                  err_text, err.ptr(), lip->yylineno);
+}
+
+
+static void my_parse_error(THD *thd, uint err_number, const char *yytext=0)
+{
+  return my_parse_error_intern(thd, ER_THD(thd, err_number), yytext);
 }

 void LEX::parse_error()
 {
-  my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+  my_parse_error(thd, ER_SYNTAX_ERROR);
 }


@@ -194,7 +200,7 @@ void MYSQLerror(THD *thd, const char *s)
  /* "parse error" changed into "syntax error" between bison 1.75 and 1.875 */
  if (strcmp(s,"parse error") == 0 || strcmp(s,"syntax error") == 0)
    s= ER_THD(thd, ER_SYNTAX_ERROR);
-  my_parse_error(s);
+  my_parse_error_intern(thd, s, 0);
 }


@@ -646,11 +652,11 @@ Item* handle_sql2003_note184_exception(THD *thd, Item* left, bool equal,

   @param lex The parser state.

-   @param is_union_distinct True if the union preceding the new select statement
-   uses UNION DISTINCT.
+   @param is_union_distinct True if the union preceding the new select
+          statement uses UNION DISTINCT.

   @param is_top_level This should be @c TRUE if the newly created SELECT_LEX
-   is a non-nested statement.
+                       is a non-nested statement.

   @return <code>false</code> if successful, <code>true</code> if an error was
   reported. In the latter case parsing should stop.
@@ -680,7 +686,7 @@ bool add_select_to_union_list(LEX *lex, bool is_union_distinct,
  }
  if (lex->current_select->linkage == GLOBAL_OPTIONS_TYPE)
  {
-    my_parse_error(ER_THD(lex->thd, ER_SYNTAX_ERROR));
+    my_parse_error(lex->thd, ER_SYNTAX_ERROR);
    return TRUE;
  }
  /* This counter shouldn't be incremented for UNION parts */
@@ -708,7 +714,7 @@ bool setup_select_in_parentheses(LEX *lex)
  /*
  if (sel->set_braces(1))
  {
-    my_parse_error(ER_THD(lex->thd, ER_SYNTAX_ERROR));
+    my_parse_error(lex->thd, ER_SYNTAX_ERROR);
    return TRUE;
  }
  */
@@ -718,7 +724,7 @@ bool setup_select_in_parentheses(LEX *lex)
      sel->master_unit()->first_select()->linkage ==
      UNION_TYPE)
  {
-    my_parse_error(ER_THD(lex->thd, ER_SYNTAX_ERROR));
+    my_parse_error(lex->thd, ER_SYNTAX_ERROR);
    return TRUE;
  }
  if (sel->linkage == UNION_TYPE &&
@@ -3431,7 +3437,7 @@ signal_allowed_expr:
                    SIGNAL/RESIGNAL ...
                    SET <signal condition item name> = @foo := expr
                */
-                my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+                my_parse_error(thd, ER_SYNTAX_ERROR);
                MYSQL_YYABORT;
              }
            }
@@ -4613,7 +4619,8 @@ tablespace_name:
          ident
          {
            LEX *lex= Lex;
-            lex->alter_tablespace_info= new st_alter_tablespace();
+            lex->alter_tablespace_info= (new (thd->mem_root)
+                                         st_alter_tablespace());
            if (lex->alter_tablespace_info == NULL)
              MYSQL_YYABORT;
            lex->alter_tablespace_info->tablespace_name= $1.str;
@@ -4625,7 +4632,8 @@ logfile_group_name:
          ident
          {
            LEX *lex= Lex;
-            lex->alter_tablespace_info= new st_alter_tablespace();
+            lex->alter_tablespace_info= (new (thd->mem_root)
+                                         st_alter_tablespace());
            if (lex->alter_tablespace_info == NULL)
              MYSQL_YYABORT;
            lex->alter_tablespace_info->logfile_group_name= $1.str;
@@ -4899,7 +4907,7 @@ partitioning:
          PARTITION_SYM have_partitioning
          {
            LEX *lex= Lex;
-            lex->part_info= new partition_info();
+            lex->part_info= new (thd->mem_root) partition_info();
            if (!lex->part_info)
            {
              mem_alloc_error(sizeof(partition_info));
@@ -4938,7 +4946,7 @@ partition_entry:
            LEX *lex= Lex;
            if (!lex->part_info)
            {
-              my_parse_error(ER_THD(thd, ER_PARTITION_ENTRY_ERROR));
+              my_parse_error(thd, ER_PARTITION_ENTRY_ERROR);
              MYSQL_YYABORT;
            }
            /*
@@ -4993,7 +5001,7 @@ opt_key_algo:
              Lex->part_info->key_algorithm= partition_info::KEY_ALGORITHM_55;
              break;
            default:
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
          }
@@ -5122,7 +5130,7 @@ part_func_expr:
            lex->safe_to_cache_query= 1;
            if (not_corr_func)
            {
-              my_parse_error(ER_THD(thd, ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR));
+              my_parse_error(thd, ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR);
              MYSQL_YYABORT;
            }
            $$=$1;
@@ -5171,7 +5179,7 @@ part_defs:
              if (part_info->num_parts !=
                  count_curr_parts)
              {
-                my_parse_error(ER_THD(thd, ER_PARTITION_WRONG_NO_PART_ERROR));
+                my_parse_error(thd, ER_PARTITION_WRONG_NO_PART_ERROR);
                MYSQL_YYABORT;
              }
            }
@@ -5192,7 +5200,7 @@ part_definition:
          PARTITION_SYM
          {
            partition_info *part_info= Lex->part_info;
-            partition_element *p_elem= new partition_element();
+            partition_element *p_elem= new (thd->mem_root) partition_element();

            if (!p_elem ||
                 part_info->partitions.push_back(p_elem, thd->mem_root))
@@ -5290,7 +5298,7 @@ part_func_max:
                part_info->num_columns != 1U)
            {
              part_info->print_debug("Kilroy II", NULL);
-              my_parse_error(ER_THD(thd, ER_PARTITION_COLUMN_LIST_ERROR));
+              my_parse_error(thd, ER_PARTITION_COLUMN_LIST_ERROR);
              MYSQL_YYABORT;
            }
            else
@@ -5321,7 +5329,7 @@ part_values_in:
                  part_info->num_columns > MAX_REF_PARTS)
              {
                part_info->print_debug("Kilroy III", NULL);
-                my_parse_error(ER_THD(thd, ER_PARTITION_COLUMN_LIST_ERROR));
+                my_parse_error(thd, ER_PARTITION_COLUMN_LIST_ERROR);
                MYSQL_YYABORT;
              }
              /*
@@ -5342,7 +5350,7 @@ part_values_in:
            partition_info *part_info= Lex->part_info;
            if (part_info->num_columns < 2U)
            {
-              my_parse_error(ER_THD(thd, ER_ROW_SINGLE_PARTITION_FIELD_ERROR));
+              my_parse_error(thd, ER_ROW_SINGLE_PARTITION_FIELD_ERROR);
              MYSQL_YYABORT;
            }
          }
@@ -5383,7 +5391,7 @@ part_value_item:
                error.
              */
              part_info->print_debug("Kilroy I", NULL);
-              my_parse_error(ER_THD(thd, ER_PARTITION_COLUMN_LIST_ERROR));
+              my_parse_error(thd, ER_PARTITION_COLUMN_LIST_ERROR);
              MYSQL_YYABORT;
            }
            part_info->curr_list_object= 0;
@@ -5401,7 +5409,7 @@ part_value_expr_item:
            partition_info *part_info= Lex->part_info;
            if (part_info->part_type == LIST_PARTITION)
            {
-              my_parse_error(ER_THD(thd, ER_MAXVALUE_IN_VALUES_IN));
+              my_parse_error(thd, ER_MAXVALUE_IN_VALUES_IN);
              MYSQL_YYABORT;
            }
            if (part_info->add_max_value(thd))
@@ -5417,7 +5425,7 @@ part_value_expr_item:

            if (!lex->safe_to_cache_query)
            {
-              my_parse_error(ER_THD(thd, ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR));
+              my_parse_error(thd, ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR);
              MYSQL_YYABORT;
            }
            if (part_info->add_column_list_value(thd, part_expr))
@@ -5439,7 +5447,7 @@ opt_sub_partition:
                We come here when we have defined subpartitions on the first
                partition but not on all the subsequent partitions. 
              */
-              my_parse_error(ER_THD(thd, ER_PARTITION_WRONG_NO_SUBPART_ERROR));
+              my_parse_error(thd, ER_PARTITION_WRONG_NO_SUBPART_ERROR);
              MYSQL_YYABORT;
            }
          }
@@ -5451,7 +5459,7 @@ opt_sub_partition:
              if (part_info->num_subparts !=
                  part_info->count_curr_subparts)
              {
-                my_parse_error(ER_THD(thd, ER_PARTITION_WRONG_NO_SUBPART_ERROR));
+                my_parse_error(thd, ER_PARTITION_WRONG_NO_SUBPART_ERROR);
                MYSQL_YYABORT;
              }
            }
@@ -5459,7 +5467,7 @@ opt_sub_partition:
            {
              if (part_info->partitions.elements > 1)
              {
-                my_parse_error(ER_THD(thd, ER_PARTITION_WRONG_NO_SUBPART_ERROR));
+                my_parse_error(thd, ER_PARTITION_WRONG_NO_SUBPART_ERROR);
                MYSQL_YYABORT;
              }
              part_info->num_subparts= part_info->count_curr_subparts;
@@ -5478,7 +5486,8 @@ sub_part_definition:
          {
            partition_info *part_info= Lex->part_info;
            partition_element *curr_part= part_info->current_partition;
-            partition_element *sub_p_elem= new partition_element(curr_part);
+            partition_element *sub_p_elem= new (thd->mem_root)
+                                           partition_element(curr_part);
            if (part_info->use_default_subpartitions &&
                part_info->partitions.elements >= 2)
            {
@@ -5493,7 +5502,7 @@ sub_part_definition:
                the second partition (the current partition processed
                have already been put into the partitions list.
              */
-              my_parse_error(ER_THD(thd, ER_PARTITION_WRONG_NO_SUBPART_ERROR));
+              my_parse_error(thd, ER_PARTITION_WRONG_NO_SUBPART_ERROR);
              MYSQL_YYABORT;
            }
            if (!sub_p_elem ||
@@ -5703,7 +5712,7 @@ create_table_option:
                Lex->create_info.table_options|= HA_OPTION_PACK_KEYS;
                break;
            default:
-                my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+                my_parse_error(thd, ER_SYNTAX_ERROR);
                MYSQL_YYABORT;
            }
            Lex->create_info.used_fields|= HA_CREATE_USED_PACK_KEYS;
@@ -5724,7 +5733,7 @@ create_table_option:
                Lex->create_info.stats_auto_recalc= HA_STATS_AUTO_RECALC_ON;
                break;
            default:
-                my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+                my_parse_error(thd, ER_SYNTAX_ERROR);
                MYSQL_YYABORT;
            }
            Lex->create_info.used_fields|= HA_CREATE_USED_STATS_AUTO_RECALC;
@@ -5744,7 +5753,7 @@ create_table_option:
                Lex->create_info.table_options|= HA_OPTION_STATS_PERSISTENT;
                break;
            default:
-                my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+                my_parse_error(thd, ER_SYNTAX_ERROR);
                MYSQL_YYABORT;
            }
            Lex->create_info.used_fields|= HA_CREATE_USED_STATS_PERSISTENT;
@@ -5767,7 +5776,7 @@ create_table_option:
            we can store the higher bits from stats_sample_pages in .frm too. */
            if ($3 == 0 || $3 > 0xffff)
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
            Lex->create_info.stats_sample_pages=$3;
@@ -6057,23 +6066,25 @@ key_def:
        | opt_constraint FOREIGN KEY_SYM opt_if_not_exists opt_ident
          {
            if (Lex->check_add_key($4) ||
-               !(Lex->last_key= new Key(Key::MULTIPLE, $1.str ? $1 : $5,
-                                        HA_KEY_ALG_UNDEF, true, $4)))
+               !(Lex->last_key= (new (thd->mem_root)
+                                 Key(Key::MULTIPLE, $1.str ? $1 : $5,
+                                     HA_KEY_ALG_UNDEF, true, $4))))
              MYSQL_YYABORT;
            Lex->option_list= NULL;
          }
          '(' key_list ')' references
          {
            LEX *lex=Lex;
-            Key *key= new Foreign_key($5.str ? $5 : $1,
-                                      lex->last_key->columns,
-                                      $10->db,
-                                      $10->table,
-                                      lex->ref_list,
-                                      lex->fk_delete_opt,
-                                      lex->fk_update_opt,
-                                      lex->fk_match_option,
-                                      $4);
+            Key *key= (new (thd->mem_root)
+                       Foreign_key($5.str ? $5 : $1,
+                                   lex->last_key->columns,
+                                   $10->db,
+                                   $10->table,
+                                   lex->ref_list,
+                                   lex->fk_delete_opt,
+                                   lex->fk_update_opt,
+                                   lex->fk_match_option,
+                                    $4));
            if (key == NULL)
              MYSQL_YYABORT;
            /*
@@ -6112,7 +6123,7 @@ field_spec:
          field_ident
          {
            LEX *lex=Lex;
-            Create_field *f= new Create_field();
+            Create_field *f= new (thd->mem_root) Create_field();

            if (check_string_char_length(&$1, 0, NAME_CHAR_LEN,
                                         system_charset_info, 1))
@@ -6216,7 +6227,7 @@ parse_vcol_expr:
 virtual_column_func:
          remember_name expr remember_end
          {
-            Virtual_column_info *v= new Virtual_column_info();
+            Virtual_column_info *v= new (thd->mem_root) Virtual_column_info();
            if (!v)
            {
              mem_alloc_error(sizeof(Virtual_column_info));
@@ -6752,7 +6763,7 @@ ws_nweights:
        {
          if ($2 == 0)
          {
-            my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+            my_parse_error(thd, ER_SYNTAX_ERROR);
            MYSQL_YYABORT;
          }
        }
@@ -6840,14 +6851,14 @@ opt_ref_list:
 ref_list:
          ref_list ',' ident
          {
-            Key_part_spec *key= new Key_part_spec($3, 0);
+            Key_part_spec *key= new (thd->mem_root) Key_part_spec($3, 0);
            if (key == NULL)
              MYSQL_YYABORT;
            Lex->ref_list.push_back(key, thd->mem_root);
          }
        | ident
          {
-            Key_part_spec *key= new Key_part_spec($1, 0);
+            Key_part_spec *key= new (thd->mem_root) Key_part_spec($1, 0);
            if (key == NULL)
              MYSQL_YYABORT;
            LEX *lex= Lex;
@@ -7073,7 +7084,7 @@ key_list:
 key_part:
          ident
          {
-            $$= new Key_part_spec($1, 0);
+            $$= new (thd->mem_root) Key_part_spec($1, 0);
            if ($$ == NULL)
              MYSQL_YYABORT;
          }
@@ -7084,7 +7095,7 @@ key_part:
            {
              my_error(ER_KEY_PART_0, MYF(0), $1.str);
            }
-            $$= new Key_part_spec($1, (uint) key_part_len);
+            $$= new (thd->mem_root) Key_part_spec($1, (uint) key_part_len);
            if ($$ == NULL)
              MYSQL_YYABORT;
          }
@@ -7263,7 +7274,7 @@ alter:
          {
            if (!($7 || $8 || $9 || $10 || $11))
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
            /*
@@ -7489,7 +7500,7 @@ add_partition_rule:
          opt_no_write_to_binlog
          {
            LEX *lex= Lex;
-            lex->part_info= new partition_info();
+            lex->part_info= new (thd->mem_root) partition_info();
            if (!lex->part_info)
            {
              mem_alloc_error(sizeof(partition_info));
@@ -7521,7 +7532,7 @@ reorg_partition_rule:
          REORGANIZE_SYM PARTITION_SYM opt_no_write_to_binlog
          {
            LEX *lex= Lex;
-            lex->part_info= new partition_info();
+            lex->part_info= new (thd->mem_root) partition_info();
            if (!lex->part_info)
            {
              mem_alloc_error(sizeof(partition_info));
@@ -7614,7 +7625,8 @@ alter_list_item:
        | DROP opt_column opt_if_exists_table_element field_ident opt_restrict
          {
            LEX *lex=Lex;
-            Alter_drop *ad= new Alter_drop(Alter_drop::COLUMN, $4.str, $3);
+            Alter_drop *ad= (new (thd->mem_root)
+                             Alter_drop(Alter_drop::COLUMN, $4.str, $3));
            if (ad == NULL)
              MYSQL_YYABORT;
            lex->alter_info.drop_list.push_back(ad, thd->mem_root);
@@ -7623,7 +7635,8 @@ alter_list_item:
        | DROP FOREIGN KEY_SYM opt_if_exists_table_element field_ident
          {
            LEX *lex=Lex;
-            Alter_drop *ad= new Alter_drop(Alter_drop::FOREIGN_KEY, $5.str, $4);
+            Alter_drop *ad= (new (thd->mem_root)
+                             Alter_drop(Alter_drop::FOREIGN_KEY, $5.str, $4));
            if (ad == NULL)
              MYSQL_YYABORT;
            lex->alter_info.drop_list.push_back(ad, thd->mem_root);
@@ -7632,8 +7645,9 @@ alter_list_item:
        | DROP PRIMARY_SYM KEY_SYM
          {
            LEX *lex=Lex;
-            Alter_drop *ad= new Alter_drop(Alter_drop::KEY, primary_key_name,
-                                           FALSE);
+            Alter_drop *ad= (new (thd->mem_root)
+                             Alter_drop(Alter_drop::KEY, primary_key_name,
+                                        FALSE));
            if (ad == NULL)
              MYSQL_YYABORT;
            lex->alter_info.drop_list.push_back(ad, thd->mem_root);
@@ -7642,7 +7656,8 @@ alter_list_item:
        | DROP key_or_index opt_if_exists_table_element field_ident
          {
            LEX *lex=Lex;
-            Alter_drop *ad= new Alter_drop(Alter_drop::KEY, $4.str, $3);
+            Alter_drop *ad= (new (thd->mem_root)
+                             Alter_drop(Alter_drop::KEY, $4.str, $3));
            if (ad == NULL)
              MYSQL_YYABORT;
            lex->alter_info.drop_list.push_back(ad, thd->mem_root);
@@ -7663,7 +7678,7 @@ alter_list_item:
        | ALTER opt_column field_ident SET DEFAULT signed_literal
          {
            LEX *lex=Lex;
-            Alter_column *ac= new Alter_column($3.str,$6);
+            Alter_column *ac= new (thd->mem_root) Alter_column($3.str,$6);
            if (ac == NULL)
              MYSQL_YYABORT;
            lex->alter_info.alter_list.push_back(ac, thd->mem_root);
@@ -7672,7 +7687,8 @@ alter_list_item:
        | ALTER opt_column field_ident DROP DEFAULT
          {
            LEX *lex=Lex;
-            Alter_column *ac= new Alter_column($3.str, (Item*) 0);
+            Alter_column *ac= (new (thd->mem_root)
+                               Alter_column($3.str, (Item*) 0));
            if (ac == NULL)
              MYSQL_YYABORT;
            lex->alter_info.alter_list.push_back(ac, thd->mem_root);
@@ -7879,7 +7895,7 @@ start:
            if (($3 & MYSQL_START_TRANS_OPT_READ_WRITE) &&
                ($3 & MYSQL_START_TRANS_OPT_READ_ONLY))
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
            lex->start_transaction_opt= $3;
@@ -8081,7 +8097,7 @@ persistent_column_stat_spec:
        | '('
          { 
            LEX* lex= thd->lex;
-            lex->column_list= new List<LEX_STRING>;
+            lex->column_list= new (thd->mem_root) List<LEX_STRING>;
            if (lex->column_list == NULL)
              MYSQL_YYABORT;
          }
@@ -8094,7 +8110,7 @@ persistent_index_stat_spec:
        | '('
          { 
            LEX* lex= thd->lex;
-            lex->index_list= new List<LEX_STRING>;
+            lex->index_list= new (thd->mem_root) List<LEX_STRING>;
            if (lex->index_list == NULL)
              MYSQL_YYABORT;
          }
@@ -10064,7 +10080,7 @@ function_call_generic:
            {
              if (lex->current_select->inc_in_sum_expr())
              {
-                my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+                my_parse_error(thd, ER_SYNTAX_ERROR);
                MYSQL_YYABORT;
              }
            }
@@ -10407,7 +10423,7 @@ variable_aux:
            /* disallow "SELECT @@global.global.variable" */
            if ($3.str && $4.str && check_reserved_words(&$3))
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
            if (!($$= get_system_var(thd, $2, $3, $4)))
@@ -10463,7 +10479,7 @@ in_sum_expr:
            LEX *lex= Lex;
            if (lex->current_select->inc_in_sum_expr())
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
          }
@@ -10567,7 +10583,7 @@ opt_else:
 when_list:
          WHEN_SYM expr THEN_SYM expr
          {
-            $$= new List<Item>;
+            $$= new (thd->mem_root) List<Item>;
            if ($$ == NULL)
              MYSQL_YYABORT;
            $$->push_back($2, thd->mem_root);
@@ -10590,7 +10606,7 @@ table_ref:
            LEX *lex= Lex;
            if (!($$= lex->current_select->nest_last_join(lex->thd)))
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
          }
@@ -10808,7 +10824,7 @@ table_factor:
            {
              if (sel->set_braces(1))
              {
-                my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+                my_parse_error(thd, ER_SYNTAX_ERROR);
                MYSQL_YYABORT;
              }
            }
@@ -10858,7 +10874,7 @@ table_factor:
              SELECT_LEX *sel= lex->current_select;
              SELECT_LEX_UNIT *unit= sel->master_unit();
              lex->current_select= sel= unit->outer_select();
-              Table_ident *ti= new Table_ident(unit);
+              Table_ident *ti= new (thd->mem_root) Table_ident(unit);
              if (ti == NULL)
                MYSQL_YYABORT;
              if (!($$= sel->add_table_to_list(lex->thd,
@@ -10880,7 +10896,7 @@ table_factor:
                Tables with or without joins within parentheses cannot
                have aliases, and we ruled out derived tables above.
              */
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
            else
@@ -10916,7 +10932,7 @@ select_derived_union:
          {
            if ($1 && $2)
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
          }
@@ -10939,7 +10955,7 @@ select_derived_union:
          {
            if ($1 != NULL)
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
          }
@@ -10953,13 +10969,13 @@ select_init2_derived:
            SELECT_LEX * sel= lex->current_select;
            if (lex->current_select->set_braces(0))
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
            if (sel->linkage == UNION_TYPE &&
                sel->master_unit()->first_select()->braces)
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
          }
@@ -10999,7 +11015,7 @@ select_derived:
              MYSQL_YYABORT;
            if (!$3 && $$)
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
          }
@@ -11012,7 +11028,7 @@ select_derived2:
            if (!lex->expr_allows_subselect ||
                lex->sql_command == (int)SQLCOM_PURGE)
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
            if (lex->current_select->linkage == GLOBAL_OPTIONS_TYPE ||
@@ -11049,7 +11065,7 @@ select_derived_init:
            if (!sel->embedding || sel->end_nested_join(lex->thd))
            {
              /* we are not in parentheses */
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
            embedding= Select->embedding;
@@ -11127,7 +11143,7 @@ key_usage_list:
 using_list:
          ident
          {
-            if (!($$= new List<String>))
+            if (!($$= new (thd->mem_root) List<String>))
              MYSQL_YYABORT;
            String *s= new (thd->mem_root) String((const char *) $1.str,
                                                    $1.length,
@@ -11562,8 +11578,8 @@ delete_limit_clause:
            Lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_LIMIT);
            sel->explicit_limit= 1;
          }
-       | LIMIT ROWS_SYM EXAMINED_SYM { my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR)); MYSQL_YYABORT; }
-       | LIMIT limit_option ROWS_SYM EXAMINED_SYM { my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR)); MYSQL_YYABORT; }
+       | LIMIT ROWS_SYM EXAMINED_SYM { my_parse_error(thd, ER_SYNTAX_ERROR); MYSQL_YYABORT; }
+       | LIMIT limit_option ROWS_SYM EXAMINED_SYM { my_parse_error(thd, ER_SYNTAX_ERROR); MYSQL_YYABORT; }
        ;

 int_num:
@@ -11607,7 +11623,7 @@ real_ulonglong_num:

 dec_num_error:
          dec_num
-          { my_parse_error(ER_THD(thd, ER_ONLY_INTEGERS_ALLOWED)); }
+          { my_parse_error(thd, ER_ONLY_INTEGERS_ALLOWED); }
        ;

 dec_num:
@@ -11710,7 +11726,7 @@ select_var_ident: select_outvar
 select_outvar:
          '@' ident_or_text
          {
-            $$ = Lex->result ? new my_var_user($2) : NULL;
+            $$ = Lex->result ? new (thd->mem_root) my_var_user($2) : NULL;
          }
        | ident_or_text
          {
@@ -11721,8 +11737,10 @@ select_outvar:
              my_error(ER_SP_UNDECLARED_VAR, MYF(0), $1.str);
              MYSQL_YYABORT;
            }
-            $$ = Lex->result ? new my_var_sp($1, t->offset, t->type, Lex->sphead)
-                             : NULL;
+            $$ = Lex->result ? (new (thd->mem_root)
+                                my_var_sp($1, t->offset, t->type,
+                                          Lex->sphead)) :
+                                NULL;
          }
        ;

@@ -11758,7 +11776,7 @@ into_destination:
            if (!lex->describe)
            {
              lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-              if (!(lex->exchange= new sql_exchange($2.str,1)))
+              if (!(lex->exchange= new (thd->mem_root) sql_exchange($2.str,1)))
                MYSQL_YYABORT;
              if (!(lex->result=
                      new (thd->mem_root) select_dump(thd, lex->exchange)))
@@ -11805,7 +11823,8 @@ drop:
        | DROP INDEX_SYM opt_if_exists_table_element ident ON table_ident {}
          {
            LEX *lex=Lex;
-            Alter_drop *ad= new Alter_drop(Alter_drop::KEY, $4.str, $3);
+            Alter_drop *ad= (new (thd->mem_root)
+                             Alter_drop(Alter_drop::KEY, $4.str, $3));
            if (ad == NULL)
              MYSQL_YYABORT;
            lex->sql_command= SQLCOM_DROP_INDEX;
@@ -12324,7 +12343,7 @@ table_wild_list:
 table_wild_one:
          ident opt_wild
          {
-            Table_ident *ti= new Table_ident($1);
+            Table_ident *ti= new (thd->mem_root) Table_ident($1);
            if (ti == NULL)
              MYSQL_YYABORT;
            if (!Select->add_table_to_list(thd,
@@ -12337,7 +12356,7 @@ table_wild_one:
          }
        | ident '.' ident opt_wild
          {
-            Table_ident *ti= new Table_ident(thd, $1, $3, 0);
+            Table_ident *ti= new (thd->mem_root) Table_ident(thd, $1, $3, 0);
            if (ti == NULL)
              MYSQL_YYABORT;
            if (!Select->add_table_to_list(thd,
@@ -12766,12 +12785,12 @@ show_param:
             ST_SCHEMA_TABLE *table= find_schema_table(thd, $1.str);
             if (!table || !table->old_format)
             {
-               my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR), $2);
+               my_parse_error(thd, ER_SYNTAX_ERROR, $2);
               MYSQL_YYABORT;
             }
             if (lex->wild && table->idx_field1 < 0)
             {
-               my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR), $3);
+               my_parse_error(thd, ER_SYNTAX_ERROR, $3);
               MYSQL_YYABORT;
             }
             if (make_schema_select(thd, Lex->current_select, table))
@@ -12977,7 +12996,7 @@ flush_lock:
          {
            if (Lex->query_tables == NULL) // Table list can't be empty
            {
-              my_parse_error(ER_THD(thd, ER_NO_TABLES_USED));
+              my_parse_error(thd, ER_NO_TABLES_USED);
              MYSQL_YYABORT;
            } 
            Lex->type|= REFRESH_FOR_EXPORT;
@@ -13048,7 +13067,7 @@ flush_option:
             ST_SCHEMA_TABLE *table= find_schema_table(thd, $1.str);
             if (!table || !table->reset_table)
             {
-               my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR), $2);
+               my_parse_error(thd, ER_SYNTAX_ERROR, $2);
               MYSQL_YYABORT;
             }
             Lex->view_list.push_back((LEX_STRING*)
@@ -13218,7 +13237,7 @@ load:
            lex->local_file=  $5;
            lex->duplicates= DUP_ERROR;
            lex->ignore= 0;
-            if (!(lex->exchange= new sql_exchange($7.str, 0, $2)))
+            if (!(lex->exchange= new (thd->mem_root) sql_exchange($7.str, 0, $2)))
              MYSQL_YYABORT;
          }
          opt_duplicate INTO TABLE_SYM table_ident opt_use_partition
@@ -14713,7 +14732,7 @@ option_value_following_option_type:
                Not in trigger assigning value to new row,
                and option_type preceding local variable is illegal.
              */
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
          }
@@ -14753,7 +14772,7 @@ option_value_no_option_type:
            item= new (thd->mem_root) Item_func_set_user_var(thd, $2, $4);
            if (item == NULL)
              MYSQL_YYABORT;
-            set_var_user *var= new set_var_user(item);
+            set_var_user *var= new (thd->mem_root) set_var_user(item);
            if (var == NULL)
              MYSQL_YYABORT;
            Lex->var_list.push_back(var, thd->mem_root);
@@ -14776,9 +14795,10 @@ option_value_no_option_type:
            CHARSET_INFO *cs2;
            cs2= $2 ? $2: global_system_variables.character_set_client;
            set_var_collation_client *var;
-            var= new set_var_collation_client(cs2,
-                                              thd->variables.collation_database,
-                                              cs2);
+            var= (new (thd->mem_root)
+                  set_var_collation_client(cs2,
+                                           thd->variables.collation_database,
+                                            cs2));
            if (var == NULL)
              MYSQL_YYABORT;
            lex->var_list.push_back(var, thd->mem_root);
@@ -14794,7 +14814,7 @@ option_value_no_option_type:
            if (spc && spc->find_variable(names, false))
              my_error(ER_SP_BAD_VAR_SHADOW, MYF(0), names.str);
            else
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);

            MYSQL_YYABORT;
          }
@@ -14812,7 +14832,7 @@ option_value_no_option_type:
              MYSQL_YYABORT;
            }
            set_var_collation_client *var;
-            var= new set_var_collation_client(cs3, cs3, cs3);
+            var= new (thd->mem_root) set_var_collation_client(cs3, cs3, cs3);
            if (var == NULL)
              MYSQL_YYABORT;
            lex->var_list.push_back(var, thd->mem_root);
@@ -14824,8 +14844,9 @@ option_value_no_option_type:
            if (!(user=(LEX_USER *) thd->calloc(sizeof(LEX_USER))))
              MYSQL_YYABORT;
            user->user= current_user;
-            set_var_default_role *var= new set_var_default_role(user,
-                                                                $3->user);
+            set_var_default_role *var= (new (thd->mem_root)
+                                        set_var_default_role(user,
+                                                             $3->user));
            if (var == NULL)
              MYSQL_YYABORT;
            lex->var_list.push_back(var, thd->mem_root);
@@ -14836,7 +14857,8 @@ option_value_no_option_type:
        | DEFAULT ROLE_SYM grant_role FOR_SYM user
          {
            LEX *lex = Lex;
-            set_var_default_role *var= new set_var_default_role($5, $3->user);
+            set_var_default_role *var= (new (thd->mem_root)
+                                        set_var_default_role($5, $3->user));
            if (var == NULL)
              MYSQL_YYABORT;
            lex->var_list.push_back(var, thd->mem_root);
@@ -14847,7 +14869,7 @@ option_value_no_option_type:
        | ROLE_SYM ident_or_text
          {
            LEX *lex = Lex;
-            set_var_role *var= new set_var_role($2);
+            set_var_role *var= new (thd->mem_root) set_var_role($2);
            if (var == NULL)
              MYSQL_YYABORT;
            lex->var_list.push_back(var, thd->mem_root);
@@ -14855,7 +14877,8 @@ option_value_no_option_type:
        | PASSWORD_SYM opt_for_user text_or_password
          {
            LEX *lex = Lex;
-            set_var_password *var= new set_var_password(lex->definer);
+            set_var_password *var= (new (thd->mem_root)
+                                    set_var_password(lex->definer));
            if (var == NULL)
              MYSQL_YYABORT;
            lex->var_list.push_back(var, thd->mem_root);
@@ -14898,7 +14921,7 @@ internal_variable_name:
            LEX *lex= Lex;
            if (check_reserved_words(&$1))
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
            if (lex->sphead && lex->sphead->m_type == TYPE_ENUM_TRIGGER &&
@@ -14963,10 +14986,11 @@ transaction_access_mode:
            Item *item= new (thd->mem_root) Item_int(thd, (int32) $1);
            if (item == NULL)
              MYSQL_YYABORT;
-            set_var *var= new set_var(thd, lex->option_type,
-                                      find_sys_var(thd, "tx_read_only"),
-                                      &null_lex_str,
-                                      item);
+            set_var *var= (new (thd->mem_root)
+                           set_var(thd, lex->option_type,
+                                   find_sys_var(thd, "tx_read_only"),
+                                   &null_lex_str,
+                                   item));
            if (var == NULL)
              MYSQL_YYABORT;
            lex->var_list.push_back(var, thd->mem_root);
@@ -14980,10 +15004,11 @@ isolation_level:
            Item *item= new (thd->mem_root) Item_int(thd, (int32) $3);
            if (item == NULL)
              MYSQL_YYABORT;
-            set_var *var= new set_var(thd, lex->option_type,
-                                      find_sys_var(thd, "tx_isolation"),
-                                      &null_lex_str,
-                                      item);
+            set_var *var= (new (thd->mem_root)
+                           set_var(thd, lex->option_type,
+                                   find_sys_var(thd, "tx_isolation"),
+                                   &null_lex_str,
+                                   item));
            if (var == NULL)
              MYSQL_YYABORT;
            lex->var_list.push_back(var, thd->mem_root);
@@ -15211,7 +15236,7 @@ handler_rkey_function:
            LEX *lex=Lex;
            lex->ha_read_mode = RKEY;
            lex->ha_rkey_mode=$1;
-            if (!(lex->insert_list= new List_item))
+            if (!(lex->insert_list= new (thd->mem_root) List_item))
              MYSQL_YYABORT;
          }
          '(' values ')'
@@ -15245,7 +15270,7 @@ revoke_command:
            LEX *lex= Lex;
            if (lex->columns.elements)
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
            lex->sql_command= SQLCOM_REVOKE;
@@ -15256,7 +15281,7 @@ revoke_command:
            LEX *lex= Lex;
            if (lex->columns.elements)
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
            lex->sql_command= SQLCOM_REVOKE;
@@ -15307,7 +15332,7 @@ grant_command:
            LEX *lex= Lex;
            if (lex->columns.elements)
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
            lex->sql_command= SQLCOM_GRANT;
@@ -15319,7 +15344,7 @@ grant_command:
            LEX *lex= Lex;
            if (lex->columns.elements)
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
            lex->sql_command= SQLCOM_GRANT;
@@ -15665,7 +15690,8 @@ column_list_id:
              point->rights |= lex->which_columns;
            else
            {
-              LEX_COLUMN *col= new LEX_COLUMN (*new_str,lex->which_columns);
+              LEX_COLUMN *col= (new (thd->mem_root)
+                                LEX_COLUMN(*new_str,lex->which_columns));
              if (col == NULL)
                MYSQL_YYABORT;
              lex->columns.push_back(col, thd->mem_root);
@@ -15948,7 +15974,7 @@ subselect_start:
            if (!lex->expr_allows_subselect ||
               lex->sql_command == (int)SQLCOM_PURGE)
            {
-              my_parse_error(ER_THD(thd, ER_SYNTAX_ERROR));
+              my_parse_error(thd, ER_SYNTAX_ERROR);
              MYSQL_YYABORT;
            }
            /* 
@@ -16386,9 +16412,9 @@ sf_tail:
                - The user deploys 5.{N+1}. At this point, 'select foo()'
                means something different, and the user code is most likely
                broken (it's only safe if the code is 'select db.foo()').
-                With a warning printed when the SF is loaded (which has to occur
-                before the call), the warning will provide a hint explaining
-                the root cause of a later failure of 'select foo()'.
+                With a warning printed when the SF is loaded (which has to
+                occur before the call), the warning will provide a hint
+                explaining the root cause of a later failure of 'select foo()'.
                With no warning printed, the user code will fail with no
                apparent reason.
                Printing a warning each time db_load_routine is executed for
--- a/sql/unireg.cc
+++ b/sql/unireg.cc
@@ -583,14 +583,14 @@ static bool pack_header(THD *thd, uchar *forminfo,
          The HEX representation is created from this copy.
        */
        field->save_interval= field->interval;
-        field->interval= (TYPELIB*) sql_alloc(sizeof(TYPELIB));
+        field->interval= (TYPELIB*) thd->alloc(sizeof(TYPELIB));
        *field->interval= *field->save_interval; 
        field->interval->type_names= 
-          (const char **) sql_alloc(sizeof(char*) * 
-				    (field->interval->count+1));
+          (const char **) thd->alloc(sizeof(char*) * 
+                                     (field->interval->count+1));
        field->interval->type_names[field->interval->count]= 0;
        field->interval->type_lengths=
-          (uint *) sql_alloc(sizeof(uint) * field->interval->count);
+          (uint *) thd->alloc(sizeof(uint) * field->interval->count);
 
        for (uint pos= 0; pos < field->interval->count; pos++)
        {
@@ -600,8 +600,8 @@ static bool pack_header(THD *thd, uchar *forminfo,
          length= field->save_interval->type_lengths[pos];
          hex_length= length * 2;
          field->interval->type_lengths[pos]= hex_length;
-          field->interval->type_names[pos]= dst= (char*) sql_alloc(hex_length +
-                                                                   1);
+          field->interval->type_names[pos]= dst=
+            (char*) thd->alloc(hex_length + 1);
          octet2hex(dst, src, length);
        }
      }