Merge sanja.is.com.ua:/home/bell/mysql/mysql-4.1

into sanja.is.com.ua:/home/bell/mysql/work-pointer-4.1

sql/item.cc

@@ -441,12 +441,11 @@ bool Item_field::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
 	cause error ER_NON_UNIQ_ERROR in find_field_in_tables.
       */
       SELECT_LEX *last= 0;
-      for (SELECT_LEX *sl= thd->lex.select->outer_select();
+      for (SELECT_LEX *sl= thd->lex.current_select->outer_select();
 	   sl;
 	   sl= sl->outer_select())
 	if ((tmp= find_field_in_tables(thd, this,
-				       (TABLE_LIST*)
-				       (last= sl)->table_list.first,
+				       (last= sl)->get_table_list(),
 				       0)) != not_found_field)
 	  break;
       if (!tmp)
@@ -464,20 +463,27 @@ bool Item_field::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
 	  Mark all selects from resolved to 1 before select where was 
 	  found table as depended (of select where was found table)
 	*/
-	for (SELECT_LEX *s= thd->lex.select;
-	     s &&s != last;
+	for (SELECT_LEX_NODE *s= thd->lex.current_select;
+	     s && s != last;
 	     s= s->outer_select())
-	  if( !s->depended )
+	{
+	  if( !s->dependent)
 	  {
 	    // Select is depended of outer select
-	    s->depended= s->master_unit()->depended= 1;
-	    //Tables will be reopened many times
-	    for (TABLE_LIST *tbl= 
-		   (TABLE_LIST*)s->table_list.first;
-		 tbl;
-		 tbl= tbl->next)
-	      tbl->shared= 1;
+	    s->dependent= 1;
+	    if (s->linkage != GLOBAL_OPTIONS_TYPE)
+	    { 
+              //s is st_select_lex*
+	      
+	      s->master_unit()->dependent= 1;
+	      //Tables will be reopened many times
+	      for (TABLE_LIST *tbl= s->get_table_list();
+		   tbl;
+		   tbl= tbl->next)
+		tbl->shared= 1;
+	    }
 	  }
+	}
       }
     } 
     else if (!tmp)
@@ -822,9 +828,11 @@ bool Item_ref::fix_fields(THD *thd,TABLE_LIST *tables, Item **reference)
 {
   if (!ref)
   {
-    SELECT_LEX *sl=thd->lex.select->outer_select();
-    if ((ref= find_item_in_list(this, thd->lex.select->item_list,
-		(sl ? REPORT_EXCEPT_NOT_FOUND : REPORT_ALL_ERRORS))) ==
+    SELECT_LEX *sl= thd->lex.current_select->outer_select();
+    if ((ref= find_item_in_list(this, 
+				*(thd->lex.current_select->get_item_list()),
+				(sl ? REPORT_EXCEPT_NOT_FOUND :
+				 REPORT_ALL_ERRORS))) ==
 	(Item **)not_found_item)
     {
       /*
@@ -850,8 +858,10 @@ bool Item_ref::fix_fields(THD *thd,TABLE_LIST *tables, Item **reference)
       else if (ref == (Item **)not_found_item)
       {
 	// Call to report error
-	find_item_in_list(this, thd->lex.select->item_list, REPORT_ALL_ERRORS);
-        ref=0;
+	find_item_in_list(this,
+			  *(thd->lex.current_select->get_item_list()),
+			  REPORT_ALL_ERRORS);
+        ref= 0;
 	return 1;
       }
       else
@@ -861,19 +871,25 @@ bool Item_ref::fix_fields(THD *thd,TABLE_LIST *tables, Item **reference)
 	  Mark all selects from resolved to 1 before select where was
 	  found table as depended (of select where was found table)
 	*/
-	for (SELECT_LEX *s= thd->lex.select;
+	for (SELECT_LEX_NODE *s= thd->lex.current_select;
 	     s &&s != last;
 	     s= s->outer_select())
-	  if( !s->depended )
+	  if( !s->dependent )
 	  {
 	    // Select is depended of outer select
-	    s->depended= s->master_unit()->depended= 1;
-	    //Tables will be reopened many times
-	    for (TABLE_LIST *tbl=
-		   (TABLE_LIST*)s->table_list.first;
-		 tbl;
-		 tbl= tbl->next)
-	      tbl->shared= 1;
+	    s->dependent= 1;
+	    if (s->linkage != GLOBAL_OPTIONS_TYPE)
+	    { 
+              //s is st_select_lex*
+
+	      s->master_unit()->dependent= 1;
+	      //Tables will be reopened many times
+	      for (TABLE_LIST *tbl=
+		     s->get_table_list();
+		   tbl;
+		   tbl= tbl->next)
+		tbl->shared= 1;
+	    }
 	  }
       }
     }

sql/item_subselect.cc

@@ -252,8 +252,8 @@ int subselect_single_select_engine::prepare()
   if (prepared)
     return 0;
   prepared= 1;
-  SELECT_LEX *save_select= thd->lex.select;
-  thd->lex.select= select_lex;
+  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,
 		   select_lex->where,
 		   (ORDER*) select_lex->order_list.first,
@@ -262,7 +262,7 @@ int subselect_single_select_engine::prepare()
 		   (ORDER*) 0, select_lex, 
 		   select_lex->master_unit(), 0))
     return 1;
-  thd->lex.select= save_select;
+  thd->lex.current_select= save_select;
   return 0;
 }
 
