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

made lex a pointer in THD

Browse Source
This commit is contained in:
unknown 2003-05-05 14:54:37 -04:00
parent 0e89178661
commit b9121cdea3
31 changed files with 219 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sql/filesort.cc
View File

@ -1110,7 +1110,7 @@ get_addon_fields(THD *thd, Field **ptabfield, uint sortlength, uint *plength)
The fact is the filter 'field->query_id != thd->query_id' The fact is the filter 'field->query_id != thd->query_id'
doesn't work for alter table doesn't work for alter table
*/ */
if (thd->lex.sql_command != SQLCOM_SELECT) if (thd->lex->sql_command != SQLCOM_SELECT)
return 0; return 0;
for (pfield= ptabfield; (field= *pfield) ; pfield++) for (pfield= ptabfield; (field= *pfield) ; pfield++)
{ {

8
sql/ha_innodb.cc
View File

@ -1938,8 +1938,8 @@ ha_innobase::write_row(
build_template(prebuilt, NULL, table, ROW_MYSQL_WHOLE_ROW); build_template(prebuilt, NULL, table, ROW_MYSQL_WHOLE_ROW);
} }
if (user_thd->lex.sql_command == SQLCOM_INSERT if (user_thd->lex->sql_command == SQLCOM_INSERT
&& user_thd->lex.duplicates == DUP_IGNORE) { && user_thd->lex->duplicates == DUP_IGNORE) {
prebuilt->trx->ignore_duplicates_in_insert = TRUE; prebuilt->trx->ignore_duplicates_in_insert = TRUE;
} else { } else {
prebuilt->trx->ignore_duplicates_in_insert = FALSE; prebuilt->trx->ignore_duplicates_in_insert = FALSE;
@ -1967,8 +1967,8 @@ ha_innobase::write_row(
skip_auto_inc_decr = FALSE; skip_auto_inc_decr = FALSE;
if (error == DB_DUPLICATE_KEY if (error == DB_DUPLICATE_KEY
&& (user_thd->lex.sql_command == SQLCOM_REPLACE && (user_thd->lex->sql_command == SQLCOM_REPLACE
|| user_thd->lex.sql_command || user_thd->lex->sql_command
== SQLCOM_REPLACE_SELECT)) { == SQLCOM_REPLACE_SELECT)) {
skip_auto_inc_decr= TRUE; skip_auto_inc_decr= TRUE;

4
sql/ha_myisam.cc
View File

@ -388,7 +388,7 @@ int ha_myisam::analyze(THD *thd, HA_CHECK_OPT* check_opt)
int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt) int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt)
{ {
HA_CHECK_OPT tmp_check_opt; HA_CHECK_OPT tmp_check_opt;
char* backup_dir = thd->lex.backup_dir; char* backup_dir = thd->lex->backup_dir;
char src_path[FN_REFLEN], dst_path[FN_REFLEN]; char src_path[FN_REFLEN], dst_path[FN_REFLEN];
char* table_name = table->real_name; char* table_name = table->real_name;
int error; int error;
@ -428,7 +428,7 @@ int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt)
int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt) int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt)
{ {
char* backup_dir = thd->lex.backup_dir; char* backup_dir = thd->lex->backup_dir;
char src_path[FN_REFLEN], dst_path[FN_REFLEN]; char src_path[FN_REFLEN], dst_path[FN_REFLEN];
char* table_name = table->real_name; char* table_name = table->real_name;
int error; int error;

24
sql/item.cc
View File

@ -779,7 +779,7 @@ bool Item_field::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
Item **refer= (Item **)not_found_item; Item **refer= (Item **)not_found_item;
uint counter; uint counter;
// Prevent using outer fields in subselects, that is not supported now // Prevent using outer fields in subselects, that is not supported now
SELECT_LEX *cursel=(SELECT_LEX *) thd->lex.current_select; SELECT_LEX *cursel=(SELECT_LEX *) thd->lex->current_select;
if (outer_resolving || if (outer_resolving ||
cursel->master_unit()->first_select()->linkage != DERIVED_TABLE_TYPE) cursel->master_unit()->first_select()->linkage != DERIVED_TABLE_TYPE)
for (SELECT_LEX *sl=(outer_resolving?cursel:cursel->outer_select()); for (SELECT_LEX *sl=(outer_resolving?cursel:cursel->outer_select());
@ -839,7 +839,7 @@ bool Item_field::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
Mark all selects from resolved to 1 before select where was Mark all selects from resolved to 1 before select where was
found table as depended (of select where was found table) found table as depended (of select where was found table)
*/ */
thd->lex.current_select->mark_as_dependent(last); thd->lex->current_select->mark_as_dependent(last);
if (depended_from->having_fix_field) if (depended_from->having_fix_field)
{ {
Item_ref *rf; Item_ref *rf;
@ -1242,8 +1242,8 @@ bool Item_ref::fix_fields(THD *thd,TABLE_LIST *tables, Item **reference)
{ {
TABLE_LIST *where= 0; TABLE_LIST *where= 0;
SELECT_LEX *sl= (outer_resolving? SELECT_LEX *sl= (outer_resolving?
thd->lex.current_select->select_lex(): thd->lex->current_select->select_lex():
thd->lex.current_select->outer_select()); thd->lex->current_select->outer_select());
/* /*
Finding only in current select will be performed for selects that have Finding only in current select will be performed for selects that have
not outer one and for derived tables (which not support using outer not outer one and for derived tables (which not support using outer
@ -1251,10 +1251,10 @@ bool Item_ref::fix_fields(THD *thd,TABLE_LIST *tables, Item **reference)
*/ */
if (outer_resolving || if (outer_resolving ||
(ref= find_item_in_list(this, (ref= find_item_in_list(this,
*(thd->lex.current_select->get_item_list()), *(thd->lex->current_select->get_item_list()),
&counter, &counter,
((sl && ((sl &&
thd->lex.current_select->master_unit()-> thd->lex->current_select->master_unit()->
first_select()->linkage != first_select()->linkage !=
DERIVED_TABLE_TYPE) ? DERIVED_TABLE_TYPE) ?
REPORT_EXCEPT_NOT_FOUND : REPORT_EXCEPT_NOT_FOUND :
@ -1296,7 +1296,7 @@ bool Item_ref::fix_fields(THD *thd,TABLE_LIST *tables, Item **reference)
{ {
// Call to report error // Call to report error
find_item_in_list(this, find_item_in_list(this,
*(thd->lex.current_select->get_item_list()), *(thd->lex->current_select->get_item_list()),
&counter, &counter,
REPORT_ALL_ERRORS); REPORT_ALL_ERRORS);
ref= 0; ref= 0;
@ -1310,7 +1310,7 @@ bool Item_ref::fix_fields(THD *thd,TABLE_LIST *tables, Item **reference)
return 1; return 1;
// store pointer on SELECT_LEX from wich item is dependent // store pointer on SELECT_LEX from wich item is dependent
f->depended_from= last; f->depended_from= last;
thd->lex.current_select->mark_as_dependent(last); thd->lex->current_select->mark_as_dependent(last);
return 0; return 0;
} }
else else
@ -1325,7 +1325,7 @@ bool Item_ref::fix_fields(THD *thd,TABLE_LIST *tables, Item **reference)
depended_from: pointer on SELECT_LEX from wich item is dependent depended_from: pointer on SELECT_LEX from wich item is dependent
*/ */
ref= (depended_from= last)->ref_pointer_array + counter; ref= (depended_from= last)->ref_pointer_array + counter;
thd->lex.current_select->mark_as_dependent(last); thd->lex->current_select->mark_as_dependent(last);
} }
} }
else if (!ref) else if (!ref)
@ -1338,7 +1338,7 @@ bool Item_ref::fix_fields(THD *thd,TABLE_LIST *tables, Item **reference)
"forward reference in item list"); "forward reference in item list");
return -1; return -1;
} }
ref= thd->lex.current_select->ref_pointer_array + counter; ref= thd->lex->current_select->ref_pointer_array + counter;
} }
} }
@ -1353,8 +1353,8 @@ bool Item_ref::fix_fields(THD *thd,TABLE_LIST *tables, Item **reference)
if (((*ref)->with_sum_func && name && if (((*ref)->with_sum_func && name &&
(depended_from || (depended_from ||
!(thd->lex.current_select->linkage != GLOBAL_OPTIONS_TYPE && !(thd->lex->current_select->linkage != GLOBAL_OPTIONS_TYPE &&
thd->lex.current_select->select_lex()->having_fix_field))) || thd->lex->current_select->select_lex()->having_fix_field))) ||
!(*ref)->fixed) !(*ref)->fixed)
{ {
my_error(ER_ILLEGAL_REFERENCE, MYF(0), name, my_error(ER_ILLEGAL_REFERENCE, MYF(0), name,

14
sql/item_create.cc
View File

@ -83,7 +83,7 @@ Item *create_func_ceiling(Item* a)
Item *create_func_connection_id(void) Item *create_func_connection_id(void)
{ {
THD *thd=current_thd; THD *thd=current_thd;
thd->lex.safe_to_cache_query=0; thd->lex->safe_to_cache_query=0;
return new Item_int(NullS,(longlong) thd->thread_id,10); return new Item_int(NullS,(longlong) thd->thread_id,10);
} }
@ -159,7 +159,7 @@ Item *create_func_floor(Item* a)
Item *create_func_found_rows(void) Item *create_func_found_rows(void)
{ {
THD *thd=current_thd; THD *thd=current_thd;
thd->lex.safe_to_cache_query=0; thd->lex->safe_to_cache_query=0;
return new Item_int(NullS,(longlong) thd->found_rows(),21); return new Item_int(NullS,(longlong) thd->found_rows(),21);
} }
@ -170,7 +170,7 @@ Item *create_func_from_days(Item* a)
Item *create_func_get_lock(Item* a, Item *b) Item *create_func_get_lock(Item* a, Item *b)
{ {
current_thd->lex.uncacheable(); current_thd->lex->uncacheable();
return new Item_func_get_lock(a, b); return new Item_func_get_lock(a, b);
} }
@ -340,7 +340,7 @@ Item *create_func_radians(Item *a)
Item *create_func_release_lock(Item* a) Item *create_func_release_lock(Item* a)
{ {
current_thd->lex.uncacheable(); current_thd->lex->uncacheable();
return new Item_func_release_lock(a); return new Item_func_release_lock(a);
} }
@ -448,7 +448,7 @@ Item *create_func_year(Item* a)
Item *create_load_file(Item* a) Item *create_load_file(Item* a)
{ {
current_thd->lex.uncacheable(); current_thd->lex->uncacheable();
return new Item_load_file(a); return new Item_load_file(a);
} }
@ -471,13 +471,13 @@ Item *create_func_cast(Item *a, Item_cast cast_type)
Item *create_func_is_free_lock(Item* a) Item *create_func_is_free_lock(Item* a)
{ {
current_thd->lex.uncacheable(); current_thd->lex->uncacheable();
return new Item_func_is_free_lock(a); return new Item_func_is_free_lock(a);
} }
Item *create_func_is_used_lock(Item* a) Item *create_func_is_used_lock(Item* a)
{ {
current_thd->lex.uncacheable(); current_thd->lex->uncacheable();
return new Item_func_is_used_lock(a); return new Item_func_is_used_lock(a);
} }

6
sql/item_func.cc
View File

@ -2253,7 +2253,7 @@ void Item_func_get_user_var::fix_length_and_dec()
if ((var_entry= get_variable(&thd->user_vars, name, 0))) if ((var_entry= get_variable(&thd->user_vars, name, 0)))
{ {
if (opt_bin_log && is_update_query(thd->lex.sql_command) && if (opt_bin_log && is_update_query(thd->lex->sql_command) &&
var_entry->used_query_id != thd->query_id) var_entry->used_query_id != thd->query_id)
{ {
uint size; uint size;
@ -2632,7 +2632,7 @@ Item *get_system_var(enum_var_type var_type, LEX_STRING name)
} }
if (!(item=var->item(thd, var_type))) if (!(item=var->item(thd, var_type)))
return 0; // Impossible return 0; // Impossible
thd->lex.uncacheable(); thd->lex->uncacheable();
buff[0]='@'; buff[0]='@';
buff[1]='@'; buff[1]='@';
pos=buff+2; pos=buff+2;
@ -2658,7 +2658,7 @@ Item *get_system_var(enum_var_type var_type, const char *var_name, uint length,
DBUG_ASSERT(var != 0); DBUG_ASSERT(var != 0);
if (!(item=var->item(thd, var_type))) if (!(item=var->item(thd, var_type)))
return 0; // Impossible return 0; // Impossible
thd->lex.uncacheable(); thd->lex->uncacheable();
item->set_name(item_name, 0, system_charset_info); // Will use original name item->set_name(item_name, 0, system_charset_info); // Will use original name
return item; return item;
} }

16
sql/item_subselect.cc
View File

@ -170,7 +170,7 @@ void Item_singlerow_subselect::select_transformer(THD *thd,
{ {
have_to_be_excluded= 1; have_to_be_excluded= 1;
if (thd->lex.describe) if (thd->lex->describe)
{ {
char warn_buff[MYSQL_ERRMSG_SIZE]; char warn_buff[MYSQL_ERRMSG_SIZE];
sprintf(warn_buff, ER(ER_SELECT_REDUCED), select_lex->select_number); sprintf(warn_buff, ER(ER_SELECT_REDUCED), select_lex->select_number);
@ -560,7 +560,7 @@ void Item_in_subselect::single_value_transformer(THD *thd,
item= (*func)(left_expr, item); item= (*func)(left_expr, item);
substitution= item; substitution= item;
have_to_be_excluded= 1; have_to_be_excluded= 1;
if (thd->lex.describe) if (thd->lex->describe)
{ {
char warn_buff[MYSQL_ERRMSG_SIZE]; char warn_buff[MYSQL_ERRMSG_SIZE];
sprintf(warn_buff, ER(ER_SELECT_REDUCED), sl->select_number); sprintf(warn_buff, ER(ER_SELECT_REDUCED), sl->select_number);
@ -703,8 +703,8 @@ int subselect_single_select_engine::prepare()
if (prepared) if (prepared)
return 0; return 0;
prepared= 1; prepared= 1;
SELECT_LEX_NODE *save_select= thd->lex.current_select; SELECT_LEX_NODE *save_select= thd->lex->current_select;
thd->lex.current_select= select_lex; thd->lex->current_select= select_lex;
if (join->prepare(&select_lex->ref_pointer_array, if (join->prepare(&select_lex->ref_pointer_array,
(TABLE_LIST*) select_lex->table_list.first, (TABLE_LIST*) select_lex->table_list.first,
select_lex->with_wild, select_lex->with_wild,
@ -717,7 +717,7 @@ int subselect_single_select_engine::prepare()
(ORDER*) 0, select_lex, (ORDER*) 0, select_lex,
select_lex->master_unit(), 0)) select_lex->master_unit(), 0))
return 1; return 1;
thd->lex.current_select= save_select; thd->lex->current_select= save_select;
return 0; return 0;
} }
@ -830,10 +830,10 @@ int subselect_single_select_engine::exec()
} }
if (!executed) if (!executed)
{ {
SELECT_LEX_NODE *save_select= join->thd->lex.current_select; SELECT_LEX_NODE *save_select= join->thd->lex->current_select;
join->thd->lex.current_select= select_lex; join->thd->lex->current_select= select_lex;
join->exec(); join->exec();
join->thd->lex.current_select= save_select; join->thd->lex->current_select= save_select;
executed= 1; executed= 1;
join->thd->where= save_where; join->thd->where= save_where;
DBUG_RETURN(join->error||thd->is_fatal_error); DBUG_RETURN(join->error||thd->is_fatal_error);

2
sql/item_sum.cc
View File

@ -57,7 +57,7 @@ Item_sum::Item_sum(THD *thd, Item_sum &item):
void Item_sum::mark_as_sum_func() void Item_sum::mark_as_sum_func()
{ {
current_thd->lex.current_select->with_sum_func++; current_thd->lex->current_select->with_sum_func++;
with_sum_func= 1; with_sum_func= 1;
} }

8
sql/mysql_priv.h
View File

@ -895,22 +895,22 @@ bool flush_error_log(void);
inline bool add_item_to_list(THD *thd, Item *item) inline bool add_item_to_list(THD *thd, Item *item)
{ {
return thd->lex.current_select->add_item_to_list(thd, item); return thd->lex->current_select->add_item_to_list(thd, item);
} }
inline bool add_value_to_list(THD *thd, Item *value) inline bool add_value_to_list(THD *thd, Item *value)
{ {
return thd->lex.value_list.push_back(value); return thd->lex->value_list.push_back(value);
} }
inline bool add_order_to_list(THD *thd, Item *item, bool asc) inline bool add_order_to_list(THD *thd, Item *item, bool asc)
{ {
return thd->lex.current_select->add_order_to_list(thd, item, asc); return thd->lex->current_select->add_order_to_list(thd, item, asc);
} }
inline bool add_group_to_list(THD *thd, Item *item, bool asc) inline bool add_group_to_list(THD *thd, Item *item, bool asc)
{ {
return thd->lex.current_select->add_group_to_list(thd, item, asc); return thd->lex->current_select->add_group_to_list(thd, item, asc);
} }
inline void mark_as_null_row(TABLE *table) inline void mark_as_null_row(TABLE *table)

4
sql/mysqld.cc
View File

@ -1269,12 +1269,12 @@ static void server_init(void)
void yyerror(const char *s) void yyerror(const char *s)
{ {
THD *thd=current_thd; THD *thd=current_thd;
char *yytext=(char*) thd->lex.tok_start; char *yytext=(char*) thd->lex->tok_start;
/* "parse error" changed into "syntax error" between bison 1.75 and 1.875 */ /* "parse error" changed into "syntax error" between bison 1.75 and 1.875 */
if (strcmp(s,"parse error") == 0 || strcmp(s,"syntax error") == 0) if (strcmp(s,"parse error") == 0 || strcmp(s,"syntax error") == 0)
s=ER(ER_SYNTAX_ERROR); s=ER(ER_SYNTAX_ERROR);
net_printf(thd,ER_PARSE_ERROR, s, yytext ? (char*) yytext : "", net_printf(thd,ER_PARSE_ERROR, s, yytext ? (char*) yytext : "",
thd->lex.yylineno); thd->lex->yylineno);
} }

2
sql/repl_failsafe.cc
View File

@ -422,7 +422,7 @@ int show_new_master(THD* thd)
DBUG_ENTER("show_new_master"); DBUG_ENTER("show_new_master");
List<Item> field_list; List<Item> field_list;
char errmsg[SLAVE_ERRMSG_SIZE]; char errmsg[SLAVE_ERRMSG_SIZE];
LEX_MASTER_INFO* lex_mi = &thd->lex.mi; LEX_MASTER_INFO* lex_mi = &thd->lex->mi;
errmsg[0]=0; // Safety errmsg[0]=0; // Safety
if (translate_master(thd, lex_mi, errmsg)) if (translate_master(thd, lex_mi, errmsg))

2
sql/set_var.cc
View File

@ -1158,7 +1158,7 @@ void sys_var_thd_sql_mode::set_default(THD *thd, enum_var_type type)
bool sys_var_thd_bit::update(THD *thd, set_var *var) bool sys_var_thd_bit::update(THD *thd, set_var *var)
{ {
int res= (*update_func)(thd, var); int res= (*update_func)(thd, var);
thd->lex.select_lex.options=thd->options; thd->lex->select_lex.options=thd->options;
return res; return res;
} }

2
sql/sp.cc
View File

@ -359,7 +359,7 @@ sp_cache_functions(THD *thd, LEX *lex)
continue; continue;
if (db_find_routine(thd, TYPE_ENUM_FUNCTION, fn, strlen(fn), &sp) == SP_OK) if (db_find_routine(thd, TYPE_ENUM_FUNCTION, fn, strlen(fn), &sp) == SP_OK)
{ {
ret= sp_cache_functions(thd, &thd->lex); ret= sp_cache_functions(thd, thd->lex);
if (ret) if (ret)
break; break;
thd->spfuns.push_back(sp); thd->spfuns.push_back(sp);

60
sql/sp_head.cc
View File

@ -351,35 +351,35 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
void void
sp_head::reset_lex(THD *thd) sp_head::reset_lex(THD *thd)
{ {
memcpy(&m_lex, &thd->lex, sizeof(LEX)); // Save old one memcpy(&m_lex, thd->lex, sizeof(LEX)); // Save old one
/* Reset most stuff. The length arguments doesn't matter here. */ /* Reset most stuff. The length arguments doesn't matter here. */
lex_start(thd, m_lex.buf, m_lex.end_of_query - m_lex.ptr); lex_start(thd, m_lex.buf, m_lex.end_of_query - m_lex.ptr);
/* We must reset ptr and end_of_query again */ /* We must reset ptr and end_of_query again */
thd->lex.ptr= m_lex.ptr; thd->lex->ptr= m_lex.ptr;
thd->lex.end_of_query= m_lex.end_of_query; thd->lex->end_of_query= m_lex.end_of_query;
/* And keep the SP stuff too */ /* And keep the SP stuff too */
thd->lex.sphead = m_lex.sphead; thd->lex->sphead = m_lex.sphead;
thd->lex.spcont = m_lex.spcont; thd->lex->spcont = m_lex.spcont;
/* Clear all lists. (QQ Why isn't this reset by lex_start()?). /* Clear all lists. (QQ Why isn't this reset by lex_start()?).
We may be overdoing this, but we know for sure that value_list must We may be overdoing this, but we know for sure that value_list must
be cleared at least. */ be cleared at least. */
thd->lex.col_list.empty(); thd->lex->col_list.empty();
thd->lex.ref_list.empty(); thd->lex->ref_list.empty();
thd->lex.drop_list.empty(); thd->lex->drop_list.empty();
thd->lex.alter_list.empty(); thd->lex->alter_list.empty();
thd->lex.interval_list.empty(); thd->lex->interval_list.empty();
thd->lex.users_list.empty(); thd->lex->users_list.empty();
thd->lex.columns.empty(); thd->lex->columns.empty();
thd->lex.key_list.empty(); thd->lex->key_list.empty();
thd->lex.create_list.empty(); thd->lex->create_list.empty();
thd->lex.insert_list= NULL; thd->lex->insert_list= NULL;
thd->lex.field_list.empty(); thd->lex->field_list.empty();
thd->lex.value_list.empty(); thd->lex->value_list.empty();
thd->lex.many_values.empty(); thd->lex->many_values.empty();
thd->lex.var_list.empty(); thd->lex->var_list.empty();
thd->lex.param_list.empty(); thd->lex->param_list.empty();
thd->lex.proc_list.empty(); thd->lex->proc_list.empty();
thd->lex.auxilliary_table_list.empty(); thd->lex->auxilliary_table_list.empty();
} }
// Restore lex during parsing, after we have parsed a sub statement. // Restore lex during parsing, after we have parsed a sub statement.
@ -387,11 +387,11 @@ void
sp_head::restore_lex(THD *thd) sp_head::restore_lex(THD *thd)
{ {
// Update some state in the old one first // Update some state in the old one first
m_lex.ptr= thd->lex.ptr; m_lex.ptr= thd->lex->ptr;
m_lex.next_state= thd->lex.next_state; m_lex.next_state= thd->lex->next_state;
// Collect some data from the sub statement lex. // Collect some data from the sub statement lex.
sp_merge_funs(&m_lex, &thd->lex); sp_merge_funs(&m_lex, thd->lex);
#if 0 #if 0
// QQ We're not using this at the moment. // QQ We're not using this at the moment.
if (thd->lex.sql_command == SQLCOM_CALL) if (thd->lex.sql_command == SQLCOM_CALL)
@ -434,7 +434,7 @@ sp_head::restore_lex(THD *thd)
} }
#endif #endif
memcpy(&thd->lex, &m_lex, sizeof(LEX)); // Restore lex memcpy(thd->lex, &m_lex, sizeof(LEX)); // Restore lex
} }
void void
@ -480,10 +480,10 @@ sp_instr_stmt::execute(THD *thd, uint *nextp)
LEX olex; // The other lex LEX olex; // The other lex
int res; int res;
memcpy(&olex, &thd->lex, sizeof(LEX)); // Save the other lex memcpy(&olex, thd->lex, sizeof(LEX)); // Save the other lex
memcpy(&thd->lex, &m_lex, sizeof(LEX)); // Use my own lex memcpy(thd->lex, &m_lex, sizeof(LEX)); // Use my own lex
thd->lex.thd = thd; thd->lex->thd = thd;
res= mysql_execute_command(thd); res= mysql_execute_command(thd);
if (thd->lock || thd->open_tables || thd->derived_tables) if (thd->lock || thd->open_tables || thd->derived_tables)
@ -492,7 +492,7 @@ sp_instr_stmt::execute(THD *thd, uint *nextp)
close_thread_tables(thd); /* Free tables */ close_thread_tables(thd); /* Free tables */
} }
memcpy(&thd->lex, &olex, sizeof(LEX)); // Restore the other lex memcpy(thd->lex, &olex, sizeof(LEX)); // Restore the other lex
*nextp = m_ip+1; *nextp = m_ip+1;
DBUG_RETURN(res); DBUG_RETURN(res);

42
sql/sql_acl.cc
View File

@ -1401,7 +1401,7 @@ static int replace_user_table(THD *thd, TABLE *table, const LEX_USER &combo,
if (table->fields >= 31) /* From 4.0.0 we have more fields */ if (table->fields >= 31) /* From 4.0.0 we have more fields */
{ {
/* We write down SSL related ACL stuff */ /* We write down SSL related ACL stuff */
switch (thd->lex.ssl_type) { switch (thd->lex->ssl_type) {
case SSL_TYPE_ANY: case SSL_TYPE_ANY:
table->field[24]->store("ANY",3, &my_charset_latin1); table->field[24]->store("ANY",3, &my_charset_latin1);
table->field[25]->store("", 0, &my_charset_latin1); table->field[25]->store("", 0, &my_charset_latin1);
@ -1419,15 +1419,15 @@ static int replace_user_table(THD *thd, TABLE *table, const LEX_USER &combo,
table->field[25]->store("", 0, &my_charset_latin1); table->field[25]->store("", 0, &my_charset_latin1);
table->field[26]->store("", 0, &my_charset_latin1); table->field[26]->store("", 0, &my_charset_latin1);
table->field[27]->store("", 0, &my_charset_latin1); table->field[27]->store("", 0, &my_charset_latin1);
if (thd->lex.ssl_cipher) if (thd->lex->ssl_cipher)
table->field[25]->store(thd->lex.ssl_cipher, table->field[25]->store(thd->lex->ssl_cipher,
strlen(thd->lex.ssl_cipher), &my_charset_latin1); strlen(thd->lex->ssl_cipher), &my_charset_latin1);
if (thd->lex.x509_issuer) if (thd->lex->x509_issuer)
table->field[26]->store(thd->lex.x509_issuer, table->field[26]->store(thd->lex->x509_issuer,
strlen(thd->lex.x509_issuer), &my_charset_latin1); strlen(thd->lex->x509_issuer), &my_charset_latin1);
if (thd->lex.x509_subject) if (thd->lex->x509_subject)
table->field[27]->store(thd->lex.x509_subject, table->field[27]->store(thd->lex->x509_subject,
strlen(thd->lex.x509_subject), &my_charset_latin1); strlen(thd->lex->x509_subject), &my_charset_latin1);
break; break;
case SSL_TYPE_NOT_SPECIFIED: case SSL_TYPE_NOT_SPECIFIED:
break; break;
@ -1439,7 +1439,7 @@ static int replace_user_table(THD *thd, TABLE *table, const LEX_USER &combo,
break; break;
} }
USER_RESOURCES mqh = thd->lex.mqh; USER_RESOURCES mqh = thd->lex->mqh;
if (mqh.bits & 1) if (mqh.bits & 1)
table->field[28]->store((longlong) mqh.questions); table->field[28]->store((longlong) mqh.questions);
if (mqh.bits & 2) if (mqh.bits & 2)
@ -1482,19 +1482,19 @@ end:
password=0; // No password given on command password=0; // No password given on command
if (old_row_exists) if (old_row_exists)
acl_update_user(combo.user.str,combo.host.str,password, acl_update_user(combo.user.str,combo.host.str,password,
thd->lex.ssl_type, thd->lex->ssl_type,
thd->lex.ssl_cipher, thd->lex->ssl_cipher,
thd->lex.x509_issuer, thd->lex->x509_issuer,
thd->lex.x509_subject, thd->lex->x509_subject,
&thd->lex.mqh, &thd->lex->mqh,
rights); rights);
else else
acl_insert_user(combo.user.str,combo.host.str,password, acl_insert_user(combo.user.str,combo.host.str,password,
thd->lex.ssl_type, thd->lex->ssl_type,
thd->lex.ssl_cipher, thd->lex->ssl_cipher,
thd->lex.x509_issuer, thd->lex->x509_issuer,
thd->lex.x509_subject, thd->lex->x509_subject,
&thd->lex.mqh, &thd->lex->mqh,
rights); rights);
} }
table->file->index_end(); table->file->index_end();

10
sql/sql_cache.cc
View File

@ -761,7 +761,7 @@ void Query_cache::store_query(THD *thd, TABLE_LIST *tables_used)
uint8 tables_type= 0; uint8 tables_type= 0;
if ((local_tables = is_cacheable(thd, thd->query_length, if ((local_tables = is_cacheable(thd, thd->query_length,
thd->query, &thd->lex, tables_used, thd->query, thd->lex, tables_used,
&tables_type))) &tables_type)))
{ {
NET *net= &thd->net; NET *net= &thd->net;
@ -895,7 +895,7 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length)
/* Check that we haven't forgot to reset the query cache variables */ /* Check that we haven't forgot to reset the query cache variables */
DBUG_ASSERT(thd->net.query_cache_query == 0); DBUG_ASSERT(thd->net.query_cache_query == 0);
if (!thd->lex.safe_to_cache_query) if (!thd->lex->safe_to_cache_query)
{ {
DBUG_PRINT("qcache", ("SELECT is non-cacheable")); DBUG_PRINT("qcache", ("SELECT is non-cacheable"));
goto err; goto err;
@ -996,7 +996,7 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length)
table_list.db, table_list.alias)); table_list.db, table_list.alias));
refused++; // This is actually a hit refused++; // This is actually a hit
STRUCT_UNLOCK(&structure_guard_mutex); STRUCT_UNLOCK(&structure_guard_mutex);
thd->lex.safe_to_cache_query=0; // Don't try to cache this thd->lex->safe_to_cache_query=0; // Don't try to cache this
BLOCK_UNLOCK_RD(query_block); BLOCK_UNLOCK_RD(query_block);
DBUG_RETURN(-1); // Privilege error DBUG_RETURN(-1); // Privilege error
} }
@ -1005,7 +1005,7 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length)
DBUG_PRINT("qcache", ("Need to check column privileges for %s.%s", DBUG_PRINT("qcache", ("Need to check column privileges for %s.%s",
table_list.db, table_list.alias)); table_list.db, table_list.alias));
BLOCK_UNLOCK_RD(query_block); BLOCK_UNLOCK_RD(query_block);
thd->lex.safe_to_cache_query= 0; // Don't try to cache this thd->lex->safe_to_cache_query= 0; // Don't try to cache this
goto err_unlock; // Parse query goto err_unlock; // Parse query
} }
if (check_tables && !handler::caching_allowed(thd, table->db(), if (check_tables && !handler::caching_allowed(thd, table->db(),
@ -1015,7 +1015,7 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length)
DBUG_PRINT("qcache", ("Handler does not allow caching for %s.%s", DBUG_PRINT("qcache", ("Handler does not allow caching for %s.%s",
table_list.db, table_list.alias)); table_list.db, table_list.alias));
BLOCK_UNLOCK_RD(query_block); BLOCK_UNLOCK_RD(query_block);
thd->lex.safe_to_cache_query= 0; // Don't try to cache this thd->lex->safe_to_cache_query= 0; // Don't try to cache this
goto err_unlock; // Parse query goto err_unlock; // Parse query
} }
else else

3
sql/sql_class.cc
View File

@ -90,6 +90,7 @@ THD::THD():user_time(0), is_fatal_error(0),
insert_id_used(0), rand_used(0), in_lock_tables(0), insert_id_used(0), rand_used(0), in_lock_tables(0),
global_read_lock(0), bootstrap(0), spcont(NULL) global_read_lock(0), bootstrap(0), spcont(NULL)
{ {
lex= &main_lex;
host=user=priv_user=db=query=ip=0; host=user=priv_user=db=query=ip=0;
host_or_ip= "connecting host"; host_or_ip= "connecting host";
locked=count_cuted_fields=some_tables_deleted=no_errors=password= locked=count_cuted_fields=some_tables_deleted=no_errors=password=
@ -1040,7 +1041,7 @@ int select_dumpvar::prepare(List<Item> &list, SELECT_LEX_UNIT *u)
else else
{ {
Item_func_set_user_var *xx = new Item_func_set_user_var(*ls,item); Item_func_set_user_var *xx = new Item_func_set_user_var(*ls,item);
xx->fix_fields(thd,(TABLE_LIST*) thd->lex.select_lex.table_list.first,&item); xx->fix_fields(thd,(TABLE_LIST*) thd->lex->select_lex.table_list.first,&item);
xx->fix_length_and_dec(); xx->fix_length_and_dec();
vars.push_back(xx); vars.push_back(xx);
} }

3
sql/sql_class.h
View File

@ -404,7 +404,8 @@ public:
struct st_mysql *mysql; struct st_mysql *mysql;
#endif #endif
NET net; // client connection descriptor NET net; // client connection descriptor
LEX lex; // parse tree descriptor LEX main_lex;
LEX *lex; // parse tree descriptor
MEM_ROOT mem_root; // 1 command-life memory pool MEM_ROOT mem_root; // 1 command-life memory pool
MEM_ROOT con_root; // connection-life memory MEM_ROOT con_root; // connection-life memory
MEM_ROOT warn_root; // For warnings and errors MEM_ROOT warn_root; // For warnings and errors

24
sql/sql_delete.cc
View File

@ -38,18 +38,18 @@ int mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds, ORDER *order,
bool transactional_table, log_delayed, safe_update, const_cond; bool transactional_table, log_delayed, safe_update, const_cond;
ha_rows deleted; ha_rows deleted;
TABLE_LIST *delete_table_list= (TABLE_LIST*) TABLE_LIST *delete_table_list= (TABLE_LIST*)
thd->lex.select_lex.table_list.first; thd->lex->select_lex.table_list.first;
DBUG_ENTER("mysql_delete"); DBUG_ENTER("mysql_delete");
if ((open_and_lock_tables(thd, table_list))) if ((open_and_lock_tables(thd, table_list)))
DBUG_RETURN(-1); DBUG_RETURN(-1);
fix_tables_pointers(thd->lex.all_selects_list); fix_tables_pointers(thd->lex->all_selects_list);
table= table_list->table; table= table_list->table;
table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK); table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
thd->proc_info="init"; thd->proc_info="init";
table->map=1; table->map=1;
if (setup_conds(thd, delete_table_list, &conds) || if (setup_conds(thd, delete_table_list, &conds) ||
setup_ftfuncs(&thd->lex.select_lex)) setup_ftfuncs(&thd->lex->select_lex))
DBUG_RETURN(-1); DBUG_RETURN(-1);
if (find_real_table_in_list(table_list->next, if (find_real_table_in_list(table_list->next,
table_list->db, table_list->real_name)) table_list->db, table_list->real_name))
@ -92,7 +92,7 @@ int mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds, ORDER *order,
if ((select && select->check_quick(safe_update, limit)) || !limit) if ((select && select->check_quick(safe_update, limit)) || !limit)
{ {
delete select; delete select;
free_underlaid_joins(thd, &thd->lex.select_lex); free_underlaid_joins(thd, &thd->lex->select_lex);
send_ok(thd,0L); send_ok(thd,0L);
DBUG_RETURN(0); // Nothing to delete DBUG_RETURN(0); // Nothing to delete
} }
@ -100,11 +100,11 @@ int mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds, ORDER *order,
/* If running in safe sql mode, don't allow updates without keys */ /* If running in safe sql mode, don't allow updates without keys */
if (!table->quick_keys) if (!table->quick_keys)
{ {
thd->lex.select_lex.options|=QUERY_NO_INDEX_USED; thd->lex->select_lex.options|=QUERY_NO_INDEX_USED;
if (safe_update && !using_limit) if (safe_update && !using_limit)
{ {
delete select; delete select;
free_underlaid_joins(thd, &thd->lex.select_lex); free_underlaid_joins(thd, &thd->lex->select_lex);
send_error(thd,ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE); send_error(thd,ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE);
DBUG_RETURN(1); DBUG_RETURN(1);
} }
@ -126,9 +126,9 @@ int mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds, ORDER *order,
table->sort.io_cache = (IO_CACHE *) my_malloc(sizeof(IO_CACHE), table->sort.io_cache = (IO_CACHE *) my_malloc(sizeof(IO_CACHE),
MYF(MY_FAE | MY_ZEROFILL)); MYF(MY_FAE | MY_ZEROFILL));
if (setup_ref_array(thd, &thd->lex.select_lex.ref_pointer_array, if (setup_ref_array(thd, &thd->lex->select_lex.ref_pointer_array,
all_fields.elements)|| all_fields.elements)||
setup_order(thd, thd->lex.select_lex.ref_pointer_array, &tables, setup_order(thd, thd->lex->select_lex.ref_pointer_array, &tables,
fields, all_fields, order) || fields, all_fields, order) ||
!(sortorder=make_unireg_sortorder(order, &length)) || !(sortorder=make_unireg_sortorder(order, &length)) ||
(table->sort.found_records = filesort(thd, table, sortorder, length, (table->sort.found_records = filesort(thd, table, sortorder, length,
@ -137,14 +137,14 @@ int mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds, ORDER *order,
== HA_POS_ERROR) == HA_POS_ERROR)
{ {
delete select; delete select;
free_underlaid_joins(thd, &thd->lex.select_lex); free_underlaid_joins(thd, &thd->lex->select_lex);
DBUG_RETURN(-1); // This will force out message DBUG_RETURN(-1); // This will force out message
} }
} }
init_read_record(&info,thd,table,select,1,1); init_read_record(&info,thd,table,select,1,1);
deleted=0L; deleted=0L;
init_ftfuncs(thd, &thd->lex.select_lex, 1); init_ftfuncs(thd, &thd->lex->select_lex, 1);
thd->proc_info="updating"; thd->proc_info="updating";
while (!(error=info.read_record(&info)) && !thd->killed && while (!(error=info.read_record(&info)) && !thd->killed &&
!thd->net.report_error) !thd->net.report_error)
@ -212,7 +212,7 @@ cleanup:
thd->lock=0; thd->lock=0;
} }
delete select; delete select;
free_underlaid_joins(thd, &thd->lex.select_lex); free_underlaid_joins(thd, &thd->lex->select_lex);
if (error >= 0 || thd->net.report_error) if (error >= 0 || thd->net.report_error)
send_error(thd,thd->killed_errno()); send_error(thd,thd->killed_errno());
else else
@ -302,7 +302,7 @@ multi_delete::initialize_tables(JOIN *join)
table->file->ref_length, table->file->ref_length,
MEM_STRIP_BUF_SIZE); MEM_STRIP_BUF_SIZE);
} }
init_ftfuncs(thd, thd->lex.current_select->select_lex(), 1); init_ftfuncs(thd, thd->lex->current_select->select_lex(), 1);
DBUG_RETURN(thd->is_fatal_error != 0); DBUG_RETURN(thd->is_fatal_error != 0);
} }

2
sql/sql_error.cc
View File

@ -183,7 +183,7 @@ my_bool mysqld_show_warnings(THD *thd, ulong levels_to_show)
DBUG_RETURN(1); DBUG_RETURN(1);
MYSQL_ERROR *err; MYSQL_ERROR *err;
SELECT_LEX *sel= &thd->lex.select_lex; SELECT_LEX *sel= &thd->lex->select_lex;
ha_rows offset= sel->offset_limit, limit= sel->select_limit; ha_rows offset= sel->offset_limit, limit= sel->select_limit;
Protocol *protocol=thd->protocol; Protocol *protocol=thd->protocol;

8
sql/sql_insert.cc
View File

@ -123,7 +123,7 @@ int mysql_insert(THD *thd,TABLE_LIST *table_list,
char *query=thd->query; char *query=thd->query;
thr_lock_type lock_type = table_list->lock_type; thr_lock_type lock_type = table_list->lock_type;
TABLE_LIST *insert_table_list= (TABLE_LIST*) TABLE_LIST *insert_table_list= (TABLE_LIST*)
thd->lex.select_lex.table_list.first; thd->lex->select_lex.table_list.first;
DBUG_ENTER("mysql_insert"); DBUG_ENTER("mysql_insert");
/* /*
@ -166,7 +166,7 @@ int mysql_insert(THD *thd,TABLE_LIST *table_list,
res= open_and_lock_tables(thd, table_list); res= open_and_lock_tables(thd, table_list);
if (res) if (res)
DBUG_RETURN(-1); DBUG_RETURN(-1);
fix_tables_pointers(thd->lex.all_selects_list); fix_tables_pointers(thd->lex->all_selects_list);
table= table_list->table; table= table_list->table;
thd->proc_info="init"; thd->proc_info="init";
@ -378,13 +378,13 @@ int mysql_insert(THD *thd,TABLE_LIST *table_list,
thd->cuted_fields); thd->cuted_fields);
::send_ok(thd,info.copied+info.deleted,(ulonglong)id,buff); ::send_ok(thd,info.copied+info.deleted,(ulonglong)id,buff);
} }
free_underlaid_joins(thd, &thd->lex.select_lex); free_underlaid_joins(thd, &thd->lex->select_lex);
DBUG_RETURN(0); DBUG_RETURN(0);
abort: abort:
if (lock_type == TL_WRITE_DELAYED) if (lock_type == TL_WRITE_DELAYED)
end_delayed_insert(thd); end_delayed_insert(thd);
free_underlaid_joins(thd, &thd->lex.select_lex); free_underlaid_joins(thd, &thd->lex->select_lex);
DBUG_RETURN(-1); DBUG_RETURN(-1);
} }

4
sql/sql_lex.cc
View File

@ -108,7 +108,7 @@ void lex_free(void)
LEX *lex_start(THD *thd, uchar *buf,uint length) LEX *lex_start(THD *thd, uchar *buf,uint length)
{ {
LEX *lex= &thd->lex; LEX *lex= thd->lex;
lex->thd= thd; lex->thd= thd;
lex->next_state=MY_LEX_START; lex->next_state=MY_LEX_START;
lex->buf= buf; lex->buf= buf;
@ -436,7 +436,7 @@ int yylex(void *arg, void *yythd)
int tokval; int tokval;
uint length; uint length;
enum my_lex_states state,prev_state; enum my_lex_states state,prev_state;
LEX *lex= &(((THD *)yythd)->lex); LEX *lex= (((THD *)yythd)->lex);
YYSTYPE *yylval=(YYSTYPE*) arg; YYSTYPE *yylval=(YYSTYPE*) arg;
CHARSET_INFO *cs= ((THD *) yythd)->charset(); CHARSET_INFO *cs= ((THD *) yythd)->charset();
uchar *state_map= cs->state_map; uchar *state_map= cs->state_map;

2
sql/sql_lex.h
View File

@ -529,4 +529,4 @@ extern pthread_key(LEX*,THR_LEX);
extern LEX_STRING tmp_table_alias; extern LEX_STRING tmp_table_alias;
#define current_lex (&current_thd->lex) #define current_lex (current_thd->lex)

28
sql/sql_parse.cc
View File

@ -1087,7 +1087,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
thread_running++; thread_running++;
VOID(pthread_mutex_unlock(&LOCK_thread_count)); VOID(pthread_mutex_unlock(&LOCK_thread_count));
thd->lex.select_lex.options=0; // We store status here thd->lex->select_lex.options=0; // We store status here
switch (command) { switch (command) {
case COM_INIT_DB: case COM_INIT_DB:
statistic_increment(com_stat[SQLCOM_CHANGE_DB],&LOCK_status); statistic_increment(com_stat[SQLCOM_CHANGE_DB],&LOCK_status);
@ -1263,16 +1263,16 @@ restore_user:
DBUG_PRINT("query",("%-.4096s",thd->query)); DBUG_PRINT("query",("%-.4096s",thd->query));
mysql_parse(thd,thd->query, thd->query_length); mysql_parse(thd,thd->query, thd->query_length);
while (!thd->killed && !thd->is_fatal_error && thd->lex.found_colon) while (!thd->killed && !thd->is_fatal_error && thd->lex->found_colon)
{ {
char *packet= thd->lex.found_colon; char *packet= thd->lex->found_colon;
/* /*
Multiple queries exits, execute them individually Multiple queries exits, execute them individually
*/ */
if (thd->lock || thd->open_tables || thd->derived_tables) if (thd->lock || thd->open_tables || thd->derived_tables)
close_thread_tables(thd); close_thread_tables(thd);
ulong length= thd->query_length-(ulong)(thd->lex.found_colon-thd->query); ulong length= thd->query_length-(ulong)(thd->lex->found_colon-thd->query);
/* Remove garbage at start of query */ /* Remove garbage at start of query */
while (my_isspace(thd->charset(), *packet) && length > 0) while (my_isspace(thd->charset(), *packet) && length > 0)
@ -1510,7 +1510,7 @@ restore_user:
if ((ulong) (thd->start_time - thd->time_after_lock) > if ((ulong) (thd->start_time - thd->time_after_lock) >
thd->variables.long_query_time || thd->variables.long_query_time ||
((thd->lex.select_lex.options & ((thd->lex->select_lex.options &
(QUERY_NO_INDEX_USED | QUERY_NO_GOOD_INDEX_USED)) && (QUERY_NO_INDEX_USED | QUERY_NO_GOOD_INDEX_USED)) &&
(specialflag & SPECIAL_LONG_LOG_FORMAT))) (specialflag & SPECIAL_LONG_LOG_FORMAT)))
{ {
@ -1592,7 +1592,7 @@ int
mysql_execute_command(THD *thd) mysql_execute_command(THD *thd)
{ {
int res= 0; int res= 0;
LEX *lex= &thd->lex; LEX *lex= thd->lex;
TABLE_LIST *tables= (TABLE_LIST*) lex->select_lex.table_list.first; TABLE_LIST *tables= (TABLE_LIST*) lex->select_lex.table_list.first;
SELECT_LEX *select_lex= &lex->select_lex; SELECT_LEX *select_lex= &lex->select_lex;
SELECT_LEX_UNIT *unit= &lex->unit; SELECT_LEX_UNIT *unit= &lex->unit;
@ -1719,7 +1719,7 @@ mysql_execute_command(THD *thd)
else else
thd->send_explain_fields(result); thd->send_explain_fields(result);
fix_tables_pointers(lex->all_selects_list); fix_tables_pointers(lex->all_selects_list);
res= mysql_explain_union(thd, &thd->lex.unit, result); res= mysql_explain_union(thd, &thd->lex->unit, result);
MYSQL_LOCK *save_lock= thd->lock; MYSQL_LOCK *save_lock= thd->lock;
thd->lock= (MYSQL_LOCK *)0; thd->lock= (MYSQL_LOCK *)0;
result->send_eof(); result->send_eof();
@ -2404,7 +2404,7 @@ mysql_execute_command(THD *thd)
} }
case SQLCOM_DELETE_MULTI: case SQLCOM_DELETE_MULTI:
{ {
TABLE_LIST *aux_tables=(TABLE_LIST *)thd->lex.auxilliary_table_list.first; TABLE_LIST *aux_tables=(TABLE_LIST *)thd->lex->auxilliary_table_list.first;
TABLE_LIST *auxi; TABLE_LIST *auxi;
uint table_count=0; uint table_count=0;
multi_delete *result; multi_delete *result;
@ -3436,7 +3436,7 @@ void
mysql_init_query(THD *thd) mysql_init_query(THD *thd)
{ {
DBUG_ENTER("mysql_init_query"); DBUG_ENTER("mysql_init_query");
LEX *lex=&thd->lex; LEX *lex=thd->lex;
lex->unit.init_query(); lex->unit.init_query();
lex->unit.init_select(); lex->unit.init_select();
lex->unit.thd= thd; lex->unit.thd= thd;
@ -3621,7 +3621,7 @@ bool add_field_to_list(THD *thd, char *field_name, enum_field_types type,
uint uint_geom_type) uint uint_geom_type)
{ {
register create_field *new_field; register create_field *new_field;
LEX *lex= &thd->lex; LEX *lex= thd->lex;
uint allowed_type_modifier=0; uint allowed_type_modifier=0;
char warn_buff[MYSQL_ERRMSG_SIZE]; char warn_buff[MYSQL_ERRMSG_SIZE];
DBUG_ENTER("add_field_to_list"); DBUG_ENTER("add_field_to_list");
@ -3945,7 +3945,7 @@ add_proc_to_list(THD* thd, Item *item)
*item_ptr= item; *item_ptr= item;
order->item=item_ptr; order->item=item_ptr;
order->free_me=0; order->free_me=0;
thd->lex.proc_list.link_in_list((byte*) order,(byte**) &order->next); thd->lex->proc_list.link_in_list((byte*) order,(byte**) &order->next);
return 0; return 0;
} }
@ -4368,11 +4368,11 @@ static bool append_file_to_dir(THD *thd, char **filename_ptr, char *table_name)
bool check_simple_select() bool check_simple_select()
{ {
THD *thd= current_thd; THD *thd= current_thd;
if (thd->lex.current_select != &thd->lex.select_lex) if (thd->lex->current_select != &thd->lex->select_lex)
{ {
char command[80]; char command[80];
strmake(command, thd->lex.yylval->symbol.str, strmake(command, thd->lex->yylval->symbol.str,
min(thd->lex.yylval->symbol.length, sizeof(command)-1)); min(thd->lex->yylval->symbol.length, sizeof(command)-1));
net_printf(thd, ER_CANT_USE_OPTION_HERE, command); net_printf(thd, ER_CANT_USE_OPTION_HERE, command);
return 1; return 1;
} }

34
sql/sql_prepare.cc
View File

@ -399,7 +399,7 @@ static void setup_param_functions(Item_param *param, uchar param_type)
static bool insert_params_withlog(PREP_STMT *stmt, uchar *pos, uchar *read_pos) static bool insert_params_withlog(PREP_STMT *stmt, uchar *pos, uchar *read_pos)
{ {
THD *thd= stmt->thd; THD *thd= stmt->thd;
List<Item> &params= thd->lex.param_list; List<Item> &params= thd->lex->param_list;
List_iterator<Item> param_iterator(params); List_iterator<Item> param_iterator(params);
Item_param *param; Item_param *param;
DBUG_ENTER("insert_params_withlog"); DBUG_ENTER("insert_params_withlog");
@ -445,7 +445,7 @@ static bool insert_params_withlog(PREP_STMT *stmt, uchar *pos, uchar *read_pos)
static bool insert_params(PREP_STMT *stmt, uchar *pos, uchar *read_pos) static bool insert_params(PREP_STMT *stmt, uchar *pos, uchar *read_pos)
{ {
THD *thd= stmt->thd; THD *thd= stmt->thd;
List<Item> &params= thd->lex.param_list; List<Item> &params= thd->lex->param_list;
List_iterator<Item> param_iterator(params); List_iterator<Item> param_iterator(params);
Item_param *param; Item_param *param;
DBUG_ENTER("insert_params"); DBUG_ENTER("insert_params");
@ -471,7 +471,7 @@ static bool insert_params(PREP_STMT *stmt, uchar *pos, uchar *read_pos)
static bool setup_params_data(PREP_STMT *stmt) static bool setup_params_data(PREP_STMT *stmt)
{ {
THD *thd= stmt->thd; THD *thd= stmt->thd;
List<Item> &params= thd->lex.param_list; List<Item> &params= thd->lex->param_list;
List_iterator<Item> param_iterator(params); List_iterator<Item> param_iterator(params);
Item_param *param; Item_param *param;
DBUG_ENTER("setup_params_data"); DBUG_ENTER("setup_params_data");
@ -517,8 +517,8 @@ static bool mysql_test_insert_fields(PREP_STMT *stmt,
List_item *values; List_item *values;
DBUG_ENTER("mysql_test_insert_fields"); DBUG_ENTER("mysql_test_insert_fields");
my_bool update=(thd->lex.value_list.elements ? UPDATE_ACL : 0); my_bool update=(thd->lex->value_list.elements ? UPDATE_ACL : 0);
ulong privilege= (thd->lex.duplicates == DUP_REPLACE ? ulong privilege= (thd->lex->duplicates == DUP_REPLACE ?
INSERT_ACL | DELETE_ACL : INSERT_ACL | update); INSERT_ACL | DELETE_ACL : INSERT_ACL | update);
if (check_access(thd,privilege,table_list->db, if (check_access(thd,privilege,table_list->db,
@ -616,8 +616,8 @@ static bool mysql_test_select_fields(PREP_STMT *stmt, TABLE_LIST *tables,
SELECT_LEX *select_lex) SELECT_LEX *select_lex)
{ {
THD *thd= stmt->thd; THD *thd= stmt->thd;
LEX *lex= &thd->lex; LEX *lex= thd->lex;
select_result *result= thd->lex.result; select_result *result= thd->lex->result;
DBUG_ENTER("mysql_test_select_fields"); DBUG_ENTER("mysql_test_select_fields");
ulong privilege= lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL; ulong privilege= lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL;
@ -643,7 +643,7 @@ static bool mysql_test_select_fields(PREP_STMT *stmt, TABLE_LIST *tables,
} }
else else
{ {
fix_tables_pointers(thd->lex.all_selects_list); fix_tables_pointers(thd->lex->all_selects_list);
if (!result && !(result= new select_send())) if (!result && !(result= new select_send()))
{ {
delete select_lex->having; delete select_lex->having;
@ -676,8 +676,8 @@ static bool mysql_test_select_fields(PREP_STMT *stmt, TABLE_LIST *tables,
static bool send_prepare_results(PREP_STMT *stmt) static bool send_prepare_results(PREP_STMT *stmt)
{ {
THD *thd= stmt->thd; THD *thd= stmt->thd;
LEX *lex= &thd->lex; LEX *lex= thd->lex;
enum enum_sql_command sql_command= thd->lex.sql_command; enum enum_sql_command sql_command= thd->lex->sql_command;
DBUG_ENTER("send_prepare_results"); DBUG_ENTER("send_prepare_results");
DBUG_PRINT("enter",("command: %d, param_count: %ld", DBUG_PRINT("enter",("command: %d, param_count: %ld",
sql_command, lex->param_count)); sql_command, lex->param_count));
@ -758,7 +758,7 @@ static bool parse_prepare_query(PREP_STMT *stmt,
LEX *lex=lex_start(thd, (uchar*) packet, length); LEX *lex=lex_start(thd, (uchar*) packet, length);
lex->safe_to_cache_query= 0; lex->safe_to_cache_query= 0;
thd->prepare_command= TRUE; thd->prepare_command= TRUE;
thd->lex.param_count= 0; thd->lex->param_count= 0;
if (!yyparse((void *)thd) && !thd->is_fatal_error) if (!yyparse((void *)thd) && !thd->is_fatal_error)
error= send_prepare_results(stmt); error= send_prepare_results(stmt);
lex_end(lex); lex_end(lex);
@ -772,11 +772,11 @@ static bool parse_prepare_query(PREP_STMT *stmt,
static bool init_param_items(PREP_STMT *stmt) static bool init_param_items(PREP_STMT *stmt)
{ {
THD *thd= stmt->thd; THD *thd= stmt->thd;
List<Item> &params= thd->lex.param_list; List<Item> &params= thd->lex->param_list;
Item_param **to; Item_param **to;
uint32 length= thd->query_length; uint32 length= thd->query_length;
stmt->lex= thd->lex; stmt->lex= *thd->lex;
if (mysql_bin_log.is_open()) if (mysql_bin_log.is_open())
{ {
@ -817,7 +817,7 @@ static bool init_param_items(PREP_STMT *stmt)
static void init_stmt_execute(PREP_STMT *stmt) static void init_stmt_execute(PREP_STMT *stmt)
{ {
THD *thd= stmt->thd; THD *thd= stmt->thd;
TABLE_LIST *tables= (TABLE_LIST*) thd->lex.select_lex.table_list.first; TABLE_LIST *tables= (TABLE_LIST*) thd->lex->select_lex.table_list.first;
/* /*
TODO: When the new table structure is ready, then have a status bit TODO: When the new table structure is ready, then have a status bit
@ -914,8 +914,8 @@ void mysql_stmt_execute(THD *thd, char *packet)
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
LEX thd_lex= thd->lex; LEX *old_thd_lex= thd->lex;
thd->lex= stmt->lex; thd->lex= &stmt->lex;
init_stmt_execute(stmt); init_stmt_execute(stmt);
if (stmt->param_count && setup_params_data(stmt)) if (stmt->param_count && setup_params_data(stmt))
@ -937,7 +937,7 @@ void mysql_stmt_execute(THD *thd, char *packet)
if (!(specialflag & SPECIAL_NO_PRIOR)) if (!(specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(), WAIT_PRIOR); my_pthread_setprio(pthread_self(), WAIT_PRIOR);
thd->lex= thd_lex; thd->lex= old_thd_lex;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }

16
sql/sql_repl.cc
View File

@ -650,8 +650,8 @@ int start_slave(THD* thd , MASTER_INFO* mi, bool net_report)
was running (as we don't wan't to touch the other thread), so set the was running (as we don't wan't to touch the other thread), so set the
bit to 0 for the other thread bit to 0 for the other thread
*/ */
if (thd->lex.slave_thd_opt) if (thd->lex->slave_thd_opt)
thread_mask &= thd->lex.slave_thd_opt; thread_mask &= thd->lex->slave_thd_opt;
if (thread_mask) //some threads are stopped, start them if (thread_mask) //some threads are stopped, start them
{ {
if (init_master_info(mi,master_info_file,relay_log_info_file, 0)) if (init_master_info(mi,master_info_file,relay_log_info_file, 0))
@ -707,8 +707,8 @@ int stop_slave(THD* thd, MASTER_INFO* mi, bool net_report )
was stopped (as we don't wan't to touch the other thread), so set the was stopped (as we don't wan't to touch the other thread), so set the
bit to 0 for the other thread bit to 0 for the other thread
*/ */
if (thd->lex.slave_thd_opt) if (thd->lex->slave_thd_opt)
thread_mask &= thd->lex.slave_thd_opt; thread_mask &= thd->lex->slave_thd_opt;
if (thread_mask) if (thread_mask)
{ {
@ -856,7 +856,7 @@ int change_master(THD* thd, MASTER_INFO* mi)
} }
thd->proc_info = "changing master"; thd->proc_info = "changing master";
LEX_MASTER_INFO* lex_mi = &thd->lex.mi; LEX_MASTER_INFO* lex_mi = &thd->lex->mi;
// TODO: see if needs re-write // TODO: see if needs re-write
if (init_master_info(mi, master_info_file, relay_log_info_file, 0)) if (init_master_info(mi, master_info_file, relay_log_info_file, 0))
{ {
@ -1003,7 +1003,7 @@ int show_binlog_events(THD* thd)
if (mysql_bin_log.is_open()) if (mysql_bin_log.is_open())
{ {
LEX_MASTER_INFO *lex_mi = &thd->lex.mi; LEX_MASTER_INFO *lex_mi = &thd->lex->mi;
ha_rows event_count, limit_start, limit_end; ha_rows event_count, limit_start, limit_end;
my_off_t pos = lex_mi->pos; my_off_t pos = lex_mi->pos;
char search_file_name[FN_REFLEN], *name; char search_file_name[FN_REFLEN], *name;
@ -1012,8 +1012,8 @@ int show_binlog_events(THD* thd)
LOG_INFO linfo; LOG_INFO linfo;
Log_event* ev; Log_event* ev;
limit_start = thd->lex.current_select->offset_limit; limit_start = thd->lex->current_select->offset_limit;
limit_end = thd->lex.current_select->select_limit + limit_start; limit_end = thd->lex->current_select->select_limit + limit_start;
name= search_file_name; name= search_file_name;
if (log_file_name) if (log_file_name)

16
sql/sql_select.cc
View File

@ -816,7 +816,7 @@ JOIN::optimize()
} }
} }
if (select_lex != &thd->lex.select_lex && if (select_lex != &thd->lex->select_lex &&
select_lex->linkage != DERIVED_TABLE_TYPE) select_lex->linkage != DERIVED_TABLE_TYPE)
{ {
if (!(tmp_join= (JOIN*)thd->alloc(sizeof(JOIN)))) if (!(tmp_join= (JOIN*)thd->alloc(sizeof(JOIN))))
@ -3076,7 +3076,7 @@ static void
make_join_readinfo(JOIN *join, uint options) make_join_readinfo(JOIN *join, uint options)
{ {
uint i; uint i;
SELECT_LEX *select_lex = &(join->thd->lex.select_lex); SELECT_LEX *select_lex = &(join->thd->lex->select_lex);
DBUG_ENTER("make_join_readinfo"); DBUG_ENTER("make_join_readinfo");
for (i=join->const_tables ; i < join->tables ; i++) for (i=join->const_tables ; i < join->tables ; i++)
@ -4788,7 +4788,7 @@ bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param,
thd->proc_info="converting HEAP to MyISAM"; thd->proc_info="converting HEAP to MyISAM";
if (create_myisam_tmp_table(&new_table,param, if (create_myisam_tmp_table(&new_table,param,
thd->lex.select_lex.options | thd->options)) thd->lex->select_lex.options | thd->options))
goto err2; goto err2;
if (open_tmp_table(&new_table)) if (open_tmp_table(&new_table))
goto err1; goto err1;
@ -7917,7 +7917,7 @@ static void select_describe(JOIN *join, bool need_tmp_table, bool need_order,
List<Item> field_list; List<Item> field_list;
List<Item> item_list; List<Item> item_list;
THD *thd=join->thd; THD *thd=join->thd;
SELECT_LEX *select_lex = &(join->thd->lex.select_lex); SELECT_LEX *select_lex = &(join->thd->lex->select_lex);
select_result *result=join->result; select_result *result=join->result;
Item *item_null= new Item_null(); Item *item_null= new Item_null();
CHARSET_INFO *cs= &my_charset_latin1; CHARSET_INFO *cs= &my_charset_latin1;
@ -8101,8 +8101,8 @@ int mysql_explain_union(THD *thd, SELECT_LEX_UNIT *unit, select_result *result)
sl= sl->next_select()) sl= sl->next_select())
{ {
res= mysql_explain_select(thd, sl, res= mysql_explain_select(thd, sl,
(((&thd->lex.select_lex)==sl)? (((&thd->lex->select_lex)==sl)?
((thd->lex.all_selects_list != sl)?"PRIMARY": ((thd->lex->all_selects_list != sl)?"PRIMARY":
"SIMPLE"): "SIMPLE"):
((sl == first)? ((sl == first)?
((sl->linkage == DERIVED_TABLE_TYPE) ? ((sl->linkage == DERIVED_TABLE_TYPE) ?
@ -8130,7 +8130,7 @@ int mysql_explain_select(THD *thd, SELECT_LEX *select_lex, char const *type,
DBUG_ENTER("mysql_explain_select"); DBUG_ENTER("mysql_explain_select");
DBUG_PRINT("info", ("Select 0x%lx, type %s", (ulong)select_lex, type)) DBUG_PRINT("info", ("Select 0x%lx, type %s", (ulong)select_lex, type))
select_lex->type= type; select_lex->type= type;
thd->lex.current_select= select_lex; thd->lex->current_select= select_lex;
SELECT_LEX_UNIT *unit= select_lex->master_unit(); SELECT_LEX_UNIT *unit= select_lex->master_unit();
int res= mysql_select(thd, &select_lex->ref_pointer_array, int res= mysql_select(thd, &select_lex->ref_pointer_array,
(TABLE_LIST*) select_lex->table_list.first, (TABLE_LIST*) select_lex->table_list.first,
@ -8141,7 +8141,7 @@ int mysql_explain_select(THD *thd, SELECT_LEX *select_lex, char const *type,
(ORDER*) select_lex->order_list.first, (ORDER*) select_lex->order_list.first,
(ORDER*) select_lex->group_list.first, (ORDER*) select_lex->group_list.first,
select_lex->having, select_lex->having,
(ORDER*) thd->lex.proc_list.first, (ORDER*) thd->lex->proc_list.first,
select_lex->options | thd->options | SELECT_DESCRIBE, select_lex->options | thd->options | SELECT_DESCRIBE,
result, unit, select_lex, 0); result, unit, select_lex, 0);
DBUG_RETURN(res); DBUG_RETURN(res);

6
sql/sql_table.cc
View File

@ -1132,7 +1132,7 @@ static int prepare_for_restore(THD* thd, TABLE_LIST* table,
} }
else else
{ {
char* backup_dir = thd->lex.backup_dir; char* backup_dir = thd->lex->backup_dir;
char src_path[FN_REFLEN], dst_path[FN_REFLEN]; char src_path[FN_REFLEN], dst_path[FN_REFLEN];
char* table_name = table->real_name; char* table_name = table->real_name;
char* db = thd->db ? thd->db : table->db; char* db = thd->db ? thd->db : table->db;
@ -2345,9 +2345,9 @@ copy_data_between_tables(TABLE *from,TABLE *to,
tables.db = from->table_cache_key; tables.db = from->table_cache_key;
error=1; error=1;
if (setup_ref_array(thd, &thd->lex.select_lex.ref_pointer_array, if (setup_ref_array(thd, &thd->lex->select_lex.ref_pointer_array,
order_num)|| order_num)||
setup_order(thd, thd->lex.select_lex.ref_pointer_array, setup_order(thd, thd->lex->select_lex.ref_pointer_array,
&tables, fields, all_fields, order) || &tables, fields, all_fields, order) ||
!(sortorder=make_unireg_sortorder(order, &length)) || !(sortorder=make_unireg_sortorder(order, &length)) ||
(from->sort.found_records = filesort(thd, from, sortorder, length, (from->sort.found_records = filesort(thd, from, sortorder, length,

28
sql/sql_union.cc
View File

@ -115,7 +115,7 @@ bool select_union::flush()
int st_select_lex_unit::prepare(THD *thd, select_result *sel_result, int st_select_lex_unit::prepare(THD *thd, select_result *sel_result,
bool tables_and_fields_initied) bool tables_and_fields_initied)
{ {
SELECT_LEX_NODE *lex_select_save= thd->lex.current_select; SELECT_LEX_NODE *lex_select_save= thd->lex->current_select;
SELECT_LEX *select_cursor; SELECT_LEX *select_cursor;
DBUG_ENTER("st_select_lex_unit::prepare"); DBUG_ENTER("st_select_lex_unit::prepare");
@ -129,7 +129,7 @@ int st_select_lex_unit::prepare(THD *thd, select_result *sel_result,
t_and_f= tables_and_fields_initied; t_and_f= tables_and_fields_initied;
bzero((char *)&tmp_table_param,sizeof(TMP_TABLE_PARAM)); bzero((char *)&tmp_table_param,sizeof(TMP_TABLE_PARAM));
thd->lex.current_select= select_cursor= first_select_in_union(); thd->lex->current_select= select_cursor= first_select_in_union();
/* Global option */ /* Global option */
if (((void*)(global_parameters)) == ((void*)this)) if (((void*)(global_parameters)) == ((void*)this))
{ {
@ -194,14 +194,14 @@ int st_select_lex_unit::prepare(THD *thd, select_result *sel_result,
or derived table ... or derived table ...
*/ */
if (thd->lex.describe) if (thd->lex->describe)
{ {
for (SELECT_LEX *sl= select_cursor; sl; sl= sl->next_select()) for (SELECT_LEX *sl= select_cursor; sl; sl= sl->next_select())
{ {
JOIN *join= new JOIN(thd, sl->item_list, JOIN *join= new JOIN(thd, sl->item_list,
sl->options | thd->options | SELECT_NO_UNLOCK, sl->options | thd->options | SELECT_NO_UNLOCK,
union_result); union_result);
thd->lex.current_select= sl; thd->lex->current_select= sl;
offset_limit_cnt= sl->offset_limit; offset_limit_cnt= sl->offset_limit;
select_limit_cnt= sl->select_limit+sl->offset_limit; select_limit_cnt= sl->select_limit+sl->offset_limit;
if (select_limit_cnt < sl->select_limit) if (select_limit_cnt < sl->select_limit)
@ -227,7 +227,7 @@ int st_select_lex_unit::prepare(THD *thd, select_result *sel_result,
} }
item_list.empty(); item_list.empty();
thd->lex.current_select= lex_select_save; thd->lex->current_select= lex_select_save;
{ {
List_iterator<Item> it(select_cursor->item_list); List_iterator<Item> it(select_cursor->item_list);
Field **field; Field **field;
@ -242,7 +242,7 @@ int st_select_lex_unit::prepare(THD *thd, select_result *sel_result,
DBUG_RETURN(res || thd->is_fatal_error ? 1 : 0); DBUG_RETURN(res || thd->is_fatal_error ? 1 : 0);
err: err:
thd->lex.current_select= lex_select_save; thd->lex->current_select= lex_select_save;
DBUG_RETURN(-1); DBUG_RETURN(-1);
} }
@ -250,7 +250,7 @@ err:
int st_select_lex_unit::exec() int st_select_lex_unit::exec()
{ {
int do_print_slow= 0; int do_print_slow= 0;
SELECT_LEX_NODE *lex_select_save= thd->lex.current_select; SELECT_LEX_NODE *lex_select_save= thd->lex->current_select;
SELECT_LEX *select_cursor=first_select_in_union(); SELECT_LEX *select_cursor=first_select_in_union();
DBUG_ENTER("st_select_lex_unit::exec"); DBUG_ENTER("st_select_lex_unit::exec");
@ -275,7 +275,7 @@ int st_select_lex_unit::exec()
JOIN *join= new JOIN(thd, sl->item_list, JOIN *join= new JOIN(thd, sl->item_list,
sl->options | thd->options | SELECT_NO_UNLOCK, sl->options | thd->options | SELECT_NO_UNLOCK,
union_result); union_result);
thd->lex.current_select= sl; thd->lex->current_select= sl;
offset_limit_cnt= sl->offset_limit; offset_limit_cnt= sl->offset_limit;
select_limit_cnt= sl->select_limit+sl->offset_limit; select_limit_cnt= sl->select_limit+sl->offset_limit;
if (select_limit_cnt < sl->select_limit) if (select_limit_cnt < sl->select_limit)
@ -297,7 +297,7 @@ int st_select_lex_unit::exec()
t_and_f=0; t_and_f=0;
if (res | thd->is_fatal_error) if (res | thd->is_fatal_error)
{ {
thd->lex.current_select= lex_select_save; thd->lex->current_select= lex_select_save;
DBUG_RETURN(res); DBUG_RETURN(res);
} }
res= sl->join->optimize(); res= sl->join->optimize();
@ -308,13 +308,13 @@ int st_select_lex_unit::exec()
res= sl->join->error; res= sl->join->error;
if (!res && union_result->flush()) if (!res && union_result->flush())
{ {
thd->lex.current_select= lex_select_save; thd->lex->current_select= lex_select_save;
DBUG_RETURN(1); DBUG_RETURN(1);
} }
} }
if (res) if (res)
{ {
thd->lex.current_select= lex_select_save; thd->lex->current_select= lex_select_save;
DBUG_RETURN(res); DBUG_RETURN(res);
} }
do_print_slow|= select_cursor->options; do_print_slow|= select_cursor->options;
@ -325,7 +325,7 @@ int st_select_lex_unit::exec()
/* Send result to 'result' */ /* Send result to 'result' */
// to correct ORDER BY reference resolving // to correct ORDER BY reference resolving
thd->lex.current_select= select_cursor; thd->lex->current_select= select_cursor;
res= -1; res= -1;
{ {
List<Item_func_match> empty_list; List<Item_func_match> empty_list;
@ -333,7 +333,7 @@ int st_select_lex_unit::exec()
if (!thd->is_fatal_error) // Check if EOM if (!thd->is_fatal_error) // Check if EOM
{ {
SELECT_LEX *fake_select = new SELECT_LEX(&thd->lex); SELECT_LEX *fake_select = new SELECT_LEX(thd->lex);
offset_limit_cnt= (select_cursor->braces ? offset_limit_cnt= (select_cursor->braces ?
global_parameters->offset_limit : 0); global_parameters->offset_limit : 0);
select_limit_cnt= (select_cursor->braces ? select_limit_cnt= (select_cursor->braces ?
@ -367,7 +367,7 @@ int st_select_lex_unit::exec()
QUERY_NO_GOOD_INDEX_USED)); QUERY_NO_GOOD_INDEX_USED));
} }
} }
thd->lex.current_select= lex_select_save; thd->lex->current_select= lex_select_save;
DBUG_RETURN(res); DBUG_RETURN(res);
} }

30
sql/sql_update.cc
View File

@ -67,14 +67,14 @@ int mysql_update(THD *thd,
SQL_SELECT *select; SQL_SELECT *select;
READ_RECORD info; READ_RECORD info;
TABLE_LIST *update_table_list= (TABLE_LIST*) TABLE_LIST *update_table_list= (TABLE_LIST*)
thd->lex.select_lex.table_list.first; thd->lex->select_lex.table_list.first;
DBUG_ENTER("mysql_update"); DBUG_ENTER("mysql_update");
LINT_INIT(used_index); LINT_INIT(used_index);
LINT_INIT(timestamp_query_id); LINT_INIT(timestamp_query_id);
if ((open_and_lock_tables(thd, table_list))) if ((open_and_lock_tables(thd, table_list)))
DBUG_RETURN(-1); DBUG_RETURN(-1);
fix_tables_pointers(thd->lex.all_selects_list); fix_tables_pointers(thd->lex->all_selects_list);
table= table_list->table; table= table_list->table;
table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK); table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
@ -87,7 +87,7 @@ int mysql_update(THD *thd,
table->grant.want_privilege=(SELECT_ACL & ~table->grant.privilege); table->grant.want_privilege=(SELECT_ACL & ~table->grant.privilege);
if (setup_tables(update_table_list) || if (setup_tables(update_table_list) ||
setup_conds(thd,update_table_list,&conds) setup_conds(thd,update_table_list,&conds)
|| setup_ftfuncs(&thd->lex.select_lex)) || setup_ftfuncs(&thd->lex->select_lex))
DBUG_RETURN(-1); /* purecov: inspected */ DBUG_RETURN(-1); /* purecov: inspected */
if (find_real_table_in_list(table_list->next, if (find_real_table_in_list(table_list->next,
table_list->db, table_list->real_name)) table_list->db, table_list->real_name))
@ -126,7 +126,7 @@ int mysql_update(THD *thd,
table->grant.want_privilege=(SELECT_ACL & ~table->grant.privilege); table->grant.want_privilege=(SELECT_ACL & ~table->grant.privilege);
if (setup_fields(thd, 0, update_table_list, values, 0, 0, 0)) if (setup_fields(thd, 0, update_table_list, values, 0, 0, 0))
{ {
free_underlaid_joins(thd, &thd->lex.select_lex); free_underlaid_joins(thd, &thd->lex->select_lex);
DBUG_RETURN(-1); /* purecov: inspected */ DBUG_RETURN(-1); /* purecov: inspected */
} }
@ -137,7 +137,7 @@ int mysql_update(THD *thd,
(select && select->check_quick(safe_update, limit)) || !limit) (select && select->check_quick(safe_update, limit)) || !limit)
{ {
delete select; delete select;
free_underlaid_joins(thd, &thd->lex.select_lex); free_underlaid_joins(thd, &thd->lex->select_lex);
if (error) if (error)
{ {
DBUG_RETURN(-1); // Error in where DBUG_RETURN(-1); // Error in where
@ -148,16 +148,16 @@ int mysql_update(THD *thd,
/* If running in safe sql mode, don't allow updates without keys */ /* If running in safe sql mode, don't allow updates without keys */
if (!table->quick_keys) if (!table->quick_keys)
{ {
thd->lex.select_lex.options|=QUERY_NO_INDEX_USED; thd->lex->select_lex.options|=QUERY_NO_INDEX_USED;
if (safe_update && !using_limit) if (safe_update && !using_limit)
{ {
delete select; delete select;
free_underlaid_joins(thd, &thd->lex.select_lex); free_underlaid_joins(thd, &thd->lex->select_lex);
send_error(thd,ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE); send_error(thd,ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE);
DBUG_RETURN(1); DBUG_RETURN(1);
} }
} }
init_ftfuncs(thd, &thd->lex.select_lex, 1); init_ftfuncs(thd, &thd->lex->select_lex, 1);
/* Check if we are modifying a key that we are used to search with */ /* Check if we are modifying a key that we are used to search with */
if (select && select->quick) if (select && select->quick)
used_key_is_modified= (!select->quick->unique_key_range() && used_key_is_modified= (!select->quick->unique_key_range() &&
@ -180,7 +180,7 @@ int mysql_update(THD *thd,
DISK_BUFFER_SIZE, MYF(MY_WME))) DISK_BUFFER_SIZE, MYF(MY_WME)))
{ {
delete select; /* purecov: inspected */ delete select; /* purecov: inspected */
free_underlaid_joins(thd, &thd->lex.select_lex); free_underlaid_joins(thd, &thd->lex->select_lex);
DBUG_RETURN(-1); DBUG_RETURN(-1);
} }
if (old_used_keys & ((key_map) 1 << used_index)) if (old_used_keys & ((key_map) 1 << used_index))
@ -203,9 +203,9 @@ int mysql_update(THD *thd,
table->sort.io_cache = (IO_CACHE *) my_malloc(sizeof(IO_CACHE), table->sort.io_cache = (IO_CACHE *) my_malloc(sizeof(IO_CACHE),
MYF(MY_FAE | MY_ZEROFILL)); MYF(MY_FAE | MY_ZEROFILL));
if (setup_ref_array(thd, &thd->lex.select_lex.ref_pointer_array, if (setup_ref_array(thd, &thd->lex->select_lex.ref_pointer_array,
order_num)|| order_num)||
setup_order(thd, thd->lex.select_lex.ref_pointer_array, setup_order(thd, thd->lex->select_lex.ref_pointer_array,
&tables, fields, all_fields, order) || &tables, fields, all_fields, order) ||
!(sortorder=make_unireg_sortorder(order, &length)) || !(sortorder=make_unireg_sortorder(order, &length)) ||
(table->sort.found_records = filesort(thd, table, sortorder, length, (table->sort.found_records = filesort(thd, table, sortorder, length,
@ -214,7 +214,7 @@ int mysql_update(THD *thd,
== HA_POS_ERROR) == HA_POS_ERROR)
{ {
delete select; delete select;
free_underlaid_joins(thd, &thd->lex.select_lex); free_underlaid_joins(thd, &thd->lex->select_lex);
DBUG_RETURN(-1); DBUG_RETURN(-1);
} }
} }
@ -269,7 +269,7 @@ int mysql_update(THD *thd,
if (error >= 0) if (error >= 0)
{ {
delete select; delete select;
free_underlaid_joins(thd, &thd->lex.select_lex); free_underlaid_joins(thd, &thd->lex->select_lex);
DBUG_RETURN(-1); DBUG_RETURN(-1);
} }
} }
@ -354,7 +354,7 @@ int mysql_update(THD *thd,
} }
delete select; delete select;
free_underlaid_joins(thd, &thd->lex.select_lex); free_underlaid_joins(thd, &thd->lex->select_lex);
if (error >= 0) if (error >= 0)
send_error(thd,thd->killed_errno()); /* purecov: inspected */ send_error(thd,thd->killed_errno()); /* purecov: inspected */
else else
@ -399,7 +399,7 @@ int mysql_multi_update(THD *thd,
table_list->grant.want_privilege=(SELECT_ACL & ~table_list->grant.privilege); table_list->grant.want_privilege=(SELECT_ACL & ~table_list->grant.privilege);
if ((res=open_and_lock_tables(thd,table_list))) if ((res=open_and_lock_tables(thd,table_list)))
DBUG_RETURN(res); DBUG_RETURN(res);
fix_tables_pointers(thd->lex.all_selects_list); fix_tables_pointers(thd->lex->all_selects_list);
thd->select_limit=HA_POS_ERROR; thd->select_limit=HA_POS_ERROR;
if (setup_fields(thd, 0, table_list, *fields, 1, 0, 0)) if (setup_fields(thd, 0, table_list, *fields, 1, 0, 0))

26
sql/sql_yacc.yy
View File

@ -28,7 +28,7 @@
#define MYSQL_YACC #define MYSQL_YACC
#define YYINITDEPTH 100 #define YYINITDEPTH 100
#define YYMAXDEPTH 3200 /* Because of 64K stack */ #define YYMAXDEPTH 3200 /* Because of 64K stack */
#define Lex (&(YYTHD->lex)) #define Lex ((YYTHD->lex))
#define Select Lex->current_select #define Select Lex->current_select
#include "mysql_priv.h" #include "mysql_priv.h"
#include "slave.h" #include "slave.h"
@ -729,14 +729,14 @@ query:
{ {
THD *thd= YYTHD; THD *thd= YYTHD;
if (!thd->bootstrap && if (!thd->bootstrap &&
(!(thd->lex.select_lex.options & OPTION_FOUND_COMMENT))) (!(thd->lex->select_lex.options & OPTION_FOUND_COMMENT)))
{ {
send_error(thd,ER_EMPTY_QUERY); send_error(thd,ER_EMPTY_QUERY);
YYABORT; YYABORT;
} }
else else
{ {
thd->lex.sql_command = SQLCOM_EMPTY_QUERY; thd->lex->sql_command = SQLCOM_EMPTY_QUERY;
} }
} }
| verb_clause END_OF_INPUT {}; | verb_clause END_OF_INPUT {};
@ -2082,7 +2082,7 @@ alter:
ALTER opt_ignore TABLE_SYM table_ident ALTER opt_ignore TABLE_SYM table_ident
{ {
THD *thd= YYTHD; THD *thd= YYTHD;
LEX *lex=&thd->lex; LEX *lex= thd->lex;
lex->sql_command = SQLCOM_ALTER_TABLE; lex->sql_command = SQLCOM_ALTER_TABLE;
lex->name=0; lex->name=0;
if (!lex->select_lex.add_table_to_list(thd, $4, NULL, if (!lex->select_lex.add_table_to_list(thd, $4, NULL,
@ -2532,7 +2532,7 @@ select_item_list:
THD *thd= YYTHD; THD *thd= YYTHD;
if (add_item_to_list(thd, new Item_field(NULL, NULL, "*"))) if (add_item_to_list(thd, new Item_field(NULL, NULL, "*")))
YYABORT; YYABORT;
(thd->lex.current_select->select_lex()->with_wild)++; (thd->lex->current_select->select_lex()->with_wild)++;
}; };
@ -4260,8 +4260,8 @@ show_param:
| opt_var_type VARIABLES wild | opt_var_type VARIABLES wild
{ {
THD *thd= YYTHD; THD *thd= YYTHD;
thd->lex.sql_command= SQLCOM_SHOW_VARIABLES; thd->lex->sql_command= SQLCOM_SHOW_VARIABLES;
thd->lex.option_type= (enum_var_type) $1; thd->lex->option_type= (enum_var_type) $1;
} }
| charset wild | charset wild
{ Lex->sql_command= SQLCOM_SHOW_CHARSETS; } { Lex->sql_command= SQLCOM_SHOW_CHARSETS; }
@ -4664,7 +4664,7 @@ simple_ident:
| ident '.' ident | ident '.' ident
{ {
THD *thd= YYTHD; THD *thd= YYTHD;
LEX *lex= &thd->lex; LEX *lex= thd->lex;
SELECT_LEX_NODE *sel= lex->current_select; SELECT_LEX_NODE *sel= lex->current_select;
if (sel->no_table_names_allowed) if (sel->no_table_names_allowed)
{ {
@ -4677,7 +4677,7 @@ simple_ident:
| '.' ident '.' ident | '.' ident '.' ident
{ {
THD *thd= YYTHD; THD *thd= YYTHD;
LEX *lex= &thd->lex; LEX *lex= thd->lex;
SELECT_LEX_NODE *sel= lex->current_select; SELECT_LEX_NODE *sel= lex->current_select;
if (sel->no_table_names_allowed) if (sel->no_table_names_allowed)
{ {
@ -4690,7 +4690,7 @@ simple_ident:
| ident '.' ident '.' ident | ident '.' ident '.' ident
{ {
THD *thd= YYTHD; THD *thd= YYTHD;
LEX *lex= &thd->lex; LEX *lex= thd->lex;
SELECT_LEX_NODE *sel= lex->current_select; SELECT_LEX_NODE *sel= lex->current_select;
if (sel->no_table_names_allowed) if (sel->no_table_names_allowed)
{ {
@ -5079,7 +5079,7 @@ option_value:
YYABORT; YYABORT;
user->host.str=0; user->host.str=0;
user->user.str=thd->priv_user; user->user.str=thd->priv_user;
thd->lex.var_list.push_back(new set_var_password(user, $3)); thd->lex->var_list.push_back(new set_var_password(user, $3));
} }
| PASSWORD FOR_SYM user equal text_or_password | PASSWORD FOR_SYM user equal text_or_password
{ {
@ -5597,7 +5597,7 @@ optional_order_or_limit:
| |
{ {
THD *thd= YYTHD; THD *thd= YYTHD;
LEX *lex= &thd->lex; LEX *lex= thd->lex;
DBUG_ASSERT(lex->current_select->linkage != GLOBAL_OPTIONS_TYPE); DBUG_ASSERT(lex->current_select->linkage != GLOBAL_OPTIONS_TYPE);
SELECT_LEX *sel= lex->current_select->select_lex(); SELECT_LEX *sel= lex->current_select->select_lex();
SELECT_LEX_UNIT *unit= sel->master_unit(); SELECT_LEX_UNIT *unit= sel->master_unit();
@ -5609,7 +5609,7 @@ optional_order_or_limit:
order_or_limit order_or_limit
{ {
THD *thd= YYTHD; THD *thd= YYTHD;
thd->lex.current_select->no_table_names_allowed= 0; thd->lex->current_select->no_table_names_allowed= 0;
thd->where= ""; thd->where= "";
} }
; ;