- Renaming variables so that they don't shadow others (After this patch one can compile with -Wshadow and get much fewer warnings)

- Changed ER(ER_...) to ER_THD(thd, ER_...) when thd was known or if there was many calls to current_thd in the same function.
- Changed ER(ER_..) to ER_THD_OR_DEFAULT(current_thd, ER...) in some places where current_thd is not necessary defined.
- Removing calls to current_thd when we have access to thd

Part of this is optimization (not calling current_thd when not needed),
but part is bug fixing for error condition when current_thd is not defined
(For example on startup and end of mysqld)

Notable renames done as otherwise a lot of functions would have to be changed:
- In JOIN structure renamed:
   examined_rows -> join_examined_rows
   record_count -> join_record_count
- In Field, renamed new_field() to make_new_field()

Other things:
- Added DBUG_ASSERT(thd == tmp_thd) in Item_singlerow_subselect() just to be safe.
- Removed old 'tab' prefix in JOIN_TAB::save_explain_data() and use members directly
- Added 'thd' as argument to a few functions to avoid calling current_thd.

1 files changed, 202 insertions, 194 deletions

diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index da994538b6b..abd9d3123f5 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -383,7 +383,7 @@ bool handle_select(THD *thd, LEX *lex, select_result *result,
     */
     push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
                         ER_QUERY_EXCEEDED_ROWS_EXAMINED_LIMIT,
-                        ER(ER_QUERY_EXCEEDED_ROWS_EXAMINED_LIMIT),
+                        ER_THD(thd, ER_QUERY_EXCEEDED_ROWS_EXAMINED_LIMIT),
                         thd->accessed_rows_and_keys,
                         thd->lex->limit_rows_examined->val_uint());
     thd->reset_killed();