@@ -310,7 +310,7 @@ int subselect_single_select_engine::exec()
       DBUG_RETURN(join->error?join->error:1);
     }
   }
-  if (select_lex->depended && executed)
+  if (select_lex->dependent && executed)
   {
     if (join->reinit())
       DBUG_RETURN(1);
@@ -319,10 +319,10 @@ int subselect_single_select_engine::exec()
   }
   if (!executed)
   {
-    SELECT_LEX *save_select= join->thd->lex.select;
-    join->thd->lex.select= select_lex;
+    SELECT_LEX_NODE *save_select= join->thd->lex.current_select;
+    join->thd->lex.current_select= select_lex;
     join->exec();
-    join->thd->lex.select= save_select;
+    join->thd->lex.current_select= save_select;
     executed= 1;
     DBUG_RETURN(join->error||thd->fatal_error);
   }
@@ -346,10 +346,10 @@ uint subselect_union_engine::cols()
 
 bool subselect_single_select_engine::depended()
 {
-  return select_lex->depended;
+  return select_lex->dependent;
 }
 
 bool subselect_union_engine::depended()
 {
-  return unit->depended;
+  return unit->dependent;
 }

sql/item_sum.cc

@@ -943,7 +943,10 @@ bool Item_sum_count_distinct::fix_fields(THD *thd, TABLE_LIST *tables,
 bool Item_sum_count_distinct::setup(THD *thd)
 {
   List<Item> list;
-  SELECT_LEX *select_lex= current_lex->select;
+  SELECT_LEX *select_lex= (SELECT_LEX *)current_lex->current_select;
+  if (select_lex->linkage == GLOBAL_OPTIONS_TYPE)
+    return 1;
+    
   /* Create a table with an unique key over all parameters */
   for (uint i=0; i < arg_count ; i++)
   {

sql/mysql_priv.h

@@ -539,11 +539,6 @@ bool add_field_to_list(char *field_name, enum enum_field_types type,
 		       char *change, TYPELIB *interval,CHARSET_INFO *cs);
 void store_position_for_column(const char *name);
 bool add_to_list(SQL_LIST &list,Item *group,bool asc=0);
-TABLE_LIST *add_table_to_list(Table_ident *table,LEX_STRING *alias,
-			      bool updating,
-			      thr_lock_type flags=TL_UNLOCK,
-			      List<String> *use_index=0,
-			      List<String> *ignore_index=0);
 void add_join_on(TABLE_LIST *b,Item *expr);
 void add_join_natural(TABLE_LIST *a,TABLE_LIST *b);
 bool add_proc_to_list(Item *item);
@@ -564,8 +559,8 @@ int setup_fields(THD *thd,TABLE_LIST *tables,List<Item> &item,
 		 bool set_query_id,List<Item> *sum_func_list,
 		 bool allow_sum_func);
 int setup_conds(THD *thd,TABLE_LIST *tables,COND **conds);
-int setup_ftfuncs(THD *thd);
-int init_ftfuncs(THD *thd, bool no_order);
+int setup_ftfuncs(SELECT_LEX* select);
+int init_ftfuncs(THD *thd, SELECT_LEX* select, bool no_order);
 void wait_for_refresh(THD *thd);
 int open_tables(THD *thd,TABLE_LIST *tables);
 int open_and_lock_tables(THD *thd,TABLE_LIST *tables);
@@ -852,19 +847,19 @@ Item *get_system_var(enum_var_type var_type, const char *var_name, uint length,
 
 inline bool add_item_to_list(Item *item)
 {
-  return current_lex->select->item_list.push_back(item);
+  return current_lex->current_select->add_item_to_list(item);
 }
 inline bool add_value_to_list(Item *value)
 {
   return current_lex->value_list.push_back(value);
 }
-inline bool add_order_to_list(Item *item,bool asc)
+inline bool add_order_to_list(Item *item, bool asc)
 {
-  return add_to_list(current_lex->select->order_list,item,asc);
+  return current_lex->current_select->add_order_to_list(item, asc);
 }
-inline bool add_group_to_list(Item *item,bool asc)
+inline bool add_group_to_list(Item *item, bool asc)
 {
-  return add_to_list(current_lex->select->group_list,item,asc);
+  return current_lex->current_select->add_group_to_list(item, asc);
 }
 inline void mark_as_null_row(TABLE *table)
 {

sql/sql_base.cc

@@ -2448,10 +2448,10 @@ bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
   DBUG_RETURN(result);
 }
 
-int setup_ftfuncs(THD *thd)
+int setup_ftfuncs(SELECT_LEX *select_lex)
 {
-  List_iterator<Item_func_match> li(*(thd->lex.select->ftfunc_list)),
-                                 lj(*(thd->lex.select->ftfunc_list));
+  List_iterator<Item_func_match> li(*(select_lex->ftfunc_list)),
+                                 lj(*(select_lex->ftfunc_list));
   Item_func_match *ftf, *ftf2;
 
   while ((ftf=li++))
@@ -2470,11 +2470,11 @@ int setup_ftfuncs(THD *thd)
 }
 
 
-int init_ftfuncs(THD *thd, bool no_order)
+int init_ftfuncs(THD *thd, SELECT_LEX *select_lex, bool no_order)
 {
-  if (thd->lex.select->ftfunc_list->elements)
+  if (select_lex->ftfunc_list->elements)
   {
-    List_iterator<Item_func_match> li(*(thd->lex.select->ftfunc_list));
+    List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
     Item_func_match *ifm;
     DBUG_PRINT("info",("Performing FULLTEXT search"));
     thd->proc_info="FULLTEXT initialization";

sql/sql_cache.cc

@@ -2444,14 +2444,14 @@ TABLE_COUNTER_TYPE Query_cache::is_cacheable(THD *thd, uint32 query_len,
 
   if (lex->sql_command == SQLCOM_SELECT &&
       (thd->variables.query_cache_type == 1 ||
-       (thd->variables.query_cache_type == 2 && (lex->select->options &
+       (thd->variables.query_cache_type == 2 && (lex->select_lex.options &
 						 OPTION_TO_QUERY_CACHE))) &&
       thd->safe_to_cache_query)
   {
     my_bool has_transactions = 0;
     DBUG_PRINT("qcache", ("options %lx %lx, type %u",
 			OPTION_TO_QUERY_CACHE,
-			lex->select->options,
+			lex->select_lex.options,
 			(int) thd->variables.query_cache_type));
 
     for (; tables_used; tables_used= tables_used->next)
@@ -2498,7 +2498,7 @@ TABLE_COUNTER_TYPE Query_cache::is_cacheable(THD *thd, uint32 query_len,
 	     ("not interesting query: %d or not cacheable, options %lx %lx, type %u",
 	      (int) lex->sql_command,
 	      OPTION_TO_QUERY_CACHE,
-	      lex->select->options,
+	      lex->select_lex.options,
 	      (int) thd->variables.query_cache_type));
   DBUG_RETURN(0);
 }

sql/sql_delete.cc

@@ -52,7 +52,8 @@ int mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds, ORDER *order,
   table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
   thd->proc_info="init";
   table->map=1;
-  if (setup_conds(thd,table_list,&conds) || setup_ftfuncs(thd))
+  if (setup_conds(thd,table_list,&conds) || 
+      setup_ftfuncs(&thd->lex.select_lex))
     DBUG_RETURN(-1);
 
   /* Test if the user wants to delete all rows */
@@ -129,7 +130,7 @@ int mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds, ORDER *order,
 
   init_read_record(&info,thd,table,select,1,1);
   deleted=0L;
-  init_ftfuncs(thd,1);
+  init_ftfuncs(thd, &thd->lex.select_lex, 1);
   thd->proc_info="updating";
   while (!(error=info.read_record(&info)) && !thd->killed)
   {
@@ -284,7 +285,11 @@ multi_delete::initialize_tables(JOIN *join)
 				     table->file->ref_length,
 				     MEM_STRIP_BUF_SIZE);
   }
-  init_ftfuncs(thd,1);
+  /*
+    There are (SELECT_LEX*) pointer conversion here global union parameters
+    can't be used in multidelete
+  */
+  init_ftfuncs(thd, (SELECT_LEX*)thd->lex.current_select, 1);
 }
 
 

sql/sql_lex.cc

@@ -147,7 +147,7 @@ LEX *lex_start(THD *thd, uchar *buf,uint length)
   lex->select_lex.in_sum_expr=0;
   lex->select_lex.expr_list.empty();
   lex->select_lex.ftfunc_list_alloc.empty();
-  lex->select_lex.ftfunc_list= &lex->select->ftfunc_list_alloc;
+  lex->select_lex.ftfunc_list= &lex->select_lex.ftfunc_list_alloc;
   lex->convert_set= (lex->thd= thd)->variables.convert_set;
   lex->yacc_yyss=lex->yacc_yyvs=0;
   lex->ignore_space=test(thd->sql_mode & MODE_IGNORE_SPACE);
@@ -934,7 +934,8 @@ void st_select_lex_node::init_select()
   order_list.first= 0;
   order_list.next= (byte**) &order_list.first;
   select_limit= HA_POS_ERROR;
-  offset_limit= 0; 
+  offset_limit= 0;
+  create_refs= dependent= 0;
 }
 
 void st_select_lex_unit::init_query()
@@ -974,7 +975,7 @@ void st_select_lex::init_select()
   ftfunc_list_alloc.empty();
   ftfunc_list= &ftfunc_list_alloc;
   linkage= UNSPECIFIED_TYPE;
-  depended= having_fix_field= 0;
+  having_fix_field= 0;
 }
 
 /*
@@ -1042,6 +1043,44 @@ void st_select_lex_node::exclude()
   */
 }
 
+bool st_select_lex_node::add_item_to_list(Item *item)
+{
+  return 1;
+}
+
+bool  st_select_lex_node::add_group_to_list(Item *item, bool asc)
+{
+  return 1; 
+}
+
+//why compiler/linker do not allow make it inline?
+bool st_select_lex_node::add_order_to_list(Item *item, bool asc)
+{ 
+  return add_to_list(order_list,item,asc);
+}
+
+bool st_select_lex_node::add_ftfunc_to_list(Item_func_match *func)
+{
+  return 1;
+}
+
+bool st_select_lex_node::set_braces(bool value)      { return 1; }
+bool st_select_lex_node::inc_in_sum_expr()           { return 1; }
+uint st_select_lex_node::get_in_sum_expr()           { return 0; }
+TABLE_LIST* st_select_lex_node::get_table_list()     { return 0; }
+List<Item>* st_select_lex_node::get_item_list()      { return 0; }
+List<String>* st_select_lex_node::get_use_index()    { return 0; }
+List<String>* st_select_lex_node::get_ignore_index() { return 0; }
+TABLE_LIST *st_select_lex_node::add_table_to_list(Table_ident *table,
+						  LEX_STRING *alias,
+						  bool updating,
+						  thr_lock_type flags,
+						  List<String> *use_index,
+						  List<String> *ignore_index)
+{
+  return 0;
+}
+
 /*
   This is used for UNION & subselect to create a new table list of all used 
   tables.
@@ -1118,3 +1157,78 @@ bool st_select_lex_unit::create_total_list_n_last_return(THD *thd, st_lex *lex,
   *result= new_table_list;
   return 0;
 }
+
+st_select_lex_unit* st_select_lex_unit::master_unit()
+{
+    return this;
+}
+
+st_select_lex* st_select_lex_unit::outer_select()
+{
+  return (st_select_lex*) master;
+}
+
+
+bool st_select_lex::add_item_to_list(Item *item)
+{
+  return item_list.push_back(item);
+}
+
+bool st_select_lex::add_group_to_list(Item *item, bool asc)
+{
+  return add_to_list(group_list, item, asc);
+}
+
+bool st_select_lex::add_ftfunc_to_list(Item_func_match *func)
+{
+  return !func || ftfunc_list->push_back(func); // end of memory?
+}
+
+st_select_lex_unit* st_select_lex::master_unit()
+{
+  return (st_select_lex_unit*) master;
+}
+
+st_select_lex* st_select_lex::outer_select()
+{
+  return (st_select_lex*) master->get_master();
+}
+
+bool st_select_lex::set_braces(bool value)
+{
+  braces= value;
+  return 0; 
+}
+
+bool st_select_lex::inc_in_sum_expr()
+{
+  in_sum_expr++;
+  return 0;
+}
+
+uint st_select_lex::get_in_sum_expr()
+{
+  return in_sum_expr;
+}
+
+TABLE_LIST* st_select_lex::get_table_list()
+{
+  return (TABLE_LIST*) table_list.first;
+}
+
+List<Item>* st_select_lex::get_item_list()
+{
+  return &item_list;
+}
+
+List<String>* st_select_lex::get_use_index()
+{
+  return use_index_ptr;
+}
+
+List<String>* st_select_lex::get_ignore_index()
+{
+  return ignore_index_ptr;
+}
+
+// There are st_select_lex::add_table_to_list in sql_parse.cc

sql/sql_lex.h

@@ -186,6 +186,8 @@ enum olap_type
     Base class for st_select_lex (SELECT_LEX) & 
     st_select_lex_unit (SELECT_LEX_UNIT)
 */
+class st_select_lex;
+class st_select_lex_unit;
 class st_select_lex_node {
 protected:
   st_select_lex_node *next, **prev,   /* neighbor list */
@@ -195,23 +197,58 @@ public:
   ulong options;
   enum sub_select_type linkage;
   SQL_LIST order_list;                /* ORDER clause */
+  List<List_item>     expr_list;
+  List<List_item>     when_list;      /* WHEN clause (expression) */
   ha_rows select_limit, offset_limit; /* LIMIT clause parameters */
-  void init_query();
-  void init_select();
+  bool	create_refs;
+  bool dependent;	/* dependent from outer select subselect */
+
+  static void *operator new(size_t size)
+  {
+    return (void*) sql_calloc((uint) size);
+  }
+  static void operator delete(void *ptr,size_t size) {}
+  virtual ~st_select_lex_node() {}
+  inline st_select_lex_node* get_master() { return master; }
+  virtual void init_query();
+  virtual void init_select();
   void include_down(st_select_lex_node *upper);
   void include_neighbour(st_select_lex_node *before);
   void include_global(st_select_lex_node **plink);
   void exclude();
+
+  virtual bool add_item_to_list(Item *item);
+  bool add_order_to_list(Item *item, bool asc);
+  virtual bool add_group_to_list(Item *item, bool asc);
+  virtual bool add_ftfunc_to_list(Item_func_match *func);
+
+  virtual st_select_lex_unit* master_unit()= 0;
+  virtual st_select_lex* outer_select()= 0;
+
+  virtual bool set_braces(bool value);
+  virtual bool inc_in_sum_expr();
+  virtual uint get_in_sum_expr();
+  virtual TABLE_LIST* get_table_list();
+  virtual List<Item>* get_item_list();
+  virtual List<String>* get_use_index();
+  virtual List<String>* get_ignore_index();
+  virtual TABLE_LIST *add_table_to_list(Table_ident *table,
+					LEX_STRING *alias,
+					bool updating,
+					thr_lock_type flags= TL_UNLOCK,
+					List<String> *use_index= 0,
+					List<String> *ignore_index= 0);
+  
 private:
   void fast_exclude();
 };
+typedef class st_select_lex_node SELECT_LEX_NODE;
 
 /* 
    SELECT_LEX_UNIT - unit of selects (UNION, INTERSECT, ...) group 
    SELECT_LEXs
 */
 struct st_lex;
-class st_select_lex;
 class THD;
 class select_result;
 class JOIN;
@@ -238,14 +275,14 @@ public:
   st_select_lex_node *global_parameters;
   /* LIMIT clause runtime counters */
   ha_rows select_limit_cnt, offset_limit_cnt;
-  bool depended; /* depended from outer select subselect */
   /* not NULL if union used in subselect, point to subselect item */
   Item_subselect *item;
   uint union_option;
 
   void init_query();
   bool create_total_list(THD *thd, st_lex *lex, TABLE_LIST **result);
-  st_select_lex* outer_select() { return (st_select_lex*) master; }
+  st_select_lex_unit* master_unit();
+  st_select_lex* outer_select();
   st_select_lex* first_select() { return (st_select_lex*) slave; }
   st_select_lex_unit* next_unit() { return (st_select_lex_unit*) next; }
 
@@ -270,8 +307,6 @@ public:
   char *db, *db1, *table1, *db2, *table2;      	/* For outer join using .. */
   Item *where, *having;                         /* WHERE & HAVING clauses */
   enum olap_type olap;
-  List<List_item>     expr_list;
-  List<List_item>     when_list;                /* WHEN clause */
   SQL_LIST	      table_list, group_list;   /* FROM & GROUP BY clauses */
   List<Item>          item_list; /* list of fields & expressions */
   List<String>        interval_list, use_index, *use_index_ptr,
@@ -286,23 +321,18 @@ public:
   const char *type; /* type of select for EXPLAIN */
   uint in_sum_expr;
   uint select_number; /* number of select (used for EXPLAIN) */
-  bool	create_refs;
   bool  braces;   	/* SELECT ... UNION (SELECT ... ) <- this braces */
-  bool depended;	/* depended from outer select subselect */
   /* TRUE when having fix field called in processing of this SELECT */
   bool having_fix_field;
 
   void init_query();
   void init_select();
-  st_select_lex_unit* master_unit() { return (st_select_lex_unit*) master; }
+  st_select_lex_unit* master_unit();
   st_select_lex_unit* first_inner_unit() 
   { 
     return (st_select_lex_unit*) slave; 
   }
-  st_select_lex* outer_select() 
-  { 
-    return (st_select_lex*) master_unit()->outer_select(); 
-  }
+  st_select_lex* outer_select();
   st_select_lex* next_select() { return (st_select_lex*) next; }
   st_select_lex*  next_select_in_list() 
   {
@@ -313,6 +343,25 @@ public:
     return &link_next;
   }
 
+  bool set_braces(bool value);
+  bool inc_in_sum_expr();
+  uint get_in_sum_expr();
+  bool add_item_to_list(Item *item);
+  bool add_group_to_list(Item *item, bool asc);
+  bool add_ftfunc_to_list(Item_func_match *func);
+
+  TABLE_LIST* get_table_list();
+  List<Item>* get_item_list();
+  List<String>* get_use_index();
+  List<String>* get_ignore_index();
+  TABLE_LIST* add_table_to_list(Table_ident *table,
+				LEX_STRING *alias,
+				bool updating,
+				thr_lock_type flags= TL_UNLOCK,
+				List<String> *use_index= 0,
+				List<String> *ignore_index= 0);
+
+  
   friend void mysql_init_query(THD *thd);
 };
 typedef class st_select_lex SELECT_LEX;
@@ -325,9 +374,9 @@ typedef struct st_lex
   uint	 yylineno,yytoklen;			/* Simulate lex */
   LEX_YYSTYPE yylval;
   SELECT_LEX_UNIT unit;                         /* most upper unit */
-  SELECT_LEX select_lex,                        /* first SELECT_LEX */
-    /* current SELECT_LEX in parsing */
-    *select;
+  SELECT_LEX select_lex;                        /* first SELECT_LEX */
+  /* current SELECT_LEX in parsing */
+  SELECT_LEX_NODE *current_select;
   uchar *ptr,*tok_start,*tok_end,*end_of_query;
   char *length,*dec,*change,*name;
   char *backup_dir;				/* For RESTORE/BACKUP */

sql/sql_parse.cc

@@ -2911,9 +2911,9 @@ mysql_init_query(THD *thd)
   thd->select_number= thd->lex.select_lex.select_number= 1;
   thd->lex.value_list.empty();
   thd->free_list= 0;
-  thd->lex.select= &thd->lex.select_lex;
+  thd->lex.current_select= &thd->lex.select_lex;
   thd->lex.olap=thd->lex.describe=0;
-  thd->lex.select->olap= UNSPECIFIED_OLAP_TYPE;
+  thd->lex.select_lex.olap= UNSPECIFIED_OLAP_TYPE;
   thd->fatal_error= 0;				// Safety
   thd->total_warn_count=0;			// Warnings for this query
   thd->last_insert_id_used= thd->query_start_used= thd->insert_id_used=0;
@@ -2927,7 +2927,8 @@ mysql_init_query(THD *thd)
 void
 mysql_init_select(LEX *lex)
 {
-  SELECT_LEX *select_lex= lex->select;
+  SELECT_LEX *select_lex= (SELECT_LEX *)lex->current_select;
+  DBUG_ASSERT(select_lex->linkage != GLOBAL_OPTIONS_TYPE);
   select_lex->init_select();
   select_lex->master_unit()->select_limit= select_lex->select_limit= 
     lex->thd->variables.select_limit;
@@ -2941,7 +2942,7 @@ mysql_init_select(LEX *lex)
 bool
 mysql_new_select(LEX *lex, bool move_down)
 {
-  SELECT_LEX *select_lex = (SELECT_LEX *) lex->thd->calloc(sizeof(SELECT_LEX));
+  SELECT_LEX *select_lex = new SELECT_LEX();
   select_lex->select_number= ++lex->thd->select_number;
   if (!select_lex)
     return 1;
@@ -2950,21 +2951,22 @@ mysql_new_select(LEX *lex, bool move_down)
   if (move_down)
   {
     /* first select_lex of subselect or derived table */
-    SELECT_LEX_UNIT *unit= 
-      (SELECT_LEX_UNIT *) lex->thd->calloc(sizeof(SELECT_LEX_UNIT));
+    SELECT_LEX_UNIT *unit= new SELECT_LEX_UNIT();
     if (!unit)
       return 1;
     unit->init_query();
     unit->init_select();
-    unit->include_down(lex->select);
+    unit->include_down(lex->current_select);
     select_lex->include_down(unit);
   }
   else
-    select_lex->include_neighbour(lex->select);
+    select_lex->include_neighbour(lex->current_select);
     
   select_lex->master_unit()->global_parameters= select_lex;
-  select_lex->include_global(lex->select->next_select_in_list_addr());
-  lex->select= select_lex;
+  DBUG_ASSERT(lex->current_select->linkage != GLOBAL_OPTIONS_TYPE);
+  select_lex->include_global(((SELECT_LEX*)lex->current_select)->
+			     next_select_in_list_addr());
+  lex->current_select= select_lex;
   return 0;
 }
 
@@ -3000,10 +3002,10 @@ void mysql_init_multi_delete(LEX *lex)
 {
   lex->sql_command=  SQLCOM_DELETE_MULTI;
   mysql_init_select(lex);
-  lex->select->select_limit= lex->select->master_unit()->select_limit_cnt=
+  lex->select_lex.select_limit= lex->unit.select_limit_cnt=
     HA_POS_ERROR;
   lex->auxilliary_table_list= lex->select_lex.table_list;
-  lex->select->init_query();
+  lex->select_lex.init_query();
 }
 
 
@@ -3413,12 +3415,12 @@ bool add_to_list(SQL_LIST &list,Item *item,bool asc)
 }
 
 
-TABLE_LIST *add_table_to_list(Table_ident *table, LEX_STRING *alias,
-			      bool updating,
-			      thr_lock_type flags,
-			      List<String> *use_index,
-			      List<String> *ignore_index
-			      )
+TABLE_LIST *st_select_lex::add_table_to_list(Table_ident *table,
+					     LEX_STRING *alias,
+					     bool updating,
+					     thr_lock_type flags,
+					     List<String> *use_index,
+					     List<String> *ignore_index)
 {
   register TABLE_LIST *ptr;
   THD	*thd=current_thd;
@@ -3480,7 +3482,7 @@ TABLE_LIST *add_table_to_list(Table_ident *table, LEX_STRING *alias,
   /* check that used name is unique */
   if (flags != TL_IGNORE)
   {
-    for (TABLE_LIST *tables=(TABLE_LIST*) thd->lex.select->table_list.first ;
+    for (TABLE_LIST *tables=(TABLE_LIST*) table_list.first ;
 	 tables ;
 	 tables=tables->next)
     {
@@ -3491,7 +3493,7 @@ TABLE_LIST *add_table_to_list(Table_ident *table, LEX_STRING *alias,
       }
     }
   }
-  link_in_list(&thd->lex.select->table_list,(byte*) ptr,(byte**) &ptr->next);
+  link_in_list(&table_list, (byte*) ptr, (byte**) &ptr->next);
   DBUG_RETURN(ptr);
 }
 
@@ -3694,7 +3696,7 @@ static bool append_file_to_dir(THD *thd, char **filename_ptr, char *table_name)
 bool check_simple_select()
 {
   THD *thd= current_thd;
-  if (thd->lex.select != &thd->lex.select_lex)
+  if (thd->lex.current_select != &thd->lex.select_lex)
   {
     char command[80];
     strmake(command, thd->lex.yylval->symbol.str,

sql/sql_prepare.cc

@@ -497,7 +497,7 @@ static bool mysql_test_select_fields(PREP_STMT *stmt, TABLE_LIST *tables,
     if (having->with_sum_func)
       having->split_sum_func(all_fields);
   }
-  if (setup_ftfuncs(thd)) 
+  if (setup_ftfuncs(&thd->lex.select_lex)) 
     DBUG_RETURN(1);
 
   /* 
@@ -543,7 +543,7 @@ static bool send_prepare_results(PREP_STMT *stmt)
   stmt->free_list= thd->free_list;		// Save items used in stmt
   thd->free_list= 0;
 
-  SELECT_LEX *select_lex = lex->select;
+  SELECT_LEX *select_lex = &lex->select_lex;
   TABLE_LIST *tables=(TABLE_LIST*) select_lex->table_list.first;
   
   switch (sql_command) {

sql/sql_repl.cc

@@ -949,8 +949,8 @@ int show_binlog_events(THD* thd)
     LOG_INFO linfo;
     Log_event* ev;
   
-    limit_start = thd->lex.select->offset_limit;
-    limit_end = thd->lex.select->select_limit + limit_start;
+    limit_start = thd->lex.current_select->offset_limit;
+    limit_end = thd->lex.current_select->select_limit + limit_start;
 
     name= search_file_name;
     if (log_file_name)

sql/sql_select.cc

@@ -38,7 +38,8 @@ static bool make_join_statistics(JOIN *join,TABLE_LIST *tables,COND *conds,
 				 DYNAMIC_ARRAY *keyuse);
 static bool update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,
 				JOIN_TAB *join_tab,
-                                uint tables,COND *conds,table_map table_map);
+                                uint tables, COND *conds,
+				table_map table_map, SELECT_LEX *select_lex);
 static int sort_keyuse(KEYUSE *a,KEYUSE *b);
 static void set_position(JOIN *join,uint index,JOIN_TAB *table,KEYUSE *key);
 static bool create_ref_for_key(JOIN *join, JOIN_TAB *j, KEYUSE *org_keyuse,
@@ -250,7 +251,7 @@ JOIN::prepare(TABLE_LIST *tables_init,
     if (having->with_sum_func)
       having->split_sum_func(all_fields);
   }
-  if (setup_ftfuncs(thd)) /* should be after having->fix_fields */
+  if (setup_ftfuncs(select_lex)) /* should be after having->fix_fields */
     DBUG_RETURN(-1);
   /*
     Check if one one uses a not constant column with group functions
@@ -420,7 +421,7 @@ JOIN::optimize()
       thd->fatal_error)
     DBUG_RETURN(-1);
 
-  if (select_lex->depended)
+  if (select_lex->dependent)
   {
     /*
       Just remove all const-table optimization in case of depended query
@@ -559,7 +560,7 @@ JOIN::optimize()
   make_join_readinfo(this,
 		     (select_options & (SELECT_DESCRIBE |
 					SELECT_NO_JOIN_CACHE)) |
-		     (thd->lex.select->ftfunc_list->elements ? 
+		     (select_lex->ftfunc_list->elements ? 
 		      SELECT_NO_JOIN_CACHE : 0));
 
   /*
@@ -720,7 +721,7 @@ JOIN::exec()
   }
 
   /* Perform FULLTEXT search before all regular searches */
-  init_ftfuncs(thd,test(order));
+  init_ftfuncs(thd, select_lex, test(order));
 
   /* Create a tmp table if distinct or if the sort is too complicated */
   if (need_tmp)
@@ -1239,8 +1240,8 @@ make_join_statistics(JOIN *join,TABLE_LIST *tables,COND *conds,
   }
 
   if (conds || outer_join)
-    if (update_ref_and_keys(join->thd,keyuse_array,stat,join->tables,
-                            conds,~outer_join))
+    if (update_ref_and_keys(join->thd, keyuse_array, stat, join->tables,
+                            conds, ~outer_join, join->select_lex))
       DBUG_RETURN(1);
 
   /* Read tables with 0 or 1 rows (system tables) */
@@ -1800,7 +1801,8 @@ sort_keyuse(KEYUSE *a,KEYUSE *b)
 
 static bool
 update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,
-		    uint tables, COND *cond, table_map normal_tables)
+		    uint tables, COND *cond, table_map normal_tables,
+		    SELECT_LEX *select_lex)
 {
   uint	and_level,i,found_eq_constant;
 
@@ -1828,7 +1830,7 @@ update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,
       add_key_part(keyuse,field);
   }
 
-  if (thd->lex.select->ftfunc_list->elements)
+  if (select_lex->ftfunc_list->elements)
   {
     add_ft_keys(keyuse,join_tab,cond,normal_tables);
   }
@@ -2930,7 +2932,7 @@ join_free(JOIN *join)
       end_read_record(&tab->read_record);
     }
     //TODO: is enough join_free at the end of mysql_select?
-    if (!join->select_lex->depended)
+    if (!join->select_lex->dependent)
       join->table=0;
   }
   /*
@@ -7460,9 +7462,9 @@ int mysql_explain_union(THD *thd, SELECT_LEX_UNIT *unit, select_result *result)
 			       ((sl->next_select_in_list())?"PRIMARY":
 				"SIMPLE"):
 			       ((sl == first)?
-				((sl->depended)?"DEPENDENT SUBSELECT":
+				((sl->dependent)?"DEPENDENT SUBSELECT":
 				 "SUBSELECT"):
-				((sl->depended)?"DEPENDENT UNION":
+				((sl->dependent)?"DEPENDENT UNION":
 				 "UNION"))),
 			      result);
     if (res)
@@ -7480,7 +7482,7 @@ int mysql_explain_select(THD *thd, SELECT_LEX *select_lex, char const *type,
   DBUG_ENTER("mysql_explain_select");
   DBUG_PRINT("info", ("Select 0x%lx, type %s", (ulong)select_lex, type))
   select_lex->type= type;
-  thd->lex.select= select_lex;
+  thd->lex.current_select= select_lex;
   SELECT_LEX_UNIT *unit=  select_lex->master_unit();
   int res= mysql_select(thd,(TABLE_LIST*) select_lex->table_list.first,
 			select_lex->item_list,

sql/sql_union.cc

@@ -115,7 +115,8 @@ int st_select_lex_unit::prepare(THD *thd, select_result *result)
   TMP_TABLE_PARAM tmp_table_param;
   this->thd= thd;
   this->result= result;
-  SELECT_LEX *lex_select_save= thd->lex.select, *sl;
+  SELECT_LEX_NODE *lex_select_save= thd->lex.current_select;
+  SELECT_LEX *sl;
 
   /* Global option */
   if (((void*)(global_parameters)) == ((void*)this))
@@ -169,7 +170,7 @@ int st_select_lex_unit::prepare(THD *thd, select_result *result)
 			 sl->options | thd->options | SELECT_NO_UNLOCK,
 			 union_result);
     joins.push_back(new JOIN_P(join));
-    thd->lex.select=sl;
+    thd->lex.current_select= sl;
     offset_limit_cnt= sl->offset_limit;
     select_limit_cnt= sl->select_limit+sl->offset_limit;
     if (select_limit_cnt < sl->select_limit)
@@ -188,29 +189,29 @@ int st_select_lex_unit::prepare(THD *thd, select_result *result)
     if (res | thd->fatal_error)
       goto err;
   }
-  thd->lex.select= lex_select_save;
+  thd->lex.current_select= lex_select_save;
   DBUG_RETURN(res | thd->fatal_error);
 err:
-  thd->lex.select= lex_select_save;
+  thd->lex.current_select= lex_select_save;
   DBUG_RETURN(-1);
 }
 
 int st_select_lex_unit::exec()
 {
   DBUG_ENTER("st_select_lex_unit::exec");
-  SELECT_LEX *lex_select_save= thd->lex.select;
+  SELECT_LEX_NODE *lex_select_save= thd->lex.current_select;
   
-  if (executed && !depended)
+  if (executed && !dependent)
     DBUG_RETURN(0);
   executed= 1;
   
-  if (depended || !item || !item->assigned())
+  if (dependent || !item || !item->assigned())
   {
     if (optimized && item && item->assigned())
       item->assigned(0); // We will reinit & rexecute unit
     for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
     {
-      thd->lex.select=sl;
+      thd->lex.current_select= sl;
       offset_limit_cnt= sl->offset_limit;
       select_limit_cnt= sl->select_limit+sl->offset_limit;
       if (select_limit_cnt < sl->select_limit)
@@ -230,7 +231,7 @@ int st_select_lex_unit::exec()
       }
       if (res)
       {
-	thd->lex.select= lex_select_save;
+	thd->lex.current_select= lex_select_save;
 	DBUG_RETURN(res);
       }
     }
@@ -239,12 +240,14 @@ int st_select_lex_unit::exec()
 
   if (union_result->flush())
   {
-    thd->lex.select= lex_select_save;
+    thd->lex.current_select= lex_select_save;
     DBUG_RETURN(1);
   }
 
   /* Send result to 'result' */
-  thd->lex.select = first_select();
+
+  // to correct ORDER BY reference resolving
+  thd->lex.current_select = first_select();
   res =-1;
   {
     /* Create a list of fields in the temporary table */
@@ -283,7 +286,7 @@ int st_select_lex_unit::exec()
     }
   }
   thd->lex.select_lex.ftfunc_list= &thd->lex.select_lex.ftfunc_list_alloc;
-  thd->lex.select= lex_select_save;
+  thd->lex.current_select= lex_select_save;
   DBUG_RETURN(res);
 }
 

