1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
fixed error code in union test


mysql-test/t/union.test:
  right code worr 4.1 error
sql/log_event.cc:
  assign non-cachable for Item status for all stack tables for safety
sql/repl_failsafe.cc:
  assign non-cachable for Item status for all stack tables for safety
sql/slave.cc:
  assign non-cachable for Item status for all stack tables for safety
sql/sql_acl.cc:
  assign non-cachable for Item status for all stack tables for safety
sql/sql_base.cc:
  assign non-cachable for Item status for all stack tables for safety
  non-cachable status processing
sql/sql_cache.cc:
  assign non-cachable for Item status for all stack tables for safety
sql/sql_class.cc:
  removed ald way to prevent using stack tables for caching Items in PS
sql/sql_class.h:
  removed old way to prevent using stack tables for caching Items in PS
sql/sql_help.cc:
  assign non-cachable for Item status for all stack tables for safety
sql/sql_insert.cc:
  assign non-cachable for Item status for all stack tables for safety
  removed old way to prevent using stack tables for caching Items in PS
sql/table.h:
  non-cachable for Item status for tables
This commit is contained in:
unknown 2004-04-04 03:05:44 +03:00
parent e65aed9cbd
commit 3c01162f0e
12 changed files with 34 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
mysql-test/t/union.test
View File

@ -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;

1
sql/log_event.cc
View File

@ -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))
{

1
sql/repl_failsafe.cc
View File

@ -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;
}

1
sql/slave.cc
View File

@ -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 */
{

15
sql/sql_acl.cc
View File

@ -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
/*

8
sql/sql_base.cc
View File

@ -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

1
sql/sql_cache.cc
View File

@ -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))
{

1
sql/sql_class.cc
View File

@ -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)

6
sql/sql_class.h
View File

@ -787,12 +787,6 @@ public:
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

8
sql/sql_help.cc
View File

@ -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;

7
sql/sql_insert.cc
View File

@ -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);

1
sql/table.h
View File

@ -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