void mysql_parse(THD *thd, Parser_state *parser_state)
{
int error MY_ATTRIBUTE((unused));
DBUG_ENTER("mysql_parse");
DBUG_PRINT("mysql_parse", ("query: '%s'", thd->query().str));
DBUG_EXECUTE_IF("parser_debug", turn_parser_debug_on(););
/*
Warning.
The purpose of query_cache_send_result_to_client() is to lookup the
query in the query cache first, to avoid parsing and executing it.
So, the natural implementation would be to:
- first, call query_cache_send_result_to_client,
- second, if caching failed, initialise the lexical and syntactic parser.
The problem is that the query cache depends on a clean initialization
of (among others) lex->safe_to_cache_query and thd->server_status,
which are reset respectively in
- lex_start()
- mysql_reset_thd_for_next_command()
So, initializing the lexical analyser *before* using the query cache
is required for the cache to work properly.
FIXME: cleanup the dependencies in the code to simplify this.
*/
解析前调用
invoke_pre_parse_rewrite_plugins
执行
parse_sql
invoke_post_parse_rewrite_plugins
查询重写
/*
Rewrite the query for logging and for the Performance Schema statement
tables. Raw logging happened earlier.
Query-cache only handles SELECT, which we don't rewrite, so it's no
concern of ours.
Sub-routines of mysql_rewrite_query() should try to only rewrite when
necessary (e.g. not do password obfuscation when query contains no
password).
If rewriting does not happen here, thd->rewritten_query is still empty
from being reset in alloc_query().
*/
// bool general= !(opt_general_log_raw || thd->slave_thread);
mysql_rewrite_query(thd);
sql执行过程中打开表
open_tables_for_query
DML_prelocking_strategy prelocking_strategy;
MDL_savepoint mdl_savepoint= thd->mdl_context.mdl_savepoint();
DBUG_ENTER("open_tables_for_query");
DBUG_EXECUTE_IF("open_tables_for_query__out_of_memory",
DBUG_SET("+d,simulate_out_of_memory"););
DBUG_ASSERT(tables == thd->lex->query_tables);
if (open_tables(thd, &tables, &thd->lex->table_count, flags,
&prelocking_strategy))
goto end;
DBUG_RETURN(0);
end:
/*
No need to commit/rollback the statement transaction: it's
either not started or we're filling in an INFORMATION_SCHEMA
table on the fly, and thus mustn't manipulate with the
transaction of the enclosing statement.
*/
DBUG_ASSERT(thd->get_transaction()->is_empty(Transaction_ctx::STMT) ||
(thd->state_flags & Open_tables_state::BACKUPS_AVAIL) ||
thd->in_sub_stmt);
close_thread_tables(thd);
/* Don't keep locks for a failed statement. */
thd->mdl_context.rollback_to_savepoint(mdl_savepoint);
在这里有个prelocking 算法的东西，第一次听说
/**
Open all tables in list
@param[in] thd Thread context.
@param[in,out] start List of tables to be open (it can be adjusted for
statement that uses tables only implicitly, e.g.
for "SELECT f1()").
@param[out] counter Number of tables which were open.
@param[in] flags Bitmap of flags to modify how the tables will be
open, see open_table() description for details.
@param[in] prelocking_strategy Strategy which specifies how prelocking
algorithm should work for this statement.
@note
Unless we are already in prelocked mode and prelocking strategy prescribes
so this function will also precache all SP/SFs explicitly or implicitly
(via views and triggers) used by the query and add tables needed for their
execution to table list. Statement that uses SFs, invokes triggers or
requires foreign key checks will be marked as requiring prelocking.
Prelocked mode will be enabled for such query during lock_tables() call.
If query for which we are opening tables is already marked as requiring
prelocking it won't do such precaching and will simply reuse table list
which is already built.
@retval FALSE Success.
@retval TRUE Error, reported.
*/
bool open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags,
Prelocking_strategy *prelocking_strategy)
{
/*
We use pointers to "next_global" member in the last processed TABLE_LIST
element and to the "next" member in the last processed Sroutine_hash_entry
element as iterators over, correspondingly, the table list and stored routines
list which stay valid and allow to continue iteration when new elements are
added to the tail of the lists.
*/
TABLE_LIST **table_to_open;
Sroutine_hash_entry **sroutine_to_open;
TABLE_LIST *tables;
Open_table_context ot_ctx(thd, flags);
bool error= FALSE;
bool some_routine_modifies_data= FALSE;
bool has_prelocking_list;
DBUG_ENTER("open_tables");
#ifndef EMBEDDED_LIBRARY
bool audit_notified= false;
#endif /* !EMBEDDED_LIBRARY */
restart:
/*
Close HANDLER tables which are marked for flush or against which there
are pending exclusive metadata locks. This is needed both in order to
avoid deadlocks and to have a point during statement execution at
which such HANDLERs are closed even if they don't create problems for
the current session (i.e. to avoid having a DDL blocked by HANDLERs
opened for a long time).
*/
if (thd->handler_tables_hash.records)
mysql_ha_flush(thd);
has_prelocking_list= thd->lex->requires_prelocking();
table_to_open= start;
sroutine_to_open= &thd->lex->sroutines_list.first;
*counter= 0;
THD_STAGE_INFO(thd, stage_opening_tables);
/*
If we are executing LOCK TABLES statement or a DDL statement
(in non-LOCK TABLES mode) we might have to acquire upgradable
semi-exclusive metadata locks (SNW or SNRW) on some of the
tables to be opened.
When executing CREATE TABLE .. If NOT EXISTS .. SELECT, the
table may not yet exist, in which case we acquire an exclusive
lock.
We acquire all such locks at once here as doing this in one
by one fashion may lead to deadlocks or starvation. Later when
we will be opening corresponding table pre-acquired metadata
lock will be reused (thanks to the fact that in recursive case
metadata locks are acquired without waiting).
*/
if (! (flags & (MYSQL_OPEN_HAS_MDL_LOCK |
MYSQL_OPEN_FORCE_SHARED_MDL |
MYSQL_OPEN_FORCE_SHARED_HIGH_PRIO_MDL)))
{
if (thd->locked_tables_mode)
{
/*
Under LOCK TABLES, we can't acquire new locks, so we instead
need to check if appropriate locks were pre-acquired.
*/
if (open_tables_check_upgradable_mdl(thd, *start,
thd->lex->first_not_own_table(),
flags))
{
error= TRUE;
goto err;
}
}
else
{
TABLE_LIST *table;
if (lock_table_names(thd, *start, thd->lex->first_not_own_table(),
ot_ctx.get_timeout(), flags))
{
error= TRUE;
goto err;
}
for (table= *start; table && table != thd->lex->first_not_own_table();
table= table->next_global)
{
if (table->mdl_request.is_ddl_or_lock_tables_lock_request() ||
table->open_strategy == TABLE_LIST::OPEN_FOR_CREATE)
table->mdl_request.ticket= NULL;
}
}
}
/*
Perform steps of prelocking algorithm until there are unprocessed
elements in prelocking list/set.
*/
while (*table_to_open ||
(thd->locked_tables_mode <= LTM_LOCK_TABLES &&
*sroutine_to_open))
{
/*
For every table in the list of tables to open, try to find or open
a table.
*/
for (tables= *table_to_open; tables;
table_to_open= &tables->next_global, tables= tables->next_global)
{
error= open_and_process_table(thd, thd->lex, tables, counter,
flags, prelocking_strategy,
has_prelocking_list, &ot_ctx);
if (error)
{
if (ot_ctx.can_recover_from_failed_open())
{
/*
We have met exclusive metadata lock or old version of table.
Now we have to close all tables and release metadata locks.
We also have to throw away set of prelocked tables (and thus
close tables from this set that were open by now) since it
is possible that one of tables which determined its content
was changed.
Instead of implementing complex/non-robust logic mentioned
above we simply close and then reopen all tables.
We have to save pointer to table list element for table which we
have failed to open since closing tables can trigger removal of
elements from the table list (if MERGE tables are involved),
*/
close_tables_for_reopen(thd, start, ot_ctx.start_of_statement_svp());
/*
Here we rely on the fact that 'tables' still points to the valid
TABLE_LIST element. Altough currently this assumption is valid
it may change in future.
*/
if (ot_ctx.recover_from_failed_open())
goto err;
/* Re-open temporary tables after close_tables_for_reopen(). */
if (open_temporary_tables(thd, *start))
goto err;
error= FALSE;
goto restart;
}
goto err;
}
DEBUG_SYNC(thd, "open_tables_after_open_and_process_table");
}
/*
Iterate through set of tables and generate table access audit events.
*/
#ifndef EMBEDDED_LIBRARY
if (!audit_notified && mysql_audit_table_access_notify(thd, *start))
{
error= true;
goto err;
}
/*
Event is not generated in the next loop. It may contain duplicated
table entries as well as new tables discovered for stored procedures.
Events for these tables will be generated during the queries of these
stored procedures.
*/
audit_notified= true;
#endif /* !EMBEDDED_LIBRARY */
/*
If we are not already in prelocked mode and extended table list is
not yet built for our statement we need to cache routines it uses
and build the prelocking list for it.
If we are not in prelocked mode but have built the extended table
list, we still need to call open_and_process_routine() to take
MDL locks on the routines.
*/
if (thd->locked_tables_mode <= LTM_LOCK_TABLES)
{
bool routine_modifies_data;
/*
Process elements of the prelocking set which are present there
since parsing stage or were added to it by invocations of
Prelocking_strategy methods in the above loop over tables.
For example, if element is a routine, cache it and then,
if prelocking strategy prescribes so, add tables it uses to the
table list and routines it might invoke to the prelocking set.
*/
for (Sroutine_hash_entry *rt= *sroutine_to_open; rt;
sroutine_to_open= &rt->next, rt= rt->next)
{
bool need_prelocking= false;
TABLE_LIST **save_query_tables_last= thd->lex->query_tables_last;
error= open_and_process_routine(thd, thd->lex, rt, prelocking_strategy,
has_prelocking_list, &ot_ctx,
&need_prelocking,
&routine_modifies_data);
if (need_prelocking && ! thd->lex->requires_prelocking())
thd->lex->mark_as_requiring_prelocking(save_query_tables_last);
if (need_prelocking && ! *start)
*start= thd->lex->query_tables;
if (error)
{
if (ot_ctx.can_recover_from_failed_open())
{
close_tables_for_reopen(thd, start,
ot_ctx.start_of_statement_svp());
if (ot_ctx.recover_from_failed_open())
goto err;
/* Re-open temporary tables after close_tables_for_reopen(). */
if (open_temporary_tables(thd, *start))
goto err;
error= FALSE;
goto restart;
}
/*
Serious error during reading stored routines from mysql.proc table.
Something is wrong with the table or its contents, and an error has
been emitted; we must abort.
*/
goto err;
}
// Remember if any of SF modifies data.
some_routine_modifies_data|= routine_modifies_data;
}
}
}
/* Accessing data in XA_IDLE or XA_PREPARED is not allowed. */
if (*start &&
thd->get_transaction()->xid_state()->check_xa_idle_or_prepared(true))
DBUG_RETURN(true);
/*
If some routine is modifying the table then the statement is not read only.
If timer is enabled then resetting the timer in this case.
*/
if (thd->timer && some_routine_modifies_data)
{
reset_statement_timer(thd);
push_warning(thd, Sql_condition::SL_NOTE, ER_NON_RO_SELECT_DISABLE_TIMER,
ER(ER_NON_RO_SELECT_DISABLE_TIMER));
}
/*
After successful open of all tables, including MERGE parents and
children, attach the children to their parents. At end of statement,
the children are detached. Attaching and detaching are always done,
even under LOCK TABLES.
We also convert all TL_WRITE_DEFAULT and TL_READ_DEFAULT locks to
appropriate "real" lock types to be used for locking and to be passed
to storage engine.
*/
for (tables= *start; tables; tables= tables->next_global)
{
TABLE *tbl= tables->table;
/*
NOTE: temporary merge tables should be processed here too, because
a temporary merge table can be based on non-temporary tables.
*/
/* Schema tables may not have a TABLE object here. */
if (tbl && tbl->file->ht->db_type == DB_TYPE_MRG_MYISAM)
{
/* MERGE tables need to access parent and child TABLE_LISTs. */
DBUG_ASSERT(tbl->pos_in_table_list == tables);
if (tbl->file->extra(HA_EXTRA_ATTACH_CHILDREN))
{
error= TRUE;
goto err;
}
}
/* Set appropriate TABLE::lock_type. */
if (tbl && tables->lock_type != TL_UNLOCK &&
!thd->locked_tables_mode)
{
if (tables->lock_type == TL_WRITE_DEFAULT)
tbl->reginfo.lock_type= thd->update_lock_default;
else if (tables->lock_type == TL_WRITE_CONCURRENT_DEFAULT)
tables->table->reginfo.lock_type= thd->insert_lock_default;
else if (tables->lock_type == TL_READ_DEFAULT)
tbl->reginfo.lock_type=
read_lock_type_for_table(thd, thd->lex, tables,
some_routine_modifies_data);
else
tbl->reginfo.lock_type= tables->lock_type;
}
}
err:
if (error && *table_to_open)
{
(*table_to_open)->table= NULL;
}
DBUG_PRINT("open_tables", ("returning: %d", (int) error));
DBUG_RETURN(error);
}
然后进入handle_query内部，进行、
- Preparation
- Locking of tables
- Optimization
- Execution or explain
- Cleanup
这几步
/**
