postreview fix (SCRUM)

fixed layout


sql/filesort.cc:
  fixed layout
sql/gstream.cc:
  fixed layout
sql/item.cc:
  postreview fix
sql/item.h:
  postreview fix
sql/item_cmpfunc.cc:
  postreview fix
sql/item_cmpfunc.h:
  fixed layout
sql/item_func.h:
  fixed layout
sql/item_row.h:
  fixed layout
sql/item_strfunc.cc:
  fixed layout
sql/item_subselect.cc:
  postreview fix
sql/item_subselect.h:
  postreview fix
sql/nt_servc.cc:
  fixed layout
sql/opt_range.cc:
  fixed layout
sql/password.c:
  fixed layout
sql/spatial.cc:
  fixed layout
sql/sql_help.cc:
  fixed layout
sql/sql_lex.cc:
  fixed layout
sql/sql_olap.cc:
  fixed layout
sql/sql_select.cc:
  fixed layout
sql/sql_show.cc:
  fixed layout
sql/sql_string.cc:
  fixed layout
sql/sql_table.cc:
  fixed layout
sql/stacktrace.c:
  fixed layout

sql/filesort.cc

@@ -496,7 +496,7 @@ static void make_sortkey(register SORTPARAM *param,
 	    length=sort_field->length;
 	  }
 #ifdef USE_STRCOLL