sql/sql_update.cc

@@ -78,7 +78,7 @@ int mysql_update(THD *thd,
   want_privilege=table->grant.want_privilege;
   table->grant.want_privilege=(SELECT_ACL & ~table->grant.privilege);
   if (setup_tables(table_list) || setup_conds(thd,table_list,&conds)
-                               || setup_ftfuncs(thd))
+                               || setup_ftfuncs(&thd->lex.select_lex))
     DBUG_RETURN(-1);				/* purecov: inspected */
   old_used_keys=table->used_keys;		// Keys used in WHERE
 
@@ -142,7 +142,7 @@ int mysql_update(THD *thd,
       DBUG_RETURN(1);
     }
   }
-  init_ftfuncs(thd,1);
+  init_ftfuncs(thd, &thd->lex.select_lex, 1);
   /* Check if we are modifying a key that we are used to search with */
   if (select && select->quick)
     used_key_is_modified= (!select->quick->unique_key_range() &&
@@ -508,7 +508,14 @@ multi_update::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
       counter++;
     }
   }
-  init_ftfuncs(thd,1);
+  /*
+    
+    There are (SELECT_LEX*) pointer conversion here global union parameters
+    can't be used in multiupdate
+
+    TODO: check is thd->lex.current_select == &thd->lex.select_lex?
+  */
+  init_ftfuncs(thd, (SELECT_LEX*)thd->lex.current_select, 1);
   error = 0; // Timestamps do not need to be restored, so far ...
   DBUG_RETURN(0);
 }