mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-16 03:52:35 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

After merge fixes

Browse source 
Added push_back(void *, MEM_ROOT *) to make some list-handling code easier that needs to be allocated in a different mem-root
(Before one had to change thd->mem_root ; push_back(); restore mem_root.


mysql-test/t/range.test:
  After merge fixRecR
sql/item_func.cc:
  After merge fix
sql/item_sum.cc:
  After merge fix
sql/opt_range.cc:
  After merge fix
sql/parse_file.cc:
  After merge fix
sql/sp.cc:
  After merge fix
sql/sp_head.cc:
  After merge fix
sql/sp_head.h:
  After merge fix
sql/sql_base.cc:
  After merge fix
sql/sql_class.h:
  After merge fix
sql/sql_list.h:
  Added push_back(void *, MEM_ROOT *) to make some list-handling code easier that needs to be allocated in a different mem-root
  (Before one had to change thd->mem_root ; push_back(); restore mem_root.
sql/sql_prepare.cc:
  After merge fix
sql/sql_select.cc:
  After merge fix
sql/sql_table.cc:
  After merge fix
  Fixed problem with OPTIMIZE on INNODB tables
sql/sql_trigger.cc:
  After merge fix
sql/sql_union.cc:
  After merge fix
sql/sql_view.cc:
  After merge fix
sql/sql_yacc.yy:
  After merge fix
sql/table.cc:
  After merge fix
This commit is contained in:
unknown 2004-11-09 03:58:44 +02:00
parent 47a5ac0e30
commit db67626196
19 changed files with 91 additions and 101 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
mysql-test/t/range.test
View file

@ -432,3 +432,4 @@ explain select * from t1 where a=binary 'aaa';
explain select * from t1 where a='aaa' collate latin1_bin;
# this one cannot:
explain select * from t1 where a='aaa' collate latin1_german1_ci;
drop table t1;

2
sql/item_func.cc
View file

@ -3514,7 +3514,7 @@ Item_func_sp::func_name() const
1 + // .
1 + // end of string
ALIGN_SIZE(1)); // to avoid String reallocation
String qname((char *)alloc_root(&thd->mem_root, len), len,
String qname((char *)alloc_root(thd->mem_root, len), len,
system_charset_info);
qname.length(0);

2
sql/item_sum.cc
View file

@ -313,7 +313,7 @@ Item_sum_sum_distinct::~Item_sum_sum_distinct()
Item *
Item_sum_sum_distinct::copy_or_same(THD *thd)
{
return new (&thd->mem_root) Item_sum_sum_distinct(thd, this);
return new (thd->mem_root) Item_sum_sum_distinct(thd, this);
}
C_MODE_START

4
sql/opt_range.cc
View file

@ -1041,7 +1041,7 @@ QUICK_ROR_UNION_SELECT::QUICK_ROR_UNION_SELECT(THD *thd_param,
rowid_length= table->file->ref_length;
record= head->record[0];
init_sql_alloc(&alloc, thd->variables.range_alloc_block_size, 0);
thd_param->malloc= &alloc;
thd_param->mem_root= &alloc;
}
@ -7497,7 +7497,7 @@ QUICK_GROUP_MIN_MAX_SELECT(TABLE *table, JOIN *join_arg, bool have_min_arg,
if (!parent_alloc)
{
init_sql_alloc(&alloc, join->thd->variables.range_alloc_block_size, 0);
thd->mem_root= &alloc;
join->thd->mem_root= &alloc;
}
else
bzero(&alloc, sizeof(MEM_ROOT)); // ensure that it's not used

26
sql/parse_file.cc
View file

@ -608,15 +608,13 @@ parse_quoted_escaped_string(char *ptr, char *end,
my_bool
File_parser::parse(gptr base, MEM_ROOT *mem_root,
struct File_option *parameters, uint required)
struct File_option *parameters, uint required)
{
uint first_param= 0, found= 0;
register char *ptr= start;
char *eol;
LEX_STRING *str;
MEM_ROOT *sql_mem;
List<LEX_STRING> *list;
bool change_mem;
DBUG_ENTER("File_parser::parse");
while (ptr < end && found < required)
@ -720,18 +718,7 @@ File_parser::parse(gptr base, MEM_ROOT *mem_root,
}
case FILE_OPTIONS_STRLIST:
{
/*
TODO: remove play with mem_root, when List will be able
to store MEM_ROOT* pointer for list elements allocation
FIXME: we can't handle empty lists
*/
sql_mem= my_pthread_getspecific_ptr(MEM_ROOT*, THR_MALLOC);
list= (List<LEX_STRING>*)(base + parameter->offset);
if ((change_mem= (sql_mem != mem_root)))
{
change_mem= 1;
my_pthread_setspecific_ptr(THR_MALLOC, mem_root);
}
list= (List<LEX_STRING>*)(base + parameter->offset);
list->empty();
// list parsing
@ -739,7 +726,7 @@ File_parser::parse(gptr base, MEM_ROOT *mem_root,
{
if (!(str= (LEX_STRING*)alloc_root(mem_root,
sizeof(LEX_STRING))) ||
list->push_back(str))
list->push_back(str, mem_root))
goto list_err;
if(!(ptr= parse_quoted_escaped_string(ptr, end, mem_root, str)))
goto list_err_w_message;
@ -754,20 +741,15 @@ File_parser::parse(gptr base, MEM_ROOT *mem_root,
goto list_err_w_message;
}
}
end_of_list:
end_of_list:
if (*(ptr++) != '\n')
goto list_err;
if (change_mem)
my_pthread_setspecific_ptr(THR_MALLOC, sql_mem);
break;
list_err_w_message:
my_error(ER_FPARSER_ERROR_IN_PARAMETER, MYF(0),
parameter->name.str, line);
list_err:
if (change_mem)
my_pthread_setspecific_ptr(THR_MALLOC, sql_mem);
DBUG_RETURN(TRUE);
}
default:

22
sql/sp.cc
View file

@ -166,7 +166,7 @@ db_find_routine(THD *thd, int type, sp_name *name, sp_head **sphp)
}
bzero((char *)&chistics, sizeof(chistics));
if ((ptr= get_field(&thd->mem_root,
if ((ptr= get_field(thd->mem_root,
table->field[MYSQL_PROC_FIELD_ACCESS])) == NULL)
{
ret= SP_GET_FIELD_FAILED;
@ -189,7 +189,7 @@ db_find_routine(THD *thd, int type, sp_name *name, sp_head **sphp)
chistics.daccess= SP_CONTAINS_SQL;
}
if ((ptr= get_field(&thd->mem_root,
if ((ptr= get_field(thd->mem_root,
table->field[MYSQL_PROC_FIELD_DETERMINISTIC])) == NULL)
{
ret= SP_GET_FIELD_FAILED;
@ -197,7 +197,7 @@ db_find_routine(THD *thd, int type, sp_name *name, sp_head **sphp)
}
chistics.detistic= (ptr[0] == 'N' ? FALSE : TRUE);
if ((ptr= get_field(&thd->mem_root,
if ((ptr= get_field(thd->mem_root,
table->field[MYSQL_PROC_FIELD_SECURITY_TYPE])) == NULL)
{
ret= SP_GET_FIELD_FAILED;
@ -205,7 +205,7 @@ db_find_routine(THD *thd, int type, sp_name *name, sp_head **sphp)
}
chistics.suid= (ptr[0] == 'I' ? SP_IS_NOT_SUID : SP_IS_SUID);
if ((params= get_field(&thd->mem_root,
if ((params= get_field(thd->mem_root,
table->field[MYSQL_PROC_FIELD_PARAM_LIST])) == NULL)
{
params= "";
@ -213,14 +213,14 @@ db_find_routine(THD *thd, int type, sp_name *name, sp_head **sphp)
if (type == TYPE_ENUM_PROCEDURE)
returns= "";
else if ((returns= get_field(&thd->mem_root,
else if ((returns= get_field(thd->mem_root,
table->field[MYSQL_PROC_FIELD_RETURNS])) == NULL)
{
ret= SP_GET_FIELD_FAILED;
goto done;
}
if ((body= get_field(&thd->mem_root,
if ((body= get_field(thd->mem_root,
table->field[MYSQL_PROC_FIELD_BODY])) == NULL)
{
ret= SP_GET_FIELD_FAILED;
@ -228,7 +228,7 @@ db_find_routine(THD *thd, int type, sp_name *name, sp_head **sphp)
}
// Get additional information
if ((definer= get_field(&thd->mem_root,
if ((definer= get_field(thd->mem_root,
table->field[MYSQL_PROC_FIELD_DEFINER])) == NULL)
{
ret= SP_GET_FIELD_FAILED;
@ -511,10 +511,10 @@ print_field_values(THD *thd, TABLE *table,
String name_string;
struct st_used_field *used_field= used_fields;
if (get_field(&thd->mem_root, used_field->field, &db_string))
if (get_field(thd->mem_root, used_field->field, &db_string))
db_string.set_ascii("", 0);
used_field+= 1;
get_field(&thd->mem_root, used_field->field, &name_string);
get_field(thd->mem_root, used_field->field, &name_string);
if (!wild || !wild[0] || !wild_compare(name_string.ptr(), wild, 0))
{
@ -539,7 +539,7 @@ print_field_values(THD *thd, TABLE *table,
{
String tmp_string;
get_field(&thd->mem_root, used_field->field, &tmp_string);
get_field(thd->mem_root, used_field->field, &tmp_string);
protocol->store(&tmp_string);
}
break;
@ -982,7 +982,7 @@ sp_cache_functions(THD *thd, LEX *lex)
newlex->proc_table= oldlex->proc_table; // hint if mysql.oper is opened
name.m_name.str= strchr(name.m_qname.str, '.');
name.m_db.length= name.m_name.str - name.m_qname.str;
name.m_db.str= strmake_root(&thd->mem_root,
name.m_db.str= strmake_root(thd->mem_root,
name.m_qname.str, name.m_db.length);
name.m_name.str+= 1;
name.m_name.length= name.m_qname.length - name.m_db.length - 1;

28
sql/sp_head.cc
View file

@ -190,7 +190,7 @@ void
sp_name::init_qname(THD *thd)
{
m_qname.length= m_db.length+m_name.length+1;
m_qname.str= alloc_root(&thd->mem_root, m_qname.length+1);
m_qname.str= thd->alloc(m_qname.length+1);
sprintf(m_qname.str, "%*s.%*s",
m_db.length, (m_db.length ? m_db.str : ""),
m_name.length, m_name.str);
@ -232,10 +232,9 @@ sp_head::operator new(size_t size)
MEM_ROOT own_root;
sp_head *sp;
bzero((char *)&own_root, sizeof(own_root));
init_alloc_root(&own_root, MEM_ROOT_BLOCK_SIZE, MEM_ROOT_PREALLOC);
sp= (sp_head *)alloc_root(&own_root, size);
sp->mem_root= own_root;
sp= (sp_head *) alloc_root(&own_root, size);
sp->main_mem_root= own_root;
DBUG_PRINT("info", ("mem_root 0x%lx", (ulong) &sp->mem_root));
DBUG_RETURN(sp);
}
@ -245,9 +244,10 @@ sp_head::operator delete(void *ptr, size_t size)
{
DBUG_ENTER("sp_head::operator delete");
MEM_ROOT own_root;
sp_head *sp= (sp_head *)ptr;
sp_head *sp= (sp_head *) ptr;
memcpy(&own_root, (const void *)&sp->mem_root, sizeof(MEM_ROOT));
/* Make a copy of main_mem_root as free_root will free the sp */
own_root= sp->main_mem_root;
DBUG_PRINT("info", ("mem_root 0x%lx moved to 0x%lx",
(ulong) &sp->mem_root, (ulong) &own_root));
free_root(&own_root, MYF(0));
@ -291,7 +291,7 @@ sp_head::init_strings(THD *thd, LEX *lex, sp_name *name)
DBUG_ENTER("sp_head::init_strings");
uint n; /* Counter for nul trimming */
/* During parsing, we must use thd->mem_root */
MEM_ROOT *root= &thd->mem_root;
MEM_ROOT *root= thd->mem_root;
/* We have to copy strings to get them into the right memroot */
if (name)
@ -916,19 +916,19 @@ sp_head::set_info(char *definer, uint definerlen,
if (! p)
p= definer; // Weird...
len= p-definer;
m_definer_user.str= strmake_root(&mem_root, definer, len);
m_definer_user.str= strmake_root(mem_root, definer, len);
m_definer_user.length= len;
len= definerlen-len-1;
m_definer_host.str= strmake_root(&mem_root, p+1, len);
m_definer_host.str= strmake_root(mem_root, p+1, len);
m_definer_host.length= len;
m_created= created;
m_modified= modified;
m_chistics= (st_sp_chistics *)alloc_root(&mem_root, sizeof(st_sp_chistics));
memcpy(m_chistics, chistics, sizeof(st_sp_chistics));
m_chistics= (st_sp_chistics *) memdup_root(mem_root, (char*) chistics,
sizeof(*chistics));
if (m_chistics->comment.length == 0)
m_chistics->comment.str= 0;
else
m_chistics->comment.str= strmake_root(&mem_root,
m_chistics->comment.str= strmake_root(mem_root,
m_chistics->comment.str,
m_chistics->comment.length);
m_sql_mode= sql_mode;
@ -939,14 +939,14 @@ sp_head::reset_thd_mem_root(THD *thd)
{
DBUG_ENTER("sp_head::reset_thd_mem_root");
m_thd_root= thd->mem_root;
thd->mem_root= mem_root;
thd->mem_root= &main_mem_root;
DBUG_PRINT("info", ("mem_root 0x%lx moved to thd mem root 0x%lx",
(ulong) &mem_root, (ulong) &thd->mem_root));
free_list= thd->free_list; // Keep the old list
thd->free_list= NULL; // Start a new one
/* Copy the db, since substatements will point to it */
m_thd_db= thd->db;
thd->db= strmake_root(&thd->mem_root, thd->db, thd->db_length);
thd->db= thd->strmake(thd->db, thd->db_length);
m_thd= thd;
DBUG_VOID_RETURN;
}

2
sql/sp_head.h
View file

@ -231,7 +231,7 @@ public:
private:
MEM_ROOT m_thd_root; // Temp. store for thd's mem_root
MEM_ROOT *m_thd_root; // Temp. store for thd's mem_root
THD *m_thd; // Set if we have reset mem_root
char *m_thd_db; // Original thd->db pointer

9
sql/sql_base.cc
View file

@ -815,7 +815,7 @@ TABLE *reopen_name_locked_table(THD* thd, TABLE_LIST* table_list)
pthread_mutex_lock(&LOCK_open);
if (open_unireg_entry(thd, table, db, table_name, table_name, 0,
&thd->mem_root) ||
thd->mem_root) ||
!(table->table_cache_key =memdup_root(&table->mem_root,(char*) key,
key_length)))
{
@ -1135,7 +1135,7 @@ bool reopen_table(TABLE *table,bool locked)
safe_mutex_assert_owner(&LOCK_open);
if (open_unireg_entry(table->in_use, &tmp, db, table_name,
table->table_name, 0, &table->in_use->mem_root))
table->table_name, 0, table->in_use->mem_root))
goto end;
free_io_cache(table);
@ -1774,7 +1774,7 @@ TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type lock_type)
thd->current_tablenr= 0;
/* open_ltable can be used only for BASIC TABLEs */
table_list->required_type= FRMTYPE_TABLE;
while (!(table= open_table(thd, table_list, &thd->mem_root, &refresh)) &&
while (!(table= open_table(thd, table_list, thd->mem_root, &refresh)) &&
refresh)
;
@ -2999,7 +2999,8 @@ insert_fields(THD *thd, TABLE_LIST *tables, const char *db_name,
during cleunup() this item will be put in list to replace
expression from VIEW
*/
thd->nocheck_register_item_tree_change(it->ref(), item, &thd->mem_root);
thd->nocheck_register_item_tree_change(it->ref(), item,
thd->mem_root);
}
}
/* All fields are used */

2
sql/sql_class.h
View file

@ -1174,7 +1174,7 @@ public:
use new arena if we are in a prepared statements and we have not
already changed to use this arena.
*/
if (current_arena->is_stmt_prepare() &&
if (!current_arena->is_conventional() &&
mem_root != &current_arena->main_mem_root)
{
set_n_backup_item_arena(current_arena, backup);

12
sql/sql_list.h
View file

@ -113,6 +113,16 @@ public:
}
return 1;
}
inline bool push_back(void *info, MEM_ROOT *mem_root)
{
if (((*last)=new (mem_root) list_node(info, &end_of_list)))
{
last= &(*last)->next;
elements++;
return 0;
}
return 1;
}
inline bool push_front(void *info)
{
list_node *node=new list_node(info,first);
@ -284,6 +294,8 @@ public:
inline List() :base_list() {}
inline List(const List<T> &tmp) :base_list(tmp) {}
inline bool push_back(T *a) { return base_list::push_back(a); }
inline bool push_back(T *a, MEM_ROOT *mem_root)
{ return base_list::push_back(a, mem_root); }
inline bool push_front(T *a) { return base_list::push_front(a); }
inline T* head() {return (T*) base_list::head(); }
inline T** head_ref() {return (T**) base_list::head_ref(); }

8
sql/sql_prepare.cc
View file

@ -1828,7 +1828,7 @@ void mysql_stmt_execute(THD *thd, char *packet, uint packet_length)
{
DBUG_PRINT("info",("Using READ_ONLY cursor"));
if (!stmt->cursor &&
!(stmt->cursor= new (&stmt->mem_root) Cursor()))
!(stmt->cursor= new (&stmt->main_mem_root) Cursor()))
{
send_error(thd, ER_OUT_OF_RESOURCES);
DBUG_VOID_RETURN;
@ -2013,7 +2013,12 @@ static void execute_stmt(THD *thd, Prepared_statement *stmt,
/*
COM_FETCH handler: fetches requested amount of rows from cursor
SYNOPSIS
mysql_stmt_fetch()
thd Thread handler
packet Packet from client (with stmt_id & num_rows)
packet_length Length of packet
*/
void mysql_stmt_fetch(THD *thd, char *packet, uint packet_length)
@ -2023,7 +2028,6 @@ void mysql_stmt_fetch(THD *thd, char *packet, uint packet_length)
ulong num_rows= uint4korr(packet+=4);
Statement *stmt;
int error;
DBUG_ENTER("mysql_stmt_fetch");
if (!(stmt= thd->stmt_map.find(stmt_id)) ||

30
sql/sql_select.cc
View file

@ -1497,7 +1497,6 @@ JOIN::exec()
are fixed or do not need fix_fields, too
*/
curr_table->select->cond->quick_fix_field();
cur_tabl
}
curr_table->select_cond= curr_table->select->cond;
curr_table->select_cond->top_level_item();
@ -1653,9 +1652,13 @@ Cursor::init_from_thd(THD *thd)
/*
We need to save and reset thd->mem_root, otherwise it'll be freed
later in mysql_parse.
We can't just change the thd->mem_root here as we want to keep the things
that is already allocated in thd->mem_root for Cursor::fetch()
*/
mem_root= thd->mem_root;
init_sql_alloc(&thd->mem_root,
main_mem_root= *thd->mem_root;
/* Allocate new memory root for thd */
init_sql_alloc(thd->mem_root,
thd->variables.query_alloc_block_size,
thd->variables.query_prealloc_size);
@ -1669,7 +1672,7 @@ Cursor::init_from_thd(THD *thd)
open_tables= thd->open_tables;
lock= thd->lock;
query_id= thd->query_id;
free_list= thd->free_list;
free_list= thd->free_list;
reset_thd(thd);
/*
XXX: thd->locked_tables is not changed.
@ -1684,8 +1687,11 @@ Cursor::init_from_thd(THD *thd)
void
Cursor::init_thd(THD *thd)
{
thd->mem_root= mem_root;
/*
Use the original mem_root, in which we store all memory allocated
during the lifetime of the cursor.
*/
thd->mem_root= &main_mem_root;
DBUG_ASSERT(thd->derived_tables == 0);
thd->derived_tables= derived_tables;
@ -1773,11 +1779,10 @@ int
Cursor::fetch(ulong num_rows)
{
THD *thd= join->thd;
JOIN_TAB *join_tab= join->join_tab + join->const_tables;;
JOIN_TAB *join_tab= join->join_tab + join->const_tables;
COND *on_expr= *join_tab->on_expr_ref;
COND *select_cond= join_tab->select_cond;
READ_RECORD *info= &join_tab->read_record;
int error= 0;
join->fetch_limit+= num_rows;
@ -1853,7 +1858,6 @@ Cursor::fetch(ulong num_rows)
::send_eof(thd);
thd->server_status&= ~SERVER_STATUS_CURSOR_EXISTS;
/* save references to memory, allocated during fetch */
mem_root= thd->mem_root;
free_list= thd->free_list;
break;
/* Limit clause worked: this is the same as 'no more rows' */
@ -1875,8 +1879,7 @@ Cursor::fetch(ulong num_rows)
Must be last, as some memory might be allocated for free purposes,
like in free_tmp_table() (TODO: fix this issue)
*/
mem_root= thd->mem_root;
free_root(&mem_root, MYF(0));
free_root(&main_mem_root, MYF(0));
break;
default:
close();
@ -1888,8 +1891,7 @@ Cursor::fetch(ulong num_rows)
Must be last, as some memory might be allocated for free purposes,
like in free_tmp_table() (TODO: fix this issue)
*/
mem_root= thd->mem_root;
free_root(&mem_root, MYF(0));
free_root(&main_mem_root, MYF(0));
break;
}
return error;
@ -1940,7 +1942,7 @@ Cursor::~Cursor()
Must be last, as some memory might be allocated for free purposes,
like in free_tmp_table() (TODO: fix this issue)
*/
free_root(&mem_root, MYF(0));
free_root(&main_mem_root, MYF(0));
}
/*********************************************************************/

6
sql/sql_table.cc
View file

@ -1401,7 +1401,7 @@ TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
create_info, *extra_fields, *keys, 0,
select_field_count))
{
if (!(table= open_table(thd, create_table, &thd->mem_root, (bool*) 0)))
if (!(table= open_table(thd, create_table, thd->mem_root, (bool*) 0)))
quick_rm_table(create_info->db_type, create_table->db,
table_case_name(create_info, create_table->real_name));
}
@ -3077,7 +3077,7 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name,
bzero((void*) &tbl, sizeof(tbl));
tbl.db= new_db;
tbl.real_name= tbl.alias= tmp_name;
new_table= open_table(thd, &tbl, &thd->mem_root, 0);
new_table= open_table(thd, &tbl, thd->mem_root, 0);
}
else
{
@ -3516,6 +3516,8 @@ int mysql_recreate_table(THD *thd, TABLE_LIST *table_list,
create_info.db_type=DB_TYPE_DEFAULT;
create_info.row_type=ROW_TYPE_DEFAULT;
create_info.default_table_charset=default_charset_info;
/* Force alter table to recreate table */
lex->alter_info.flags= ALTER_CHANGE_COLUMN;
DBUG_RETURN(mysql_alter_table(thd, NullS, NullS, &create_info,
table_list, lex->create_list,
lex->key_list, 0, (ORDER *) 0,

22
sql/sql_trigger.cc
View file

@ -134,7 +134,6 @@ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables)
TABLE *table= tables->table;
char dir_buff[FN_REFLEN], file_buff[FN_REFLEN];
LEX_STRING dir, file;
MEM_ROOT *old_global_root;
LEX_STRING *trg_def, *name;
List_iterator_fast<LEX_STRING> it(names_list);
@ -168,9 +167,6 @@ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables)
triggers_file_ext, NullS) - file_buff;
file.str= file_buff;
old_global_root= my_pthread_getspecific_ptr(MEM_ROOT*, THR_MALLOC);
my_pthread_setspecific_ptr(THR_MALLOC, &table->mem_root);
/*
Soon we will invalidate table object and thus Table_triggers_list object
so don't care about place to which trg_def->ptr points and other
@ -181,17 +177,12 @@ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables)
*/
if (!(trg_def= (LEX_STRING *)alloc_root(&table->mem_root,
sizeof(LEX_STRING))) ||
definitions_list.push_back(trg_def))
{
my_pthread_setspecific_ptr(THR_MALLOC, old_global_root);
definitions_list.push_back(trg_def, &table->mem_root))
return 1;
}
trg_def->str= thd->query;
trg_def->length= thd->query_length;
my_pthread_setspecific_ptr(THR_MALLOC, old_global_root);
return sql_create_definition_file(&dir, &file, &triggers_file_type,
(gptr)this, triggers_file_parameters, 3);
}
@ -302,7 +293,6 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db,
char path_buff[FN_REFLEN];
LEX_STRING path;
File_parser *parser;
MEM_ROOT *old_global_mem_root;
DBUG_ENTER("Table_triggers_list::check_n_load");
@ -406,14 +396,9 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db,
trg_name_str->str= trg_name_buff;
trg_name_str->length= lex.name_and_length.length;
old_global_mem_root= my_pthread_getspecific_ptr(MEM_ROOT*, THR_MALLOC);
my_pthread_setspecific_ptr(THR_MALLOC, &table->mem_root);
if (triggers->names_list.push_back(trg_name_str))
if (triggers->names_list.push_back(trg_name_str, &table->mem_root))
goto err_with_lex_cleanup;
my_pthread_setspecific_ptr(THR_MALLOC, old_global_mem_root);
lex_end(&lex);
}
thd->lex= old_lex;
@ -431,7 +416,8 @@ err_with_lex_cleanup:
We don't care about this error message much because .TRG files will
be merged into .FRM anyway.
*/
my_error(ER_WRONG_OBJECT, MYF(0), table_name, triggers_file_ext, "TRIGGER");
my_error(ER_WRONG_OBJECT, MYF(0), table_name, triggers_file_ext,
"TRIGGER");
DBUG_RETURN(1);
}

1
sql/sql_union.cc
View file

@ -314,6 +314,7 @@ int st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
thd_arg->lex->current_select= lex_select_save;
if (!item_list.elements)
{
Field **field;
Item_arena *tmp_arena,backup;
tmp_arena= thd->change_arena_if_needed(&backup);

8
sql/sql_view.cc
View file

@ -434,7 +434,7 @@ static int mysql_register_view(THD *thd, TABLE_LIST *view,
DBUG_RETURN(-1);
}
if (!(parser= sql_parse_prepare(&path, &thd->mem_root, 0)))
if (!(parser= sql_parse_prepare(&path, thd->mem_root, 0)))
DBUG_RETURN(1);
if (!parser->ok() ||
@ -451,7 +451,7 @@ static int mysql_register_view(THD *thd, TABLE_LIST *view,
TODO: read dependence list, too, to process cascade/restrict
TODO: special cascade/restrict procedure for alter?
*/
if (parser->parse((gptr)view, &thd->mem_root,
if (parser->parse((gptr)view, thd->mem_root,
view_parameters + revision_number_position, 1))
{
DBUG_RETURN(thd->net.report_error? -1 : 0);
@ -565,7 +565,7 @@ mysql_make_view(File_parser *parser, TABLE_LIST *table)
TODO: when VIEWs will be stored in cache, table mem_root should
be used here
*/
if (parser->parse((gptr)table, &thd->mem_root, view_parameters,
if (parser->parse((gptr)table, thd->mem_root, view_parameters,
required_view_parameters))
goto err;
@ -586,7 +586,7 @@ mysql_make_view(File_parser *parser, TABLE_LIST *table)
now Lex placed in statement memory
*/
table->view= lex= thd->lex= (LEX*) new(&thd->mem_root) st_lex_local;
table->view= lex= thd->lex= (LEX*) new(thd->mem_root) st_lex_local;
lex_start(thd, (uchar*)table->query.str, table->query.length);
lex->select_lex.select_number= ++thd->select_number;
old_lex->derived_tables|= DERIVED_VIEW;

2
sql/sql_yacc.yy
View file

@ -1848,7 +1848,7 @@ sp_proc_stmt:
i->m_query.length= lex->ptr - sp->m_tmp_query;
else
i->m_query.length= lex->tok_end - sp->m_tmp_query;
i->m_query.str= strmake_root(&YYTHD->mem_root,
i->m_query.str= strmake_root(YYTHD->mem_root,
(char *)sp->m_tmp_query,
i->m_query.length);
i->set_lex(lex);

5
sql/table.cc
View file

@ -89,7 +89,8 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat,
error=1;
disk_buff=NULL;
old_root= my_pthread_getspecific_ptr(MEM_ROOT*,THR_MALLOC);
root_ptr= my_pthread_getspecific_ptr(MEM_ROOT**, THR_MALLOC);
old_root= *root_ptr;
if ((file=my_open(fn_format(index_file, name, "", reg_ext,
MY_UNPACK_FILENAME),
@ -123,8 +124,6 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat,
outparam->blob_ptr_size=sizeof(char*);
outparam->db_stat = db_stat;
init_sql_alloc(&outparam->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
root_ptr= my_pthread_getspecific_ptr(MEM_ROOT**, THR_MALLOC);
old_root= *root_ptr;
*root_ptr= &outparam->mem_root;
outparam->real_name=strdup_root(&outparam->mem_root,