@@ -914,7 +914,7 @@ JOIN::prepare(Item ***rref_pointer_array,
       select_lex->agg_func_used())
   {
     my_message(ER_MIX_OF_GROUP_FUNC_AND_FIELDS,
-               ER(ER_MIX_OF_GROUP_FUNC_AND_FIELDS), MYF(0));
+               ER_THD(thd, ER_MIX_OF_GROUP_FUNC_AND_FIELDS), MYF(0));
     DBUG_RETURN(-1);
   }
   {
@@ -936,14 +936,14 @@ JOIN::prepare(Item ***rref_pointer_array,
     {
       if (!test_if_subpart(procedure->group,group_list))
       {						/* purecov: inspected */
-	my_message(ER_DIFF_GROUPS_PROC, ER(ER_DIFF_GROUPS_PROC),
+	my_message(ER_DIFF_GROUPS_PROC, ER_THD(thd, ER_DIFF_GROUPS_PROC),
                    MYF(0));                     /* purecov: inspected */
 	goto err;				/* purecov: inspected */
       }
     }
     if (order && (procedure->flags & PROC_NO_SORT))
     {						/* purecov: inspected */
-      my_message(ER_ORDER_WITH_PROC, ER(ER_ORDER_WITH_PROC),
+      my_message(ER_ORDER_WITH_PROC, ER_THD(thd, ER_ORDER_WITH_PROC),
                  MYF(0));                       /* purecov: inspected */
       goto err;					/* purecov: inspected */
     }
@@ -1001,7 +1001,7 @@ bool JOIN::prepare_stage2()
 #ifdef RESTRICTED_GROUP
   if (implicit_grouping)
   {
-    my_message(ER_WRONG_SUM_SELECT,ER(ER_WRONG_SUM_SELECT),MYF(0));
+    my_message(ER_WRONG_SUM_SELECT,ER_THD(thd, ER_WRONG_SUM_SELECT),MYF(0));
     goto err;
   }
 #endif
@@ -1064,6 +1064,7 @@ JOIN::optimize_inner()
 {
   ulonglong select_opts_for_readinfo;
   uint no_jbuf_after;
+  JOIN_TAB *tab;
   DBUG_ENTER("JOIN::optimize");
 
   do_send_rows = (unit->select_limit_cnt) ? 1 : 0;
@@ -1397,7 +1398,7 @@ TODO: make view to decide if it is possible to write to WHERE directly or make S
       best_read > (double) thd->variables.max_join_size &&
       !(select_options & SELECT_DESCRIBE))
   {						/* purecov: inspected */
-    my_message(ER_TOO_BIG_SELECT, ER(ER_TOO_BIG_SELECT), MYF(0));
+    my_message(ER_TOO_BIG_SELECT, ER_THD(thd, ER_TOO_BIG_SELECT), MYF(0));
     error= -1;
     DBUG_RETURN(1);
   }
@@ -1460,7 +1461,6 @@ TODO: make view to decide if it is possible to write to WHERE directly or make S
     Perform the optimization on fields evaluation mentioned above
     for all on expressions.
   */
-  JOIN_TAB *tab;
   for (tab= first_linear_tab(this, WITH_BUSH_ROOTS, WITHOUT_CONST_TABLES); tab;
        tab= next_linear_tab(this, tab, WITH_BUSH_ROOTS))
   {
@@ -1665,8 +1665,9 @@ TODO: make view to decide if it is possible to write to WHERE directly or make S
       because in this case we can just create a temporary table that
       holds LIMIT rows and stop when this table is full.
     */
-    JOIN_TAB *tab= &join_tab[const_tables];
     bool all_order_fields_used;
+
+    tab= &join_tab[const_tables];
     if (order)
     {
       skip_sort_order= test_if_skip_sort_order(tab, order, select_limit, 1, 
@@ -2158,11 +2159,11 @@ bool JOIN::setup_subquery_caches()
         thd->change_item_tree(li.ref(), new_item);
       }
     }
-    for (ORDER *group= group_list; group ; group= group->next)
+    for (ORDER *tmp_group= group_list; tmp_group ; tmp_group= tmp_group->next)
     {
-      *group->item=
-        (*group->item)->transform(&Item::expr_cache_insert_transformer,
-                                  (uchar*) thd);
+      *tmp_group->item=
+        (*tmp_group->item)->transform(&Item::expr_cache_insert_transformer,
+                                      (uchar*) thd);
     }
   }
   if (select_lex->expr_cache_may_be_used[NO_MATTER])
@@ -2575,11 +2576,11 @@ void JOIN::exec_inner()
     if (order && join_tab)
     {
       bool made_call= false;
-      SQL_SELECT *select= join_tab[const_tables].select;
+      SQL_SELECT *tmp_select= join_tab[const_tables].select;
       if ((order != group_list ||
            !(select_options & SELECT_BIG_RESULT) ||
-           (select && select->quick &&
-            select->quick->get_type() ==
+           (tmp_select && tmp_select->quick &&
+            tmp_select->quick->get_type() ==
             QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX)) &&
           (const_tables == table_count ||
            ((simple_order || skip_sort_order) &&
@@ -2624,7 +2625,7 @@ void JOIN::exec_inner()
     must be accumulated in examined_row_count. Hence every join
     iteration must count from zero.
   */
-  curr_join->examined_rows= 0;
+  curr_join->join_examined_rows= 0;
 
   /* Create a tmp table if distinct or if the sort is too complicated */
   if (need_tmp)
@@ -3121,7 +3122,7 @@ void JOIN::exec_inner()
   }
 
   /* Accumulate the counts from all join iterations of all join parts. */
-  thd->inc_examined_row_count(curr_join->examined_rows);
+  thd->inc_examined_row_count(curr_join->join_examined_rows);
   DBUG_PRINT("counts", ("thd->examined_row_count: %lu",
                         (ulong) thd->get_examined_row_count()));
 
@@ -3617,7 +3618,8 @@ make_join_statistics(JOIN *join, List<TABLE_LIST> &tables_list,
       if (s->dependent & s->table->map)
       {
         join->table_count=0;			// Don't use join->table
-        my_message(ER_WRONG_OUTER_JOIN, ER(ER_WRONG_OUTER_JOIN), MYF(0));
+        my_message(ER_WRONG_OUTER_JOIN,
+                   ER_THD(join->thd, ER_WRONG_OUTER_JOIN), MYF(0));
         goto error;
       }
       s->key_dependent= s->dependent;
@@ -4089,7 +4091,7 @@ make_join_statistics(JOIN *join, List<TABLE_LIST> &tables_list,
     {
       memcpy((uchar*) join->best_positions,(uchar*) join->positions,
 	     sizeof(POSITION)*join->const_tables);
-      join->record_count= 1.0;
+      join->join_record_count= 1.0;
       join->best_read=1.0;
     }
   
@@ -4124,10 +4126,10 @@ error:
     Dangling TABLE::reginfo.join_tab may cause part_of_refkey to choke. 
   */
   {    
-    TABLE_LIST *table;
-    List_iterator<TABLE_LIST> ti(tables_list);
-    while ((table= ti++))
-      table->table->reginfo.join_tab= NULL;
+    TABLE_LIST *tmp_table;
+    List_iterator<TABLE_LIST> ti2(tables_list);
+    while ((tmp_table= ti2++))
+      tmp_table->table->reginfo.join_tab= NULL;
   }
   DBUG_RETURN (1);
 }
@@ -4838,9 +4840,9 @@ Item_equal::add_key_fields(JOIN *join, KEY_FIELD **key_fields,
                            uint *and_level, table_map usable_tables,
                            SARGABLE_PARAM **sargables)
 {
-  Item *const_item= get_const();
+  Item *const_item2= get_const();
   Item_equal_fields_iterator it(*this);
-  if (const_item)
+  if (const_item2)
   {
     
     /*
@@ -4852,7 +4854,7 @@ Item_equal::add_key_fields(JOIN *join, KEY_FIELD **key_fields,
     {
       Field *equal_field= it.get_curr_field();
       add_key_field(join, key_fields, *and_level, this, equal_field,
-                    TRUE, &const_item, 1, usable_tables, sargables);
+                    TRUE, &const_item2, 1, usable_tables, sargables);
     }
   }
   else 
@@ -5950,7 +5952,6 @@ best_access_path(JOIN      *join,
             }
             else
             {
-              uint key_parts= table->actual_n_key_parts(keyinfo);
               if (!(records= keyinfo->actual_rec_per_key(key_parts-1)))
               {                                   /* Prefer longer keys */
                 records=
@@ -6875,7 +6876,7 @@ optimize_straight_join(JOIN *join, table_map join_tables)
     read_time+= record_count;  // We have to make a temp table
   memcpy((uchar*) join->best_positions, (uchar*) join->positions,
          sizeof(POSITION)*idx);
-  join->record_count= record_count;
+  join->join_record_count= record_count;
   join->best_read= read_time - 0.001;
 }
 
@@ -7279,7 +7280,6 @@ double table_multi_eq_cond_selectivity(JOIN *join, uint idx, JOIN_TAB *s,
     if (item_equal->get_const())
       continue;
 
-    Field *fld;
     bool adjust_sel= FALSE;
     Item_equal_fields_iterator fi(*item_equal);
     while((fi++) && !adjust_sel)
@@ -7345,7 +7345,7 @@ double table_multi_eq_cond_selectivity(JOIN *join, uint idx, JOIN_TAB *s,
       while ((fi++))
       {
         double curr_eq_fld_sel;
-        fld= fi.get_curr_field();
+        Field *fld= fi.get_curr_field();
         if (!fld->table->map & ~(table_bit | rem_tables))
           continue;
         curr_eq_fld_sel= get_column_avg_frequency(fld) /
@@ -7857,7 +7857,7 @@ best_extension_by_limited_search(JOIN      *join,
         {
           memcpy((uchar*) join->best_positions, (uchar*) join->positions,
                  sizeof(POSITION) * (idx + 1));
-          join->record_count= partial_join_cardinality;
+          join->join_record_count= partial_join_cardinality;
           join->best_read= current_read_time - 0.001;
         }
         DBUG_EXECUTE("opt", print_plan(join, idx+1,
@@ -9393,7 +9393,8 @@ make_outerjoin_info(JOIN *join)
     }
   }
 
-  for (JOIN_TAB *tab= first_linear_tab(join, WITH_BUSH_ROOTS, WITHOUT_CONST_TABLES); tab; 
+  for (tab= first_linear_tab(join, WITH_BUSH_ROOTS, WITHOUT_CONST_TABLES);
+       tab; 
        tab= next_linear_tab(join, tab, WITH_BUSH_ROOTS))
   {
     TABLE *table= tab->table;
@@ -9684,10 +9685,11 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
             Because of QUICK_GROUP_MIN_MAX_SELECT there may be a select without
             a cond, so neutralize the hack above.
           */
-          if (!(tmp= add_found_match_trig_cond(first_inner_tab, tmp, 0)))
+          COND *tmp_cond;
+          if (!(tmp_cond= add_found_match_trig_cond(first_inner_tab, tmp, 0)))
             DBUG_RETURN(1);
-          sel->cond= tmp;
-          tab->set_select_cond(tmp, __LINE__);
+          sel->cond= tmp_cond;
+          tab->set_select_cond(tmp_cond, __LINE__);
           /* Push condition to storage engine if this is enabled
              and the condition is not guarded */
           if (tab->table)
@@ -9698,7 +9700,7 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
                 !first_inner_tab)
             {
               COND *push_cond= 
-              make_cond_for_table(thd, tmp, current_map, current_map,
+              make_cond_for_table(thd, tmp_cond, current_map, current_map,
                                   -1, FALSE, FALSE);
               if (push_cond)
               {
@@ -9883,17 +9885,18 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
         if (*join_tab->on_expr_ref)
         {
           JOIN_TAB *cond_tab= join_tab->first_inner;
-          COND *tmp= make_cond_for_table(thd, *join_tab->on_expr_ref,
-                                         join->const_table_map,
-                                         (table_map) 0, -1, FALSE, FALSE);
-          if (!tmp)
+          COND *tmp_cond= make_cond_for_table(thd, *join_tab->on_expr_ref,
+                                              join->const_table_map,
+                                              (table_map) 0, -1, FALSE, FALSE);
+          if (!tmp_cond)
             continue;
-          tmp= new Item_func_trig_cond(tmp, &cond_tab->not_null_compl);
-          if (!tmp)
+          tmp_cond= new Item_func_trig_cond(tmp_cond, &cond_tab->not_null_compl);
+          if (!tmp_cond)
             DBUG_RETURN(1);
-          tmp->quick_fix_field();
-          cond_tab->select_cond= !cond_tab->select_cond ? tmp :
-	                            new Item_cond_and(cond_tab->select_cond,tmp);
+          tmp_cond->quick_fix_field();
+          cond_tab->select_cond= !cond_tab->select_cond ? tmp_cond :
+	                            new Item_cond_and(cond_tab->select_cond,
+                                                      tmp_cond);
           if (!cond_tab->select_cond)
 	    DBUG_RETURN(1);
           cond_tab->select_cond->quick_fix_field();
@@ -9925,23 +9928,26 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
         start_from= tab->bush_root_tab? 
                       tab->bush_root_tab->bush_children->start : 
                       join->join_tab + join->const_tables;
-        for (JOIN_TAB *tab= start_from; tab <= last_tab; tab++)
+        for (JOIN_TAB *inner_tab= start_from;
+             inner_tab <= last_tab;
+             inner_tab++)
         {
-          DBUG_ASSERT(tab->table);
-          current_map= tab->table->map;
+          DBUG_ASSERT(inner_tab->table);
+          current_map= inner_tab->table->map;
           used_tables2|= current_map;
           /*
             psergey: have put the -1 below. It's bad, will need to fix it.
           */
           COND *tmp_cond= make_cond_for_table(thd, on_expr, used_tables2,
-                                              current_map, /*(tab - first_tab)*/ -1,
+                                              current_map,
+                                              /*(inner_tab - first_tab)*/ -1,
 					      FALSE, FALSE);
           bool is_sjm_lookup_tab= FALSE;
-          if (tab->bush_children)
+          if (inner_tab->bush_children)
           {
             /*
-              'tab' is an SJ-Materialization tab, i.e. we have a join order 
-              like this:
+              'inner_tab' is an SJ-Materialization tab, i.e. we have a join
+              order like this:
 
                 ot1 sjm_tab LEFT JOIN ot2 ot3
                          ^          ^
@@ -9961,19 +9967,21 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
               would be true anyway.
             */
             SJ_MATERIALIZATION_INFO *sjm=
-              tab->bush_children->start->emb_sj_nest->sj_mat_info;
+              inner_tab->bush_children->start->emb_sj_nest->sj_mat_info;
             if (sjm->is_used && !sjm->is_sj_scan)
               is_sjm_lookup_tab= TRUE;
           }
 
-          if (tab == first_inner_tab && tab->on_precond && !is_sjm_lookup_tab)
-            add_cond_and_fix(thd, &tmp_cond, tab->on_precond);
+          if (inner_tab == first_inner_tab && inner_tab->on_precond &&
+              !is_sjm_lookup_tab)
+            add_cond_and_fix(thd, &tmp_cond, inner_tab->on_precond);
           if (tmp_cond && !is_sjm_lookup_tab)
           {
-            JOIN_TAB *cond_tab= tab < first_inner_tab ? first_inner_tab : tab;
-            Item **sel_cond_ref= tab < first_inner_tab ?
-                                   &first_inner_tab->on_precond :
-                                   &tab->select_cond;
+            JOIN_TAB *cond_tab=  (inner_tab < first_inner_tab ?
+                                  first_inner_tab : inner_tab);
+            Item **sel_cond_ref= (inner_tab < first_inner_tab ?
+                                  &first_inner_tab->on_precond :
+                                  &inner_tab->select_cond);
             /*
               First add the guards for match variables of
               all embedding outer join operations.
@@ -10201,21 +10209,21 @@ void JOIN::drop_unused_derived_keys()
        tab= next_linear_tab(this, tab, WITH_BUSH_ROOTS))
   {
     
-    TABLE *table=tab->table;
-    if (!table)
+    TABLE *tmp_tbl= tab->table;
+    if (!tmp_tbl)
       continue;
-    if (!table->pos_in_table_list->is_materialized_derived())
+    if (!tmp_tbl->pos_in_table_list->is_materialized_derived())
       continue;
-    if (table->max_keys > 1)
-      table->use_index(tab->ref.key);
-    if (table->s->keys)
+    if (tmp_tbl->max_keys > 1)
+      tmp_tbl->use_index(tab->ref.key);
+    if (tmp_tbl->s->keys)
     {
       if (tab->ref.key >= 0)
         tab->ref.key= 0;
       else
-        table->s->keys= 0;
+        tmp_tbl->s->keys= 0;
     }
-    tab->keys= (key_map) (table->s->keys ? 1 : 0);
+    tab->keys= (key_map) (tmp_tbl->s->keys ? 1 : 0);
   }
 }
 
@@ -10994,17 +11002,17 @@ void JOIN_TAB::remove_redundant_bnl_scan_conds()
       Item *scan_item;
       while ((pushed_item= pushed_cond_li++))
       {
-        bool found= false;
+        bool found_cond= false;
         scan_cond_li.rewind();
         while ((scan_item= scan_cond_li++))
         {
           if (pushed_item->eq(scan_item, 0))
           {
-            found= true;
+            found_cond= true;
             break;
           }
         }
-        if (!found)
+        if (!found_cond)
           reduced_select_cond->add(pushed_item);
       }
     }
@@ -11381,7 +11389,8 @@ bool error_if_full_join(JOIN *join)
     if (tab->type == JT_ALL && (!tab->select || !tab->select->quick))
     {
       my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
-                 ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
+                 ER_THD(join->thd,
+                        ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
       return(1);
     }
   }
@@ -12849,9 +12858,9 @@ COND *Item_cond_and::build_equal_items(THD *thd,
   cond_equal.upper_levels= inherited;
 
   List<Item> eq_list;
-  List<Item> *args= argument_list();
+  List<Item> *cond_args= argument_list();
   
-  List_iterator<Item> li(*args);
+  List_iterator<Item> li(*cond_args);
   Item *item;
 
   DBUG_ASSERT(!cond_equal_ref || !cond_equal_ref[0]);
@@ -12876,7 +12885,7 @@ COND *Item_cond_and::build_equal_items(THD *thd,
     Check if we eliminated all the predicates of the level, e.g.
     (a=a AND b=b AND a=a).
   */
-  if (!args->elements && 
+  if (!cond_args->elements && 
       !cond_equal.current_level.elements && 
       !eq_list.elements)
     return new (thd->mem_root) Item_int((longlong) 1, 1);
@@ -12909,14 +12918,14 @@ COND *Item_cond_and::build_equal_items(THD *thd,
       /* This replacement happens only for standalone equalities */
       /*
         This is ok with PS/SP as the replacement is done for
-        arguments of an AND/OR item, which are restored for each
+        cond_args of an AND/OR item, which are restored for each
         execution of PS/SP.
       */
       li.replace(new_item);
     }
   }
-  args->append(&eq_list);
-  args->append((List<Item> *)&cond_equal.current_level);
+  cond_args->append(&eq_list);
+  cond_args->append((List<Item> *)&cond_equal.current_level);
   update_used_tables();
   if (cond_equal_ref)
     *cond_equal_ref= &m_cond_equal;
@@ -12929,9 +12938,9 @@ COND *Item_cond::build_equal_items(THD *thd,
                                    bool link_item_fields,
                                    COND_EQUAL **cond_equal_ref)
 {
-  List<Item> *args= argument_list();
+  List<Item> *cond_args= argument_list();
   
-  List_iterator<Item> li(*args);
+  List_iterator<Item> li(*cond_args);
   Item *item;
 
   DBUG_ASSERT(!cond_equal_ref || !cond_equal_ref[0]);
@@ -13014,7 +13023,7 @@ COND *Item_func_eq::build_equal_items(THD *thd,
       */
       Item_cond_and *and_cond= new Item_cond_and(eq_list);
       and_cond->quick_fix_field();
-      List<Item> *args= and_cond->argument_list();
+      List<Item> *cond_args= and_cond->argument_list();
       List_iterator_fast<Item_equal> it(cond_equal.current_level);
       while ((item_equal= it++))
       {
@@ -13025,7 +13034,7 @@ COND *Item_func_eq::build_equal_items(THD *thd,
       }
       and_cond->m_cond_equal.copy(cond_equal);
       cond_equal.current_level= and_cond->m_cond_equal.current_level;
-      args->append((List<Item> *)&cond_equal.current_level);
+      cond_args->append((List<Item> *)&cond_equal.current_level);
       and_cond->update_used_tables();
       if (cond_equal_ref)
         *cond_equal_ref= &and_cond->m_cond_equal;
@@ -13789,14 +13798,14 @@ static void update_const_equal_items(THD *thd, COND *cond, JOIN_TAB *tab,
         */  
         if (!possible_keys.is_clear_all())
         {
-          TABLE *tab= field->table;
+          TABLE *field_tab= field->table;
           KEYUSE *use;
-          for (use= stat->keyuse; use && use->table == tab; use++)
+          for (use= stat->keyuse; use && use->table == field_tab; use++)
             if (const_key &&
                 !use->is_for_hash_join() && possible_keys.is_set(use->key) && 
-                tab->key_info[use->key].key_part[use->keypart].field ==
+                field_tab->key_info[use->key].key_part[use->keypart].field ==
                 field)
-              tab->const_key_parts[use->key]|= use->keypart_map;
+              field_tab->const_key_parts[use->key]|= use->keypart_map;
         }
       }
     }
@@ -15023,7 +15032,7 @@ bool cond_is_datetime_is_null(Item *cond)
 
 COND *
 Item_cond::remove_eq_conds(THD *thd, Item::cond_result *cond_value,
-                           bool top_level)
+                           bool top_level_arg)
 {
   bool and_level= functype() == Item_func::COND_AND_FUNC;
   List<Item> *cond_arg_list= argument_list();
@@ -15237,7 +15246,7 @@ Item_cond::remove_eq_conds(THD *thd, Item::cond_result *cond_value,
 
 
 COND *
-Item::remove_eq_conds(THD *thd, Item::cond_result *cond_value, bool top_level)
+Item::remove_eq_conds(THD *thd, Item::cond_result *cond_value, bool top_level_arg)
 {
   if (const_item() && !is_expensive())
   {
@@ -15251,7 +15260,7 @@ Item::remove_eq_conds(THD *thd, Item::cond_result *cond_value, bool top_level)
 
 COND *
 Item_bool_func2::remove_eq_conds(THD *thd, Item::cond_result *cond_value,
-                                 bool top_level)
+                                 bool top_level_arg)
 {
   if (const_item() && !is_expensive())
   {
@@ -15293,7 +15302,7 @@ Item_bool_func2::remove_eq_conds(THD *thd, Item::cond_result *cond_value,
 
 COND *
 Item_func_isnull::remove_eq_conds(THD *thd, Item::cond_result *cond_value,
-                                  bool top_level)
+                                  bool top_level_arg)
 {
   if (args[0]->type() == Item::FIELD_ITEM)
   {
@@ -15367,7 +15376,7 @@ Item_func_isnull::remove_eq_conds(THD *thd, Item::cond_result *cond_value,
         WHERE auto_increment IS NULL AND something_else
     */
 
-    if (top_level) // "auto_increment_column IS NULL" is the only condition
+    if (top_level_arg) // "auto_increment_column IS NULL" is the only condition
     {
       if (field->flags & AUTO_INCREMENT_FLAG && !field->table->maybe_null &&
           (thd->variables.option_bits & OPTION_AUTO_IS_NULL) &&
@@ -15402,7 +15411,7 @@ Item_func_isnull::remove_eq_conds(THD *thd, Item::cond_result *cond_value,
       }
     }
   }
-  return Item::remove_eq_conds(thd, cond_value, top_level);
+  return Item::remove_eq_conds(thd, cond_value, top_level_arg);
 }
 
 
@@ -15583,8 +15592,8 @@ Field *create_tmp_field_from_field(THD *thd, Field *org_field,
                                    org_field->field_name, table->s,
                                    org_field->charset());
   else
-    new_field= org_field->new_field(thd->mem_root, table,
-                                    table == org_field->table);
+    new_field= org_field->make_new_field(thd->mem_root, table,
+                                         table == org_field->table);
   if (new_field)
   {
     new_field->init(table);
@@ -17678,8 +17687,8 @@ do_select(JOIN *join,List<Item> *fields,TABLE *table,Procedure *procedure)
         here.  join->send_records is increased on success in end_send(),
         so we don't touch it here.
       */
-      join->examined_rows++;
-      DBUG_ASSERT(join->examined_rows <= 1);
+      join->join_examined_rows++;
+      DBUG_ASSERT(join->join_examined_rows <= 1);
     }
     else if (join->send_row_on_empty_set())
     {
@@ -18272,9 +18281,9 @@ evaluate_join_record(JOIN *join, JOIN_TAB *join_tab,
       of the newly activated predicates is evaluated as false
       (See above join->return_tab= tab).
     */
-    join->examined_rows++;
+    join->join_examined_rows++;
     DBUG_PRINT("counts", ("join->examined_rows++: %lu  found: %d",
-                          (ulong) join->examined_rows, (int) found));
+                          (ulong) join->join_examined_rows, (int) found));
 
     if (found)
     {
@@ -18309,7 +18318,7 @@ evaluate_join_record(JOIN *join, JOIN_TAB *join_tab,
       The condition pushed down to the table join_tab rejects all rows
       with the beginning coinciding with the current partial join.
     */
-    join->examined_rows++;
+    join->join_examined_rows++;
     join->thd->get_stmt_da()->inc_current_row_for_warning();
     join_tab->read_record.unlock_row(join_tab);
   }
@@ -20697,11 +20706,11 @@ test_if_skip_sort_order(JOIN_TAB *tab,ORDER *order,ha_rows select_limit,
     if (select && // psergey:  why doesn't this use a quick?
         table->quick_keys.is_set(best_key) && best_key != ref_key)
     {
-      key_map map;
-      map.clear_all();       // Force the creation of quick select
-      map.set_bit(best_key); // only best_key.
+      key_map tmp_map;
+      tmp_map.clear_all();       // Force the creation of quick select
+      tmp_map.set_bit(best_key); // only best_key.
       select->quick= 0;
-      select->test_quick_select(join->thd, map, 0,
+      select->test_quick_select(join->thd, tmp_map, 0,
                                 join->select_options & OPTION_FOUND_ROWS ?
                                 HA_POS_ERROR :
                                 join->unit->select_limit_cnt,
@@ -21125,7 +21134,7 @@ create_sort_index(THD *thd, JOIN *join, ORDER *order,
   if (err)
     goto err;
 
-  tab->join->examined_rows+=examined_rows;
+  tab->join->join_examined_rows+= examined_rows;
   DBUG_RETURN(filesort_retval == HA_POS_ERROR);
 err:
   DBUG_RETURN(-1);
@@ -21307,7 +21316,8 @@ static int remove_dup_with_compare(THD *thd, TABLE *table, Field **first_field,
     }
     if (copy_blobs(first_field))
     {
-      my_message(ER_OUTOFMEMORY, ER(ER_OUTOFMEMORY), MYF(ME_FATALERROR));
+      my_message(ER_OUTOFMEMORY, ER_THD(thd,ER_OUTOFMEMORY),
+                 MYF(ME_FATALERROR));
       error=0;
       goto err;
     }
@@ -21725,9 +21735,9 @@ find_order_in_list(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
       */
       push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
                           ER_NON_UNIQ_ERROR,
-                          ER(ER_NON_UNIQ_ERROR),
+                          ER_THD(thd, ER_NON_UNIQ_ERROR),
                           ((Item_ident*) order_item)->field_name,
-                          current_thd->where);
+                          thd->where);
     }
   }
 
@@ -22451,7 +22461,8 @@ setup_copy_fields(THD *thd, TMP_TABLE_PARAM *param,
 	   saved value
 	*/
 	field= item->field;
-	item->result_field=field->new_field(thd->mem_root,field->table, 1);
+	item->result_field=field->make_new_field(thd->mem_root,
+                                                 field->table, 1);
         /*
           We need to allocate one extra byte for null handling and
           another extra byte to not get warnings from purify in
@@ -23609,35 +23620,31 @@ void JOIN_TAB::update_explain_data(uint idx)
 }
 
 
-void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tables, 
+void JOIN_TAB::save_explain_data(Explain_table_access *eta,
+                                 table_map prefix_tables, 
                                  bool distinct, JOIN_TAB *first_top_tab)
 {
   int quick_type;
   CHARSET_INFO *cs= system_charset_info;
-
-  JOIN_TAB *tab= this;
-  THD *thd=join->thd;
-
-  TABLE *table=tab->table;
-  TABLE_LIST *table_list= tab->table->pos_in_table_list;
+  THD *thd=      join->thd;
+  TABLE_LIST *table_list= table->pos_in_table_list;
+  QUICK_SELECT_I *cur_quick= NULL;
   my_bool key_read;
   char table_name_buffer[SAFE_NAME_LEN];
   KEY *key_info= 0;
   uint key_len= 0;
   quick_type= -1;
-  QUICK_SELECT_I *quick= NULL;
-
 
   explain_plan= eta;
   eta->key.clear();
   eta->quick_info= NULL;
   
-  tab->tracker= &eta->tracker;
-  tab->jbuf_tracker= &eta->jbuf_tracker;
+  tracker= &eta->tracker;
+  jbuf_tracker= &eta->jbuf_tracker;
 
   /* Enable the table access time tracker only for "ANALYZE stmt" */
   if (thd->lex->analyze_stmt)
-    tab->table->file->set_time_tracker(&eta->op_tracker);
+    table->file->set_time_tracker(&eta->op_tracker);
 
   /* No need to save id and select_type here, they are kept in Explain_select */
 
@@ -23650,9 +23657,9 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
                          table->derived_select_number);
     eta->table_name.copy(table_name_buffer, len, cs);
   }
-  else if (tab->bush_children)
+  else if (bush_children)
   {
-    JOIN_TAB *ctab= tab->bush_children->start;
+    JOIN_TAB *ctab= bush_children->start;
     /* table */
     int len= my_snprintf(table_name_buffer, 
                          sizeof(table_name_buffer)-1,
@@ -23706,19 +23713,19 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
   }
 
   /* "type" column */
-  enum join_type tab_type= tab->type;
-  if ((tab->type == JT_ALL || tab->type == JT_HASH) &&
-       tab->select && tab->select->quick && tab->use_quick != 2)
+  enum join_type tab_type= type;
+  if ((type == JT_ALL || type == JT_HASH) &&
+       select && select->quick && use_quick != 2)
   {
-    quick= tab->select->quick;
-    quick_type= tab->select->quick->get_type();
+    cur_quick= select->quick;
+    quick_type= cur_quick->get_type();
     if ((quick_type == QUICK_SELECT_I::QS_TYPE_INDEX_MERGE) ||
         (quick_type == QUICK_SELECT_I::QS_TYPE_INDEX_INTERSECT) ||
         (quick_type == QUICK_SELECT_I::QS_TYPE_ROR_INTERSECT) ||
         (quick_type == QUICK_SELECT_I::QS_TYPE_ROR_UNION))
-      tab_type= tab->type == JT_ALL ? JT_INDEX_MERGE : JT_HASH_INDEX_MERGE;
+      tab_type= type == JT_ALL ? JT_INDEX_MERGE : JT_HASH_INDEX_MERGE;
     else
-      tab_type= tab->type == JT_ALL ? JT_RANGE : JT_HASH_RANGE;
+      tab_type= type == JT_ALL ? JT_RANGE : JT_HASH_RANGE;
   }
   eta->type= tab_type;
 
@@ -23726,45 +23733,45 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
   // psergey-todo: why does this use thd MEM_ROOT??? Doesn't this 
   // break ANALYZE ? thd->mem_root will be freed, and after that we will
   // attempt to print the query plan?
-  append_possible_keys(thd->mem_root, eta->possible_keys, table, tab->keys);
+  append_possible_keys(thd->mem_root, eta->possible_keys, table, keys);
   // psergey-todo: ^ check for error return code 
 
   /* Build "key", "key_len", and "ref" */
   if (tab_type == JT_NEXT)
   {
-    key_info= table->key_info+tab->index;
+    key_info= table->key_info+index;
     key_len= key_info->key_length;
   }
-  else if (tab->ref.key_parts)
+  else if (ref.key_parts)
   {
-    key_info= tab->get_keyinfo_by_key_no(tab->ref.key);
-    key_len= tab->ref.key_length;
+    key_info= get_keyinfo_by_key_no(ref.key);
+    key_len= ref.key_length;
   }
   
   /*
     In STRAIGHT_JOIN queries, there can be join tabs with JT_CONST type
     that still have quick selects.
   */
-  if (tab->select && tab->select->quick && tab_type != JT_CONST)
+  if (select && select->quick && tab_type != JT_CONST)
   {
-    eta->quick_info= tab->select->quick->get_explain(thd->mem_root);
+    eta->quick_info= select->quick->get_explain(thd->mem_root);
   }
 
   if (key_info) /* 'index' or 'ref' access */
   {
     eta->key.set(thd->mem_root, key_info, key_len);
 
-    if (tab->ref.key_parts && tab_type != JT_FT)
+    if (ref.key_parts && tab_type != JT_FT)
     {
-      store_key **ref=tab->ref.key_copy;
-      for (uint kp= 0; kp < tab->ref.key_parts; kp++)
+      store_key **key_ref= ref.key_copy;
+      for (uint kp= 0; kp < ref.key_parts; kp++)
       {
-        if ((key_part_map(1) << kp) & tab->ref.const_ref_part_map)
+        if ((key_part_map(1) << kp) & ref.const_ref_part_map)
           eta->ref_list.append_str(thd->mem_root, "const");
         else
         {
-          eta->ref_list.append_str(thd->mem_root, (*ref)->name());
-          ref++;
+          eta->ref_list.append_str(thd->mem_root, (*key_ref)->name());
+          key_ref++;
         }
       }
     }
@@ -23773,8 +23780,8 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
   if (tab_type == JT_HASH_NEXT) /* full index scan + hash join */
   {
     eta->hash_next_key.set(thd->mem_root, 
-                           & table->key_info[tab->index], 
-                           table->key_info[tab->index].key_length);
+                           & table->key_info[index], 
+                           table->key_info[index].key_length);
     // psergey-todo: ^ is the above correct? are we necessarily joining on all
     // columns?
   }
@@ -23824,7 +23831,7 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
   }
   else
   {
-    double examined_rows= tab->get_examined_rows();
+    double examined_rows= get_examined_rows();
 
     eta->rows_set= true;
     eta->rows= (ha_rows) examined_rows;
@@ -23833,9 +23840,9 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
     float f= 0.0; 
     if (examined_rows)
     {
-      double pushdown_cond_selectivity= tab->cond_selectivity;	      
+      double pushdown_cond_selectivity= cond_selectivity;
       if (pushdown_cond_selectivity == 1.0)
-        f= (float) (100.0 * tab->records_read / examined_rows);
+        f= (float) (100.0 * records_read / examined_rows);
       else
         f= (float) (100.0 * pushdown_cond_selectivity);
     }
@@ -23847,32 +23854,32 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
   /* Build "Extra" field and save it */
   key_read=table->key_read;
   if ((tab_type == JT_NEXT || tab_type == JT_CONST) &&
-      table->covering_keys.is_set(tab->index))
+      table->covering_keys.is_set(index))
     key_read=1;
   if (quick_type == QUICK_SELECT_I::QS_TYPE_ROR_INTERSECT &&
-      !((QUICK_ROR_INTERSECT_SELECT*)quick)->need_to_fetch_row)
+      !((QUICK_ROR_INTERSECT_SELECT*)cur_quick)->need_to_fetch_row)
     key_read=1;
     
-  if (tab->info)
+  if (info)
   {
-    eta->push_extra(tab->info);
+    eta->push_extra(info);
   }
-  else if (tab->packed_info & TAB_INFO_HAVE_VALUE)
+  else if (packed_info & TAB_INFO_HAVE_VALUE)
   {
-    if (tab->packed_info & TAB_INFO_USING_INDEX)
+    if (packed_info & TAB_INFO_USING_INDEX)
       eta->push_extra(ET_USING_INDEX);
-    if (tab->packed_info & TAB_INFO_USING_WHERE)
+    if (packed_info & TAB_INFO_USING_WHERE)
       eta->push_extra(ET_USING_WHERE);
-    if (tab->packed_info & TAB_INFO_FULL_SCAN_ON_NULL)
+    if (packed_info & TAB_INFO_FULL_SCAN_ON_NULL)
       eta->push_extra(ET_FULL_SCAN_ON_NULL_KEY);
   }
   else
   {
     uint keyno= MAX_KEY;
-    if (tab->ref.key_parts)
-      keyno= tab->ref.key;
-    else if (tab->select && quick)
-      keyno = quick->index;
+    if (ref.key_parts)
+      keyno= ref.key;
+    else if (select && cur_quick)
+      keyno = cur_quick->index;
 
     if (keyno != MAX_KEY && keyno == table->file->pushed_idx_cond_keyno &&
         table->file->pushed_idx_cond)
@@ -23880,7 +23887,7 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
       eta->push_extra(ET_USING_INDEX_CONDITION);
       eta->pushed_index_cond= table->file->pushed_idx_cond;
     }
-    else if (tab->cache_idx_cond)
+    else if (cache_idx_cond)
       eta->push_extra(ET_USING_INDEX_CONDITION_BKA);
 
     if (quick_type == QUICK_SELECT_I::QS_TYPE_ROR_UNION || 
@@ -23890,22 +23897,22 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
     {
       eta->push_extra(ET_USING);
     }
-    if (tab->select)
+    if (select)
     {
-      if (tab->use_quick == 2)
+      if (use_quick == 2)
       {
         eta->push_extra(ET_RANGE_CHECKED_FOR_EACH_RECORD);
         eta->range_checked_fer= new (thd->mem_root) Explain_range_checked_fer;
         if (eta->range_checked_fer)
           eta->range_checked_fer->
-            append_possible_keys_stat(thd->mem_root, table, tab->keys);
+            append_possible_keys_stat(thd->mem_root, table, keys);
       }
-      else if (tab->select->cond ||
-               (tab->cache_select && tab->cache_select->cond))
+      else if (select->cond ||
+               (cache_select && cache_select->cond))
       {
-        const COND *pushed_cond= tab->table->file->pushed_cond;
+        const COND *pushed_cond= table->file->pushed_cond;
 
-        if ((tab->table->file->ha_table_flags() &
+        if ((table->file->ha_table_flags() &
               HA_CAN_TABLE_CONDITION_PUSHDOWN) &&
             pushed_cond)
         {
@@ -23913,8 +23920,8 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
         }
         else
         {
-          eta->where_cond= tab->select->cond;
-          eta->cache_cond= tab->cache_select? tab->cache_select->cond : NULL;
+          eta->where_cond= select->cond;
+          eta->cache_cond= cache_select? cache_select->cond : NULL;
           eta->push_extra(ET_USING_WHERE);
         }
       }
@@ -23945,7 +23952,7 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
       if (quick_type == QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX)
       {
         QUICK_GROUP_MIN_MAX_SELECT *qgs= 
-          (QUICK_GROUP_MIN_MAX_SELECT *) tab->select->quick;
+          (QUICK_GROUP_MIN_MAX_SELECT *) select->quick;
         eta->push_extra(ET_USING_INDEX_FOR_GROUP_BY);
         eta->loose_scan_is_scanning= qgs->loose_scan_is_scanning();
       }
@@ -23957,7 +23964,7 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
 
     if (quick_type == QUICK_SELECT_I::QS_TYPE_RANGE)
     {
-      explain_append_mrr_info((QUICK_RANGE_SELECT*)(tab->select->quick),
+      explain_append_mrr_info((QUICK_RANGE_SELECT*)(select->quick),
                               &eta->mrr_type);
       if (eta->mrr_type.length() > 0)
         eta->push_extra(ET_USING_MRR);
@@ -23965,30 +23972,30 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
 
     if (distinct & test_all_bits(prefix_tables, join->select_list_used_tables))
       eta->push_extra(ET_DISTINCT);
-    if (tab->loosescan_match_tab)
+    if (loosescan_match_tab)
     {
       eta->push_extra(ET_LOOSESCAN);
     }
 
-    if (tab->first_weedout_table)
+    if (first_weedout_table)
     {
       eta->start_dups_weedout= true;
       eta->push_extra(ET_START_TEMPORARY);
     }
-    if (tab->check_weed_out_table)
+    if (check_weed_out_table)
     {
       eta->push_extra(ET_END_TEMPORARY);
       eta->end_dups_weedout= true;
     }
 
-    else if (tab->do_firstmatch)
+    else if (do_firstmatch)
     {
-      if (tab->do_firstmatch == /*join->join_tab*/ first_top_tab - 1)
+      if (do_firstmatch == /*join->join_tab*/ first_top_tab - 1)
         eta->push_extra(ET_FIRST_MATCH);
       else
       {
         eta->push_extra(ET_FIRST_MATCH);
-        TABLE *prev_table=tab->do_firstmatch->table;
+        TABLE *prev_table=do_firstmatch->table;
         if (prev_table->derived_select_number)
         {
           char namebuf[NAME_LEN];
@@ -24003,9 +24010,9 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
       }
     }
 
-    for (uint part= 0; part < tab->ref.key_parts; part++)
+    for (uint part= 0; part < ref.key_parts; part++)
     {
-      if (tab->ref.cond_guards[part])
+      if (ref.cond_guards[part])
       {
         eta->push_extra(ET_FULL_SCAN_ON_NULL_KEY);
         eta->full_scan_on_null_key= true;
@@ -24013,10 +24020,10 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta, table_map prefix_tab
       }
     }
 
-    if (tab->cache)
+    if (cache)
     {
       eta->push_extra(ET_USING_JOIN_BUFFER);
-      tab->cache->save_explain_data(&eta->bka_type);
+      cache->save_explain_data(&eta->bka_type);
     }
   }
 
@@ -24043,7 +24050,7 @@ int JOIN::save_explain_data_intern(Explain_query *output, bool need_tmp_table,
                                    const char *message)
 {
   JOIN *join= this; /* Legacy: this code used to be a non-member function */
-  int error= 0;
+  int cur_error= 0;
   DBUG_ENTER("JOIN::save_explain_data_intern");
   DBUG_PRINT("info", ("Select 0x%lx, type %s, message %s",
 		      (ulong)join->select_lex, join->select_lex->type,
@@ -24106,12 +24113,12 @@ int JOIN::save_explain_data_intern(Explain_query *output, bool need_tmp_table,
          tab= next_explain_order_tab(join, tab))
     {
       JOIN_TAB *saved_join_tab= NULL;
-      TABLE *table=tab->table;
+      TABLE *cur_table= tab->table;
 
       /* Don't show eliminated tables */
-      if (table->map & join->eliminated_tables)
+      if (cur_table->map & join->eliminated_tables)
       {
-        used_tables|=table->map;
+        used_tables|= cur_table->map;
         continue;
       }
 
@@ -24159,14 +24166,14 @@ int JOIN::save_explain_data_intern(Explain_query *output, bool need_tmp_table,
         tab= saved_join_tab;
 
       // For next iteration
-      used_tables|=table->map;
+      used_tables|= cur_table->map;
     }
     output->add_node(xpl_sel);
   }
 
-  for (SELECT_LEX_UNIT *unit= join->select_lex->first_inner_unit();
-       unit;
-       unit= unit->next_unit())
+  for (SELECT_LEX_UNIT *tmp_unit= join->select_lex->first_inner_unit();
+       tmp_unit;
+       tmp_unit= tmp_unit->next_unit())
   {
     /* 
       Display subqueries only if 
@@ -24174,17 +24181,18 @@ int JOIN::save_explain_data_intern(Explain_query *output, bool need_tmp_table,
           elimination.
       (2) they are not merged derived tables
     */
-    if (!(unit->item && unit->item->eliminated) &&                    // (1)
-        (!unit->derived || unit->derived->is_materialized_derived())) // (2)
+    if (!(tmp_unit->item && tmp_unit->item->eliminated) &&    // (1)
+        (!tmp_unit->derived ||
+         tmp_unit->derived->is_materialized_derived()))       // (2)
     {
-      explain->add_child(unit->first_select()->select_number);
+      explain->add_child(tmp_unit->first_select()->select_number);
     }
   }
 
-  if (!error && select_lex->is_top_level_node())
+  if (!cur_error && select_lex->is_top_level_node())
     output->query_plan_ready();
 
-  DBUG_RETURN(error);
+  DBUG_RETURN(cur_error);
 }
 
 
@@ -24433,7 +24441,7 @@ static void print_join(THD *thd,
     {
       if (!(*t2)->sj_inner_tables)
       {
-        TABLE_LIST *tmp= *t2;
+        tmp= *t2;
         *t2= *table;
         *table= tmp;
         break;