removed old way to prevent using stack tables for caching Items in PS

fixed error code in union test

mysql-test/t/union.test

@@ -251,7 +251,7 @@ create temporary table t1 select a from t1 union select a from t2;
 drop temporary table t1;
 --error 1093
 create table t1 select a from t1 union select a from t2;
---error 1054
+--error 1109
 select a from t1 union select a from t2 order by t2.a;
 drop table t1,t2;
 

sql/log_event.cc

@@ -1698,6 +1698,7 @@ int Load_log_event::exec_event(NET* net, struct st_relay_log_info* rli,
     tables.alias = tables.real_name = (char*)table_name;
     tables.lock_type = TL_WRITE;
     tables.updating= 1;
+    tables.non_cachable_table= 1;	// just safety for table on stack
     // the table will be opened in mysql_load    
     if (table_rules_on && !tables_ok(thd, &tables))
     {

sql/repl_failsafe.cc

@@ -736,6 +736,7 @@ static int fetch_db_tables(THD *thd, MYSQL *mysql, const char *db,
       table.db= (char*) db;
       table.real_name= (char*) table_name;
       table.updating= 1;
+      table.non_cachable_table= 1;	// just safety for table on stack
       if (!tables_ok(thd, &table))
 	continue;
     }

sql/slave.cc

@@ -1216,6 +1216,7 @@ static int create_table_from_dump(THD* thd, MYSQL *mysql, const char* db,
   bzero((char*) &tables,sizeof(tables));
   tables.db = (char*)db;
   tables.alias= tables.real_name= (char*)table_name;
+  tables.non_cachable_table= 1;	// just safety for table on stack
   /* Drop the table if 'overwrite' is true */
   if (overwrite && mysql_rm_table(thd,&tables,1,0)) /* drop if exists */
   {

sql/sql_acl.cc

@@ -172,6 +172,9 @@ my_bool acl_init(THD *org_thd, bool dont_read_acl_tables)
   tables[1].next=tables+2;
   tables[0].lock_type=tables[1].lock_type=tables[2].lock_type=TL_READ;
   tables[0].db=tables[1].db=tables[2].db=thd->db;
+  // just safety for table on stack
+  tables[0].non_cachable_table= tables[1].non_cachable_table=
+    tables[2].non_cachable_table= 1;
 
   uint counter;
   if (open_tables(thd, tables, &counter))
@@ -1325,6 +1328,7 @@ static bool update_user_table(THD *thd, const char *host, const char *user,
   bzero((char*) &tables,sizeof(tables));
   tables.alias=tables.real_name=(char*) "user";
   tables.db=(char*) "mysql";
+  tables.non_cachable_table= 1;	// just safety for table on stack
 #ifdef HAVE_REPLICATION
   /*
     GRANT and REVOKE are applied the slave in/exclusion rules as they are
@@ -1382,6 +1386,7 @@ static bool test_if_create_new_users(THD *thd)
     bzero((char*) &tl,sizeof(tl));
     tl.db=	   (char*) "mysql";
     tl.real_name=  (char*) "user";
+    tl.non_cachable_table= 1;	// just safety for table on stack
     db_access=acl_get(thd->host, thd->ip,
 		      thd->priv_user, tl.db, 0);
     if (!(db_access & INSERT_ACL))
@@ -2233,6 +2238,9 @@ int mysql_table_grant(THD *thd, TABLE_LIST *table_list,
 		  ? tables+2 : 0);
   tables[0].lock_type=tables[1].lock_type=tables[2].lock_type=TL_WRITE;
   tables[0].db=tables[1].db=tables[2].db=(char*) "mysql";
+  // just safety for table on stack
+  tables[0].non_cachable_table= tables[1].non_cachable_table=
+    tables[2].non_cachable_table= 1;
 
 #ifdef HAVE_REPLICATION
   /*
@@ -2407,6 +2415,8 @@ int mysql_grant(THD *thd, const char *db, List <LEX_USER> &list,
   tables[0].lock_type=tables[1].lock_type=TL_WRITE;
   tables[0].db=tables[1].db=(char*) "mysql";
   tables[0].table=tables[1].table=0;
+  // just safety for table on stack
+  tables[0].non_cachable_table= tables[1].non_cachable_table= 1;
 
 #ifdef HAVE_REPLICATION
   /*
@@ -2526,6 +2536,8 @@ my_bool grant_init(THD *org_thd)
   tables[0].next=tables+1;
   tables[0].lock_type=tables[1].lock_type=TL_READ;
   tables[0].db=tables[1].db=thd->db;
+  // just safety for table on stack
+  tables[0].non_cachable_table= tables[1].non_cachable_table= 1;
 
   uint counter;
   if (open_tables(thd, tables, &counter))
@@ -3363,6 +3375,9 @@ int open_grant_tables(THD *thd, TABLE_LIST *tables)
   tables->lock_type= (tables+1)->lock_type=
     (tables+2)->lock_type= (tables+3)->lock_type= TL_WRITE;
   tables->db= (tables+1)->db= (tables+2)->db= (tables+3)->db=(char*) "mysql";
+  // just safety for table on stack
+  tables[0].non_cachable_table= tables[1].non_cachable_table=
+    tables[2].non_cachable_table= tables[3].non_cachable_table=1;
 
 #ifdef HAVE_REPLICATION
   /*

sql/sql_base.cc

@@ -156,6 +156,7 @@ OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *wild)
     table_list.db= (char*) entry->table_cache_key;
     table_list.real_name= entry->real_name;
     table_list.grant.privilege=0;
+    table_list.non_cachable_table= 1;	// just safety for table on stack
     if (check_table_access(thd,SELECT_ACL | EXTRA_ACL,&table_list,1))
       continue;
     /* need to check if we haven't already listed it */
@@ -1332,6 +1333,7 @@ static int open_unireg_entry(THD *thd, TABLE *entry, const char *db,
     bzero((char*) &table_list, sizeof(table_list)); // just for safe
     table_list.db=(char*) db;
     table_list.real_name=(char*) name;
+    table_list.non_cachable_table= 1;	// just safety for table on stack
     safe_mutex_assert_owner(&LOCK_open);
 
     if ((error=lock_table_name(thd,&table_list)))
@@ -1886,7 +1888,7 @@ find_field_in_tables(THD *thd, Item_ident *item, TABLE_LIST *tables,
   char name_buff[NAME_LEN+1];
 
 
-  if (!thd->no_table_fix_fields_cache && item->cached_table)
+  if (item->cached_table)
   {
     /*
       This shortcut is used by prepared statements. We assuming that 
@@ -1939,6 +1941,8 @@ find_field_in_tables(THD *thd, Item_ident *item, TABLE_LIST *tables,
 	if (find)
 	{
 	  (*where)= item->cached_table= tables;
+	  if (tables->non_cachable_table)
+	    item->cached_table= 0;
 	  if (find == WRONG_GRANT)
 	    return (Field*) 0;
 	  if (db || !thd->where)
@@ -1998,6 +2002,8 @@ find_field_in_tables(THD *thd, Item_ident *item, TABLE_LIST *tables,
       if (field == WRONG_GRANT)
 	return (Field*) 0;
       (*where)= item->cached_table= tables;
+      if (tables->non_cachable_table)
+	item->cached_table= 0;
       if (found)
       {
 	if (!thd->where)			// Returns first found

sql/sql_cache.cc

@@ -1022,6 +1022,7 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length)
     Query_cache_table *table = block_table->parent;
     table_list.db = table->db();
     table_list.alias= table_list.real_name= table->table();
+    table_list.non_cachable_table= 1;	// just safety for table on stack
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
     if (check_table_access(thd,SELECT_ACL,&table_list,1))
     {

sql/sql_class.cc

@@ -84,7 +84,6 @@ extern "C" void free_user_var(user_var_entry *entry)
 ****************************************************************************/
 
 THD::THD():user_time(0), current_statement(0), is_fatal_error(0),
-	   no_table_fix_fields_cache(0),
 	   last_insert_id_used(0),
 	   insert_id_used(0), rand_used(0), in_lock_tables(0),
 	   global_read_lock(0), bootstrap(0)

sql/sql_class.h

@@ -787,12 +787,6 @@ class THD :public ilink,
   bool	     charset_is_system_charset, charset_is_collation_connection;
   bool       slow_command;
 
-  /*
-    Used in prepared statement to prevent using table/field cache in
-    Item_idend, bacuse it can point on removed table.
-  */
-  bool	     no_table_fix_fields_cache;
-
   /*
     If we do a purge of binary logs, log index info of the threads
     that are currently reading it needs to be adjusted. To do that

sql/sql_help.cc

@@ -659,20 +659,20 @@ int mysqld_help(THD *thd, const char *mask)
   bzero((gptr)tables,sizeof(tables));
   tables[0].alias= tables[0].real_name= (char*) "help_topic";
   tables[0].lock_type= TL_READ;
-  tables[0].db= (char*) "mysql";
   tables[0].next= &tables[1];
   tables[1].alias= tables[1].real_name= (char*) "help_category";
   tables[1].lock_type= TL_READ;
-  tables[1].db= (char*) "mysql";
   tables[1].next= &tables[2];
   tables[2].alias= tables[2].real_name= (char*) "help_relation";
   tables[2].lock_type= TL_READ;
-  tables[2].db= (char*) "mysql";
   tables[2].next=  &tables[3];
   tables[3].alias= tables[3].real_name= (char*) "help_keyword";
   tables[3].lock_type= TL_READ;
-  tables[3].db= (char*) "mysql";
   tables[3].next= 0;
+  tables[0].db= tables[1].db= tables[2].db= tables[3].db= (char*) "mysql";
+  // just safety for table on stack
+  tables[0].non_cachable_table= tables[1].non_cachable_table=
+    tables[2].non_cachable_table= tables[3].non_cachable_table= 1;
   
   List<String> topics_list, categories_list, subcategories_list;
   String name, description, example;

sql/sql_insert.cc

@@ -82,16 +82,13 @@ check_insert_fields(THD *thd,TABLE *table,List<Item> &fields,
     table_list.real_name= table_list.alias= table->table_name;
     table_list.table=table;
     table_list.grant=table->grant;
+    table_list.non_cachable_table= 1;
 
     thd->dupp_field=0;
-    thd->no_table_fix_fields_cache= 1;
     if (setup_tables(&table_list) ||
 	setup_fields(thd, 0, &table_list,fields,1,0,0))
-    {
-      thd->no_table_fix_fields_cache= 0;
       return -1;
-    }
-    thd->no_table_fix_fields_cache= 0;
+
     if (thd->dupp_field)
     {
       my_error(ER_FIELD_SPECIFIED_TWICE,MYF(0), thd->dupp_field->field_name);

sql/table.h

@@ -193,6 +193,7 @@ typedef struct st_table_list
   bool          updating;               /* for replicate-do/ignore table */
   bool		force_index;		/* Prefer index over table scan */
   bool          ignore_leaves;          /* Preload only non-leaf nodes */
+  bool		non_cachable_table;	/* stop PS caching */
 } TABLE_LIST;
 
 typedef struct st_changed_table_list