-          if(use_strnxfrm(cs))
+          if (use_strnxfrm(cs))
           {
             if (item->binary())
             {

sql/gstream.cc

@@ -3,36 +3,38 @@
 int GTextReadStream::get_next_toc_type() const
 {
   const char *cur = m_cur;
-  while((*cur)&&(strchr(" \t\r\n",*cur)))
+  while ((*cur)&&(strchr(" \t\r\n",*cur)))
   {
     cur++;
   }
-  if(!(*cur))
+  if (!(*cur))
   {
     return eostream;
   }
 
-  if(((*cur>='a') && (*cur<='z')) || ((*cur>='A') && (*cur<='Z')) || (*cur=='_'))
+  if (((*cur>='a') && (*cur<='z')) || ((*cur>='A') && (*cur<='Z')) ||
+      (*cur=='_'))
   {
     return word;
   }
 
-  if(((*cur>='0') && (*cur<='9')) || (*cur=='-') || (*cur=='+') || (*cur=='.'))
+  if (((*cur>='0') && (*cur<='9')) || (*cur=='-') || (*cur=='+') ||
+      (*cur=='.'))
   {
     return numeric;
   }
 
-  if(*cur == '(')
+  if (*cur == '(')
   {
     return l_bra;
   }
   
-  if(*cur == ')')
+  if (*cur == ')')
   {
     return r_bra;
   }
 
-  if(*cur == ',')
+  if (*cur == ',')
   {
     return comma;
   }
@@ -43,28 +45,28 @@ int GTextReadStream::get_next_toc_type() const
 const char *GTextReadStream::get_next_word(int *word_len)
 {
   const char *cur = m_cur;
-  while((*cur)&&(strchr(" \t\r\n",*cur)))
+  while ((*cur)&&(strchr(" \t\r\n",*cur)))
   {
     cur++;
   }
   m_last_text_position = cur;
 
-  if(!(*cur))
+  if (!(*cur))
   {
     return 0;
   }
 
   const char *wd_start = cur;
 
-  if(((*cur<'a') || (*cur>'z')) && ((*cur<'A') || (*cur>'Z')) && (*cur!='_'))
+  if (((*cur<'a') || (*cur>'z')) && ((*cur<'A') || (*cur>'Z')) && (*cur!='_'))
   {
     return NULL;
   }
 
   ++cur;
 
-  while(((*cur>='a') && (*cur<='z')) || ((*cur>='A') && (*cur<='Z')) || (*cur=='_') ||
-    ((*cur>='0') && (*cur<='9')))
+  while (((*cur>='a') && (*cur<='z')) || ((*cur>='A') && (*cur<='Z')) ||
+	 (*cur=='_') || ((*cur>='0') && (*cur<='9')))
   {
     ++cur;
   }
@@ -79,19 +81,19 @@ const char *GTextReadStream::get_next_word(int *word_len)
 int GTextReadStream::get_next_number(double *d)
 {
   const char *cur = m_cur;
-  while((*cur)&&(strchr(" \t\r\n",*cur)))
+  while ((*cur)&&(strchr(" \t\r\n",*cur)))
   {
     cur++;
   }
 
   m_last_text_position = cur;
-  if(!(*cur))
+  if (!(*cur))
   {
     set_error_msg("Numeric constant expected");
     return 1;
   }
 
-  if(((*cur<'0') || (*cur>'9')) && (*cur!='-') && (*cur!='+') && (*cur!='.'))
+  if (((*cur<'0') || (*cur>'9')) && (*cur!='-') && (*cur!='+') && (*cur!='.'))
   {
     set_error_msg("Numeric constant expected");
     return 1;
@@ -101,7 +103,7 @@ int GTextReadStream::get_next_number(double *d)
 
   *d = strtod(cur, &endptr);
 
-  if(endptr)
+  if (endptr)
   {
     m_cur = endptr;
   }
@@ -112,11 +114,11 @@ int GTextReadStream::get_next_number(double *d)
 char GTextReadStream::get_next_symbol()
 {
   const char *cur = m_cur;
-  while((*cur)&&(strchr(" \t\r\n",*cur)))
+  while ((*cur)&&(strchr(" \t\r\n",*cur)))
   {
     cur++;
   }
-  if(!(*cur))
+  if (!(*cur))
   {
     return 0;
   }

sql/item.cc

@@ -502,18 +502,17 @@ bool Item_ref_on_list_position::fix_fields(THD *thd,
 					   struct st_table_list *tables,
 					   Item ** reference)
 {
-  ref= 0;
   List_iterator<Item> li(list);
   Item *item;
-  uint i= 0;
-  for (; (item= li++) && i < pos; i++);
-  if (i == pos)
+  for (uint i= 0; (item= li++) && i < pos; i++);
+  if (item)
   {
     ref= li.ref();
     return Item_ref_null_helper::fix_fields(thd, tables, reference);
   }
   else
   {
+    ref= 0;
     my_error(ER_CARDINALITY_COL, MYF(0), pos);
     return 1;
   }
@@ -1280,29 +1279,20 @@ longlong Item_cache_str::val_int()
 
 bool Item_cache_row::allocate(uint num)
 {
-  n= num;
+  item_count= num;
   THD *thd= current_thd;
-  if (!(values= (Item_cache **) thd->calloc(sizeof(Item_cache *)*n)))
-  {
-    my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-    thd->fatal_error= 1;
-    return 1;
-  }
-  return 0;
+  return (!(values= 
+	    (Item_cache **) thd->calloc(sizeof(Item_cache *)*item_count)));
 }
 
 bool Item_cache_row::setup(Item * item)
 {
   if (!values && allocate(item->cols()))
     return 1;
-  for(uint i= 0; i < n; i++)
+  for (uint i= 0; i < item_count; i++)
   {
     if (!(values[i]= Item_cache::get_cache(item->el(i)->result_type())))
-    {
-      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-      current_thd->fatal_error= 1;
       return 1;
-    }
     values[i]->setup(item->el(i));
   }
   return 0;
@@ -1312,7 +1302,7 @@ void Item_cache_row::store(Item * item)
 {
   null_value= 0;
   item->bring_value();
-  for(uint i= 0; i < n; i++)
+  for (uint i= 0; i < item_count; i++)
   {
     values[i]->store(item->el(i));
     null_value|= values[i]->null_value;
@@ -1330,7 +1320,7 @@ void Item_cache_row::illegal_method_call(const char *method)
 
 bool Item_cache_row::check_cols(uint c)
 {
-  if (c != n)
+  if (c != item_count)
   {
     my_error(ER_CARDINALITY_COL, MYF(0), c);
     return 1;
@@ -1340,7 +1330,7 @@ bool Item_cache_row::check_cols(uint c)
 
 bool Item_cache_row::null_inside()
 {
-  for (uint i= 0; i < n; i++)
+  for (uint i= 0; i < item_count; i++)
   {
     if (values[i]->cols() > 1)
     {
@@ -1359,7 +1349,7 @@ bool Item_cache_row::null_inside()
 
 void Item_cache_row::bring_value()
 {
-  for (uint i= 0; i < n; i++)
+  for (uint i= 0; i < item_count; i++)
     values[i]->bring_value();
   return;
 }

sql/item.h

@@ -731,9 +731,9 @@ public:
 class Item_cache_row: public Item_cache
 {
   Item_cache  **values;
-  uint n;
+  uint item_count;
 public:
-  Item_cache_row(): values(0), n(2) { fixed= 1; null_value= 1; }
+  Item_cache_row(): values(0), item_count(2) { fixed= 1; null_value= 1; }
   
   /*
     'allocate' used only in row transformer, to preallocate space for row 
@@ -768,7 +768,7 @@ public:
   };
   enum Item_result result_type() const { return ROW_RESULT; }
   
-  uint cols() { return n; }
+  uint cols() { return item_count; }
   Item* el(uint i) { return values[i]; }
   Item** addr(uint i) { return (Item **) (values + i); }
   bool check_cols(uint c);

sql/item_cmpfunc.cc

@@ -153,12 +153,8 @@ int Arg_comparator::set_compare_func(Item_bool_func2 *item, Item_result type)
 	comparators[i].set_cmp_func(owner, (*a)->addr(i), (*b)->addr(i));
       }
     else
-    {
-      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-      current_thd->fatal_error= 1;
       return 1;
   }
-  }
   return 0;
 }
 
@@ -276,11 +272,7 @@ int Arg_comparator::compare_e_row()
 
 bool Item_in_optimizer::preallocate_row()
 {
-  if ((cache= Item_cache::get_cache(ROW_RESULT)))
-    return 0;
-  my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-  current_thd->fatal_error= 1;
-  return 1;
+  return (!(cache= Item_cache::get_cache(ROW_RESULT)));
 }
 
 bool Item_in_optimizer::fix_fields(THD *thd, struct st_table_list *tables,
@@ -296,11 +288,7 @@ bool Item_in_optimizer::fix_fields(THD *thd, struct st_table_list *tables,
   used_tables_cache= args[0]->used_tables();
   const_item_cache= args[0]->const_item();
   if (!cache && !(cache= Item_cache::get_cache(args[0]->result_type())))
-  {
-    my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-    thd->fatal_error= 1;
     return 1;
-  }
   cache->setup(args[0]);
   if (args[1]->fix_fields(thd, tables, args))
     return 1;
@@ -1246,18 +1234,10 @@ void cmp_item_row::store_value(Item *item)
 	item->null_value|= item->el(i)->null_value;
       }
       else
-      {
-	my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-	thd->fatal_error= 1;
 	return;
   }
-  }
   else
-  {
-    my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-    thd->fatal_error= 1;
     return;
-  }
 }
 
 void cmp_item_row::store_value_by_template(cmp_item *t, Item *item)
@@ -1281,18 +1261,10 @@ void cmp_item_row::store_value_by_template(cmp_item *t, Item *item)
 	item->null_value|= item->el(i)->null_value;
       }
       else
-      {
-	my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-	current_thd->fatal_error= 1;
 	return;
   }
-  }
   else
-  {
-    my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-    current_thd->fatal_error= 1;
     return;
-  }	  
 }
 
 int cmp_item_row::cmp(Item *arg)

sql/item_cmpfunc.h

@@ -544,8 +544,8 @@ public:
   cmp_item_row(): comparators(0), n(0) {}
   ~cmp_item_row()
   {
-    if(comparators)
-      for(uint i= 0; i < n; i++)
+    if (comparators)
+      for (uint i= 0; i < n; i++)
 	if (comparators[i])
 	  delete comparators[i];
   }

sql/item_func.h

@@ -995,7 +995,7 @@ public:
     {
       ft_handler->please->close_search(ft_handler);
       ft_handler=0;
-      if(join_key)
+      if (join_key)
 	table->file->ft_handler=0;
       table->fulltext_searched=0;
     }

sql/item_row.h

@@ -33,7 +33,7 @@ public:
 
   ~Item_row()
   {
-    if(array_holder && items)
+    if (array_holder && items)
       sql_element_free(items);
   }
 

sql/item_strfunc.cc

@@ -1961,7 +1961,7 @@ String *Item_func_conv_charset::val_str(String *str)
   d0=d=(unsigned char*)str->ptr();
   de=d+dmaxlen;
 
-  while( s < se && d < de){
+  while (s < se && d < de){
 
     cnvres=from->mb_wc(from,&wc,s,se);
     if (cnvres>0)
@@ -2035,7 +2035,7 @@ String *Item_func_conv_charset3::val_str(String *str)
   d0=d=(unsigned char*)str->ptr();
   de=d+dmaxlen;
 
-  while( s < se && d < de){
+  while (s < se && d < de){
 
     cnvres=from_charset->mb_wc(from_charset,&wc,s,se);
     if (cnvres>0)
@@ -2655,7 +2655,7 @@ String *Item_func_spatial_collection::val_str(String *str)
   null_value=1;
 
   str->length(0);
-  if(str->reserve(9,512))
+  if (str->reserve(9,512))
     return 0;
 
   str->q_append((char)Geometry::wkbNDR);

sql/item_subselect.cc

@@ -32,6 +32,11 @@ SUBSELECT TODO:
 #include "mysql_priv.h"
 #include "sql_select.h"
 
+inline Item * and_items(Item* cond, Item *item)
+{
+  return (cond? (new Item_cond_and(cond, item)) : item);
+}
+
 Item_subselect::Item_subselect():
   Item_result_field(), engine_owner(1), value_assigned(0), substitution(0),
   have_to_be_excluded(0)
@@ -51,7 +56,7 @@ void Item_subselect::init(THD *thd, st_select_lex *select_lex,
   DBUG_ENTER("Item_subselect::init");
   DBUG_PRINT("subs", ("select_lex 0x%xl", (ulong) select_lex));
 
-  select_transformer(select_lex->master_unit());
+  select_transformer(thd, select_lex->master_unit());
   if (select_lex->next_select())
     engine= new subselect_union_engine(thd, select_lex->master_unit(), result,
 				       this);
@@ -67,7 +72,7 @@ Item_subselect::~Item_subselect()
     delete engine;
 }
 
-void Item_subselect::select_transformer(st_select_lex_unit *unit) 
+void Item_subselect::select_transformer(THD *thd, st_select_lex_unit *unit) 
 {
   DBUG_ENTER("Item_subselect::select_transformer");
   DBUG_VOID_RETURN;
@@ -146,7 +151,8 @@ void Item_singlerow_subselect::reset()
     value->null_value= 1;
 }
 
-void Item_singlerow_subselect::select_transformer(st_select_lex_unit *unit)
+void Item_singlerow_subselect::select_transformer(THD *thd,
+						  st_select_lex_unit *unit)
 {
   SELECT_LEX *select_lex= unit->first_select();
   
@@ -155,7 +161,6 @@ void Item_singlerow_subselect::select_transformer(st_select_lex_unit *unit)
   {
     
     have_to_be_excluded= 1;
-    THD *thd= current_thd;
     if (thd->lex.describe)
     {
       char warn_buff[MYSQL_ERRMSG_SIZE];
@@ -178,20 +183,12 @@ void Item_singlerow_subselect::select_transformer(st_select_lex_unit *unit)
 	cond= select_lex->having;
       else
 	if (!(cond= new Item_cond_and(select_lex->having, select_lex->where)))
-	{
-	  my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-	  thd->fatal_error= 1;
 	  return;
-	}
       if (!(substitution= new Item_func_if(cond, substitution,
 					   new Item_null())))
-      {
-	my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-	thd->fatal_error= 1;
 	return;
     }
   }
-  }
 }
 
 void Item_singlerow_subselect::store(uint i, Item *item)
@@ -210,21 +207,13 @@ void Item_singlerow_subselect::fix_length_and_dec()
   {
     engine->fix_length_and_dec(row= &value);
     if (!(value= Item_cache::get_cache(engine->type())))
-    {
-      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-      current_thd->fatal_error= 1;
       return;
   }
-  }
   else
   {
     THD *thd= current_thd;
     if (!(row= (Item_cache**)thd->alloc(sizeof(Item_cache*)*max_columns)))
-    {
-      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-      thd->fatal_error= 1;
       return;
-    }
     engine->fix_length_and_dec(row);
     value= *row;
   }
@@ -443,7 +432,8 @@ Item_allany_subselect::Item_allany_subselect(Item_allany_subselect *item):
   func= item->func;
 }
 
-void Item_in_subselect::single_value_transformer(st_select_lex_unit *unit,
+void Item_in_subselect::single_value_transformer(THD *thd,
+						 st_select_lex_unit *unit,
 						 Item *left_expr,
 						 compare_func_creator func)
 {
@@ -457,10 +447,8 @@ void Item_in_subselect::single_value_transformer(st_select_lex_unit *unit,
   Item_in_optimizer *optimizer;
   substitution= optimizer= new Item_in_optimizer(left_expr, this);
   if (!optimizer)
-  {
-    current_thd->fatal_error= 1;
     DBUG_VOID_RETURN;
-  }
+
   /*
     As far as  Item_ref_in_optimizer do not substitude itself on fix_fields
     we can use same item for all selects.
@@ -497,15 +485,9 @@ void Item_in_subselect::single_value_transformer(st_select_lex_unit *unit,
 						   (char *)"<no matter>",
 						   (char*)"<result>"));
       if (sl->having || sl->with_sum_func || sl->group_list.first)
-	if (sl->having)
-	  sl->having= new Item_cond_and(sl->having, item);
-	else
-	  sl->having= item;
-      else
-	if (sl->where)
-	  sl->where= new Item_cond_and(sl->where, item);
+	sl->having= and_items(sl->having, item);
       else
-	  sl->where= item;
+	sl->where= and_items(sl->where, item);
     }
     else
     {
@@ -516,10 +498,7 @@ void Item_in_subselect::single_value_transformer(st_select_lex_unit *unit,
 	item= (*func)(expr, new Item_asterisk_remover(this, item,
 						      (char *)"<no matter>",
 						      (char*)"<result>"));
-	if (sl->where)
-	  sl->where= new Item_cond_and(sl->where, item);
-	else
-	  sl->where= item;
+	sl->where= and_items(sl->where, item);
       }
       else
       {
@@ -546,7 +525,6 @@ void Item_in_subselect::single_value_transformer(st_select_lex_unit *unit,
 	  item= (*func)(left_expr, item);
 	  substitution= item;
 	  have_to_be_excluded= 1;
-	  THD *thd= current_thd;
 	  if (thd->lex.describe)
 	  {
 	    char warn_buff[MYSQL_ERRMSG_SIZE];
@@ -561,7 +539,8 @@ void Item_in_subselect::single_value_transformer(st_select_lex_unit *unit,
   DBUG_VOID_RETURN;
 }
 
-void Item_in_subselect::row_value_transformer(st_select_lex_unit *unit,
+void Item_in_subselect::row_value_transformer(THD *thd,
+					      st_select_lex_unit *unit,
 					      Item *left_expr)
 {
   DBUG_ENTER("Item_in_subselect::row_value_transformer");
@@ -575,10 +554,8 @@ void Item_in_subselect::row_value_transformer(st_select_lex_unit *unit,
   Item_in_optimizer *optimizer;
   substitution= optimizer= new Item_in_optimizer(left_expr, this);
   if (!optimizer)
-  {
-    current_thd->fatal_error= 1;
     DBUG_VOID_RETURN;
-  }
+
   unit->dependent= 1;
   uint n= left_expr->cols();
   if (optimizer->preallocate_row() || (*optimizer->get_cache())->allocate(n))
@@ -608,40 +585,32 @@ void Item_in_subselect::row_value_transformer(st_select_lex_unit *unit,
 						 (char *)"<no matter>",
 						 (char *)"<left expr>"),
 				    func);
-      if (!item)
-	item= func;
-      else
-	item= new Item_cond_and(item, func);
+      item= and_items(item, func);
     }
 
     if (sl->having || sl->with_sum_func || sl->group_list.first ||
 	!sl->table_list.elements)
-      if (sl->having)
-	sl->having= new Item_cond_and(sl->having, item);
-      else
-	sl->having= item;
-    else
-      if (sl->where)
-	sl->where= new Item_cond_and(sl->where, item);
+      sl->having= and_items(sl->having, item);
     else
-	sl->where= item;
+      sl->where= and_items(sl->where, item);
   }
   DBUG_VOID_RETURN;
 }
 
 
-void Item_in_subselect::select_transformer(st_select_lex_unit *unit)
+void Item_in_subselect::select_transformer(THD *thd, st_select_lex_unit *unit)
 {
   if (left_expr->cols() == 1)
-    single_value_transformer(unit, left_expr,
+    single_value_transformer(thd, unit, left_expr,
 			     &Item_bool_func2::eq_creator);
   else
-    row_value_transformer(unit, left_expr);
+    row_value_transformer(thd, unit, left_expr);
 }
 
-void Item_allany_subselect::select_transformer(st_select_lex_unit *unit)
+void Item_allany_subselect::select_transformer(THD *thd,
+					       st_select_lex_unit *unit)
 {
-  single_value_transformer(unit, left_expr, func);
+  single_value_transformer(thd, unit, left_expr, func);
 }
 
 subselect_single_select_engine::subselect_single_select_engine(THD *thd, 
@@ -678,7 +647,7 @@ subselect_union_engine::subselect_union_engine(THD *thd,
   subselect_engine(thd, item, result)
 {
   unit= u;
-  if( !result)
+  if (!result)
   {
     //out of memory
     thd->fatal_error= 1;
@@ -694,7 +663,7 @@ int subselect_single_select_engine::prepare()
   prepared= 1;
   SELECT_LEX_NODE *save_select= thd->lex.current_select;
   thd->lex.current_select= select_lex;
-  if(join->prepare((TABLE_LIST*) select_lex->table_list.first,
+  if (join->prepare((TABLE_LIST*) select_lex->table_list.first,
 		    select_lex->where,
 		    (ORDER*) select_lex->order_list.first,
 		    (ORDER*) select_lex->group_list.first,
@@ -726,11 +695,7 @@ static Item_result set_row(SELECT_LEX *select_lex, Item * item,
     if (row)
     {
       if (!(row[i]= Item_cache::get_cache(res_type)))
-      {
-	my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-	current_thd->fatal_error= 1;
 	return STRING_RESULT; // we should return something
-      }
       row[i]->set_len_n_dec(sel_item->max_length, sel_item->decimals);
     }
   }
@@ -763,7 +728,7 @@ void subselect_union_engine::fix_length_and_dec(Item_cache **row)
 	mlen= len;
       if (!sel_item)
 	sel_item= s_item;
-      maybe_null!= s_item->maybe_null;
+      maybe_null= s_item->maybe_null;
     }
     item->max_length= mlen;
     res_type= sel_item->result_type();
@@ -771,11 +736,7 @@ void subselect_union_engine::fix_length_and_dec(Item_cache **row)
     if (row)
     {
       if (!(row[0]= Item_cache::get_cache(res_type)))
-      {
-	my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
-	current_thd->fatal_error= 1;
 	return;
-      }
       row[0]->set_len_n_dec(mlen, sel_item->decimals);
     }
   }
@@ -784,7 +745,7 @@ void subselect_union_engine::fix_length_and_dec(Item_cache **row)
     SELECT_LEX *sl= unit->first_select();
     bool fake= 0;
     res_type= set_row(sl, item, row, &fake);
-    for(sl= sl->next_select(); sl; sl->next_select())
+    for (sl= sl->next_select(); sl; sl->next_select())
     {
       List_iterator_fast<Item> li(sl->item_list);
       Item *sel_item;

sql/item_subselect.h

@@ -71,7 +71,7 @@ public:
   {
     null_value= 1;
   }
-  virtual void select_transformer(st_select_lex_unit *unit);
+  virtual void select_transformer(THD *thd, st_select_lex_unit *unit);
   bool assigned() { return value_assigned; }
   void assigned(bool a) { value_assigned= a; }
   enum Type type() const;
@@ -106,7 +106,7 @@ public:
     decimals= item->decimals;
   }
   void reset();
-  void select_transformer(st_select_lex_unit *unit);
+  void select_transformer(THD *thd, st_select_lex_unit *unit);
   void store(uint i, Item* item);
   double val();
   longlong val_int ();
@@ -173,10 +173,11 @@ public:
     null_value= 0;
     was_null= 0;
   }
-  virtual void select_transformer(st_select_lex_unit *unit);
-  void single_value_transformer(st_select_lex_unit *unit,
+  virtual void select_transformer(THD *thd, st_select_lex_unit *unit);
+  void single_value_transformer(THD *thd, st_select_lex_unit *unit,
 				Item *left_expr, compare_func_creator func);
-  void row_value_transformer(st_select_lex_unit *unit, Item *left_expr);
+  void row_value_transformer(THD *thd, st_select_lex_unit *unit,
+			     Item *left_expr);
   longlong val_int();
   double val();
   String *val_str(String*);
@@ -195,7 +196,7 @@ public:
   Item_allany_subselect(THD *thd, Item * left_expr, compare_func_creator f,
 		     st_select_lex *select_lex);
   Item_allany_subselect(Item_allany_subselect *item);
-  virtual void select_transformer(st_select_lex_unit *unit);
+  virtual void select_transformer(THD *thd, st_select_lex_unit *unit);
 };
 
 class subselect_engine: public Sql_alloc

sql/nt_servc.cc

@@ -431,7 +431,7 @@ BOOL NTService::SeekStatus(LPCSTR szInternName, int OperationType)
     if (ret_error == ERROR_ACCESS_DENIED)
     {
      printf("Install/Remove of the Service Denied!\n");
-     if(!is_super_user())
+     if (!is_super_user())
       printf("That operation should be made by an user with Administrator privileges!\n");
     }
     else
@@ -530,12 +530,12 @@ BOOL NTService::is_super_user()
   UINT x;
   BOOL ret_value=FALSE;
  
-  if(!OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, TRUE,&hAccessToken ))
+  if (!OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, TRUE,&hAccessToken ))
   {
-   if(GetLastError() != ERROR_NO_TOKEN)
+   if (GetLastError() != ERROR_NO_TOKEN)
      return FALSE;
  
-   if(!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hAccessToken))
+   if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hAccessToken))
      return FALSE;
   }
  
@@ -544,10 +544,10 @@ BOOL NTService::is_super_user()
 
   CloseHandle(hAccessToken);
  
-  if(!ret_value )
+  if (!ret_value )
     return FALSE;
  
-  if(!AllocateAndInitializeSid(&siaNtAuthority, 2,
+  if (!AllocateAndInitializeSid(&siaNtAuthority, 2,
 				SECURITY_BUILTIN_DOMAIN_RID,
 				DOMAIN_ALIAS_RID_ADMINS,
 				0, 0, 0, 0, 0, 0,
@@ -556,9 +556,9 @@ BOOL NTService::is_super_user()
 
   ret_value = FALSE;
  
-  for(x=0;x<ptgGroups->GroupCount;x++)
+  for (x=0;x<ptgGroups->GroupCount;x++)
   {
-   if( EqualSid(psidAdministrators, ptgGroups->Groups[x].Sid) )
+   if ( EqualSid(psidAdministrators, ptgGroups->Groups[x].Sid) )
    {
     ret_value = TRUE;
     break;

sql/opt_range.cc

@@ -2162,12 +2162,13 @@ check_quick_keys(PARAM *param,uint idx,SEL_ARG *key_tree,
     tmp=1;					// Max one record
   else
   {
-    if(tmp_min_flag & GEOM_FLAG)
+    if (tmp_min_flag & GEOM_FLAG)
     {
-      tmp=param->table->file->
-	records_in_range((int) keynr,(byte*)(param->min_key + 1),
-	  min_key_length, (ha_rkey_function)(tmp_min_flag ^ GEOM_FLAG),
-          (byte *)NullS,0,HA_READ_KEY_EXACT);
+      tmp= param->table->file->
+	records_in_range((int) keynr, (byte*)(param->min_key + 1),
+			 min_key_length,
+			 (ha_rkey_function)(tmp_min_flag ^ GEOM_FLAG),
+			 (byte *)NullS, 0, HA_READ_KEY_EXACT);
     }
     else
     {

sql/password.c

@@ -573,7 +573,7 @@ void get_hash_and_password(ulong* salt, uint8 pversion, char* hash, unsigned cha
     while (salt<salt_end) /* Iterate over these elements*/
     {
       val=*salt;
-      for(t=3;t>=0;t--)
+      for (t=3;t>=0;t--)
       {
         bp[t]=val%256;
 

sql/spatial.cc

@@ -506,7 +506,7 @@ int GPolygon::get_data_as_text(String *txt) const
 
   for (; n_linear_rings>0; --n_linear_rings)
   {
-    if(no_data(data, 4))
+    if (no_data(data, 4))
       return 1;
     uint32 n_points = uint4korr(data);
     data += 4;
@@ -593,7 +593,7 @@ int GPolygon::area(double *ar) const
       data += (8+8);
     }
     lr_area=fabs(lr_area)/2;
-    if(result==-1) result=lr_area;
+    if (result==-1) result=lr_area;
     else result-=lr_area;
   }
   *ar=fabs(result);
@@ -1344,7 +1344,7 @@ int GGeometryCollection::get_mbr(MBR *mbr) const
   data += 4;
   for (; n_objects>0; --n_objects)
   {
-    if(no_data(data, WKB_HEADER_SIZE))
+    if (no_data(data, WKB_HEADER_SIZE))
       return 1;
     uint32 wkb_type = uint4korr(data + sizeof(char));
     data += WKB_HEADER_SIZE;

sql/sql_help.cc

@@ -96,7 +96,7 @@ int search_functions(MI_INFO *file_leafs, const char *mask,
   DBUG_ENTER("search_functions");
   int count= 0;
 
-  if(mi_scan_init(file_leafs))
+  if (mi_scan_init(file_leafs))
     DBUG_RETURN(-1);
 
   help_leaf leaf;
@@ -191,7 +191,7 @@ int search_categories(THD *thd,
   if (!(file_categories= open_help_file(thd,"function_category_name")))
     DBUG_RETURN(-1);
 
-  if(mi_scan_init(file_categories))
+  if (mi_scan_init(file_categories))
   {
     mi_close(file_categories);
     DBUG_RETURN(-1);
@@ -393,7 +393,7 @@ int mysqld_help(THD *thd, const char *mask)
 			    description->ptr(), example->ptr())))
       goto end;
   }
-  else if((res= send_header_2(protocol)) ||
+  else if ((res= send_header_2(protocol)) ||
 	   (res= send_variant_2_list(protocol,&function_list,false)) ||
 	   (search_categories(thd, mask, &categories_list, 0)<0 && 
 	    (res=1)) ||

sql/sql_lex.cc

@@ -1036,7 +1036,7 @@ void st_select_lex_node::include_global(st_select_lex_node **plink)
 //excluding from global list (internal function)
 void st_select_lex_node::fast_exclude()
 {
-  if(link_prev)
+  if (link_prev)
   {
     if ((*link_prev= link_next))
       link_next->link_prev= link_prev;
@@ -1068,7 +1068,7 @@ void st_select_lex_node::exclude()
 void st_select_lex_unit::exclude_level()
 {
   SELECT_LEX_UNIT *units= 0, **units_last= &units;
-  for(SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
+  for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
   {
     if (sl->link_prev && (*sl->link_prev= sl->link_next))
       sl->link_next->link_prev= sl->link_prev;
@@ -1142,7 +1142,7 @@ void st_select_lex_node::mark_as_dependent(SELECT_LEX *last)
   for (SELECT_LEX_NODE *s= this;
        s &&s != last;
        s= s->outer_select())
-    if( !s->dependent )
+    if ( !s->dependent )
     {
       // Select is dependent of outer select
       s->dependent= 1;

sql/sql_olap.cc

@@ -62,7 +62,7 @@ static int make_new_olap_select(LEX *lex, SELECT_LEX *select_lex, List<Item> new
   List_iterator<Item> list_it(select_lex->item_list);
   List_iterator<Item> new_it(new_fields);
     
-  while((item=list_it++))
+  while ((item=list_it++))
   {
     bool not_found=true;
     if (item->type()==Item::FIELD_ITEM)
@@ -109,15 +109,15 @@ static int  olap_combos(List<Item> old_fields, List<Item> new_fields, Item *item
 			      int num_new_fields)
 {
   int sl_return = 0;
-  if(position == num_new_fields)
+  if (position == num_new_fields)
   {
-    if(item)
+    if (item)
       new_fields.push_front(item);
     sl_return = make_new_olap_select(lex, select_lex, new_fields);
   }
   else
   {
-    if(item)
+    if (item)
       new_fields.push_front(item);
     while ((num_fields - num_new_fields >= selection - position) && !sl_return)
     {
@@ -170,12 +170,12 @@ int handle_olaps(LEX *lex, SELECT_LEX *select_lex)
 
   if (select_lex->olap == CUBE_TYPE)
   {
-    for( int i=count-1; i>=0 && !sl_return; i--)
+    for ( int i=count-1; i>=0 && !sl_return; i--)
       sl_return=olap_combos(item_list_copy, new_item_list, (Item *)0, lex, select_lex, 0, 0, count, i);
   }
   else if (select_lex->olap == ROLLUP_TYPE)
   {
-    for( int i=count-1; i>=0 && !sl_return; i--)
+    for ( int i=count-1; i>=0 && !sl_return; i--)
     {
       Item *item;
       item_list_copy.pop();

sql/sql_select.cc

@@ -1160,7 +1160,7 @@ mysql_select(THD *thd, TABLE_LIST *tables, List<Item> &fields, COND *conds,
     if (thd->possible_loops)
     {
       Item *item;
-      while(thd->possible_loops->elements)
+      while (thd->possible_loops->elements)
       {
 	item= thd->possible_loops->pop();
     	if (item->check_loop(thd->check_loops_counter++))

sql/sql_show.cc

@@ -1113,7 +1113,7 @@ store_create_info(THD *thd, TABLE *table, String *packet)
       packet->append(" USING BTREE", 12);
 
     // +BAR: send USING only in non-default case: non-spatial rtree
-    if((key_info->algorithm == HA_KEY_ALG_RTREE) &&
+    if ((key_info->algorithm == HA_KEY_ALG_RTREE) &&
 	!(key_info->flags & HA_SPATIAL))
       packet->append(" USING RTREE",12);
 

sql/sql_string.cc

@@ -254,7 +254,7 @@ bool String::copy(const char *str,uint32 arg_length, CHARSET_INFO *from, CHARSET
       break;
 
 outp:
-    if((cnvres=to->wc_mb(to,wc,d,de)) >0 )
+    if ((cnvres=to->wc_mb(to,wc,d,de)) >0 )
     {
       d+=cnvres;
     }

sql/sql_table.cc

@@ -398,7 +398,7 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
   it.rewind();
   while ((sql_field=it++))
   {
-    if(!sql_field->charset)
+    if (!sql_field->charset)
       sql_field->charset = create_info->table_charset ?
 			   create_info->table_charset : 
 			   thd->db_charset? thd->db_charset :

sql/stacktrace.c

@@ -38,7 +38,7 @@ void safe_print_str(const char* name, const char* val, int max_len)
   }
 
   fprintf(stderr, "= ");
-  for(; max_len && PTR_SANE(val) && *val; --max_len)
+  for (; max_len && PTR_SANE(val) && *val; --max_len)
     fputc(*val++, stderr);
   fputc('\n', stderr);
 }
@@ -59,7 +59,7 @@ void safe_print_str(const char* name, const char* val, int max_len)
 inline uchar** find_prev_fp(uint32* pc, uchar** fp)
 {
   int i;
-  for(i = 0; i < MAX_INSTR_IN_FUNC; ++i,--pc)
+  for (i = 0; i < MAX_INSTR_IN_FUNC; ++i,--pc)
   {
     uchar* p = (uchar*)pc;
     if (p[2] == 222 &&  p[3] == 35)
@@ -73,7 +73,7 @@ inline uchar** find_prev_fp(uint32* pc, uchar** fp)
 inline uint32* find_prev_pc(uint32* pc, uchar** fp)
 {
   int i;
-  for(i = 0; i < MAX_INSTR_IN_FUNC; ++i,--pc)
+  for (i = 0; i < MAX_INSTR_IN_FUNC; ++i,--pc)
   {
     char* p = (char*)pc;
     if (p[1] == 0 && p[2] == 94 &&  p[3] == -73)