一、Sql流程
MySql是数据库，这次就分析一下一条SQL语句的流程，流程可能不会全面展开分析，当后面遇到具体的模块时，再由各个模块深入学习。如果使用过MySql的客户端（任意一种都可以），基本的形式就是在客户端写一条SQL语句，然后点击运行，正常的情况下，就会返回这条SQL执行后的结果。
可能学习Sql源码的人不少，但学习编译器知识的人就少多了。在SQL语句的执行过程中，其实SQL语句就是一门语言，只不过这门语言相对于其它经常接触到的比如C/c++，JAVA等语言来比，它就是一个小儿科了。但无论怎么小儿科，所有的语言处理的机制都是一样的，只是有些地方可以简化罢了。
先看一看Sql语句执行的流程：
1、建立客户端和服务端的通信连接。
2、客户端向服务端发起请求即发送SQL语句。
3、查询缓存（在8.0后删除）即在目前分析的版本已经没有。
4、服务器端对SQL语句进行解析处理。
5、查询优化并形成执行计划。
6、执行查询计划，调用存储引擎并对数据处理。
7、返回客户端（并缓存，8.0删除）
今天重点分析一下命令的接收和处理这一模块，从此处可以引发后面的一系列的动作。
二、源码分析
在前面的分析中知道客户端连接上来后，调用add_connection，它调用handle_connection：
bool Per_thread_connection_handler::add_connection(Channel_info *channel_info) {
int error = 0;
my_thread_handle id;
DBUG_TRACE;
// Simulate thread creation for test case before we check thread cache
DBUG_EXECUTE_IF("fail_thread_create", error = 1; goto handle_error;);
if (!check_idle_thread_and_enqueue_connection(channel_info)) return false;
channel_info->set_prior_thr_create_utime();
error =
mysql_thread_create(key_thread_one_connection, &id, &connection_attrib,
handle_connection, (void *)channel_info);
......
return false;
}
extern "C" {
static void *handle_connection(void *arg) {
Global_THD_manager *thd_manager = Global_THD_manager::get_instance();
Connection_handler_manager *handler_manager =
Connection_handler_manager::get_instance();
Channel_info *channel_info = static_cast<Channel_info *>(arg);
bool pthread_reused MY_ATTRIBUTE((unused)) = false;
if (my_thread_init()) {
connection_errors_internal++;
channel_info->send_error_and_close_channel(ER_OUT_OF_RESOURCES, 0, false);
handler_manager->inc_aborted_connects();
Connection_handler_manager::dec_connection_count();
delete channel_info;
my_thread_exit(nullptr);
return nullptr;
}
for (;;) {
THD *thd = init_new_thd(channel_info);
if (thd == nullptr) {
connection_errors_internal++;
handler_manager->inc_aborted_connects();
Connection_handler_manager::dec_connection_count();
break; // We are out of resources, no sense in continuing.
}
#ifdef HAVE_PSI_THREAD_INTERFACE
if (pthread_reused) {
/*
Reusing existing pthread:
Create new instrumentation for the new THD job,
and attach it to this running pthread.
*/
PSI_thread *psi = PSI_THREAD_CALL(new_thread)(key_thread_one_connection,
thd, thd->thread_id());
PSI_THREAD_CALL(set_thread_os_id)(psi);
PSI_THREAD_CALL(set_thread)(psi);
}
#endif
#ifdef HAVE_PSI_THREAD_INTERFACE
/* Find the instrumented thread */
PSI_thread *psi = PSI_THREAD_CALL(get_thread)();
/* Save it within THD, so it can be inspected */
thd->set_psi(psi);
#endif /* HAVE_PSI_THREAD_INTERFACE */
mysql_thread_set_psi_id(thd->thread_id());
mysql_thread_set_psi_THD(thd);
MYSQL_SOCKET socket = thd->get_protocol_classic()->get_vio()->mysql_socket;
mysql_socket_set_thread_owner(socket);
thd_manager->add_thd(thd);
if (thd_prepare_connection(thd))
handler_manager->inc_aborted_connects();
else {
//最主要的是这里处理命令
while (thd_connection_alive(thd)) {
if (do_command(thd)) break;
}
end_connection(thd);
}
close_connection(thd, 0, false, false);
thd->get_stmt_da()->reset_diagnostics_area();
thd->release_resources();
// Clean up errors now, before possibly waiting for a new connection.
#if OPENSSL_VERSION_NUMBER < 0x10100000L
ERR_remove_thread_state(0);
#endif /* OPENSSL_VERSION_NUMBER < 0x10100000L */
thd_manager->remove_thd(thd);
Connection_handler_manager::dec_connection_count();
#ifdef HAVE_PSI_THREAD_INTERFACE
/*
Delete the instrumentation for the job that just completed.
*/
thd->set_psi(nullptr);
PSI_THREAD_CALL(delete_current_thread)();
#endif /* HAVE_PSI_THREAD_INTERFACE */
delete thd;
// Server is shutting down so end the pthread.
if (connection_events_loop_aborted()) break;
channel_info = Per_thread_connection_handler::block_until_new_connection();
if (channel_info == nullptr) break;
pthread_reused = true;
if (connection_events_loop_aborted()) {
// Close the channel and exit as server is undergoing shutdown.
channel_info->send_error_and_close_channel(ER_SERVER_SHUTDOWN, 0, false);
delete channel_info;
channel_info = nullptr;
Connection_handler_manager::dec_connection_count();
break;
}
}
my_thread_end();
my_thread_exit(nullptr);
return nullptr;
}
}
这个连接处理命令接着处理do_command,它是今天的主角：
bool do_command(THD *thd) {
bool return_value;
int rc;
NET *net = nullptr;
enum enum_server_command command;
COM_DATA com_data;
DBUG_TRACE;
assert(thd->is_classic_protocol());
/*
indicator of uninitialized lex => normal flow of errors handling
(see my_message_sql)
*/
thd->lex->set_current_query_block(nullptr);
/*
XXX: this code is here only to clear possible errors of init_connect.
Consider moving to prepare_new_connection_state() instead.
That requires making sure the DA is cleared before non-parsing statements
such as COM_QUIT.
*/
thd->clear_error(); // Clear error message
thd->get_stmt_da()->reset_diagnostics_area();
/*
This thread will do a blocking read from the client which
will be interrupted when the next command is received from
the client, the connection is closed or "net_wait_timeout"
number of seconds has passed.
*/
net = thd->get_protocol_classic()->get_net();
my_net_set_read_timeout(net, thd->variables.net_wait_timeout);
net_new_transaction(net);
/*
Synchronization point for testing of KILL_CONNECTION.
This sync point can wait here, to simulate slow code execution
between the last test of thd->killed and blocking in read().
The goal of this test is to verify that a connection does not
hang, if it is killed at this point of execution.
(Bug#37780 - main.kill fails randomly)
Note that the sync point wait itself will be terminated by a
kill. In this case it consumes a condition broadcast, but does
not change anything else. The consumed broadcast should not
matter here, because the read/recv() below doesn't use it.
*/
DEBUG_SYNC(thd, "before_do_command_net_read");
/*
Because of networking layer callbacks in place,
this call will maintain the following instrumentation:
- IDLE events
- SOCKET events
- STATEMENT events
- STAGE events
when reading a new network packet.
In particular, a new instrumented statement is started.
See init_net_server_extension()
*/
thd->m_server_idle = true;
rc = thd->get_protocol()->get_command(&com_data, &command);
thd->m_server_idle = false;
if (rc) {
#ifndef NDEBUG
char desc[VIO_DESCRIPTION_SIZE];
vio_description(net->vio, desc);
DBUG_PRINT("info", ("Got error %d reading command from socket %s",
net->error, desc));
#endif // NDEBUG
/* Instrument this broken statement as "statement/com/error" */
thd->m_statement_psi = MYSQL_REFINE_STATEMENT(
thd->m_statement_psi, com_statement_info[COM_END].m_key);
/* Check if we can continue without closing the connection */
/* The error must be set. */
assert(thd->is_error());
thd->send_statement_status();
/* Mark the statement completed. */
MYSQL_END_STATEMENT(thd->m_statement_psi, thd->get_stmt_da());
thd->m_statement_psi = nullptr;
thd->m_digest = nullptr;
if (rc < 0) {
return_value = true; // We have to close it.
goto out;
}
net->error = NET_ERROR_UNSET;
return_value = false;
goto out;
}
#ifndef NDEBUG
char desc[VIO_DESCRIPTION_SIZE];
vio_description(net->vio, desc);
DBUG_PRINT("info", ("Command on %s = %d (%s)", desc, command,
command_name[command].str));
#endif // NDEBUG
DBUG_PRINT("info", ("packet: '%*.s'; command: %d",
(int)thd->get_protocol_classic()->get_packet_length(),
thd->get_protocol_classic()->get_raw_packet(), command));
if (thd->get_protocol_classic()->bad_packet)
assert(0); // Should be caught earlier
// Reclaim some memory
thd->get_protocol_classic()->get_output_packet()->shrink(
thd->variables.net_buffer_length);
/* Restore read timeout value */
my_net_set_read_timeout(net, thd->variables.net_read_timeout);
DEBUG_SYNC(thd, "before_command_dispatch");
//看到这个分发的名字就知道啥意思了吧。上面把数据接受过来，进行初步的分析后到下面分发
return_value = dispatch_command(thd, &com_data, command);
thd->get_protocol_classic()->get_output_packet()->shrink(
thd->variables.net_buffer_length);
out:
/* The statement instrumentation must be closed in all cases. */
assert(thd->m_digest == nullptr);
assert(thd->m_statement_psi == nullptr);
return return_value;
}
这里先看一下通信用的数据结构，以方便后面的分析：
struct COM_INIT_DB_DATA {
const char *db_name;
unsigned long length;
};
struct COM_REFRESH_DATA {
unsigned char options;
};
struct COM_KILL_DATA {
unsigned long id;
};
struct COM_SET_OPTION_DATA {
unsigned int opt_command;
};
struct PS_PARAM {
unsigned char null_bit;
enum enum_field_types type;
unsigned char unsigned_type;
const unsigned char *value;
unsigned long length;
const unsigned char *name;
unsigned long name_length;
};
struct COM_STMT_EXECUTE_DATA {
unsigned long stmt_id;
unsigned long open_cursor;
PS_PARAM *parameters;
unsigned long parameter_count;
unsigned char has_new_types;
};
struct COM_STMT_FETCH_DATA {
unsigned long stmt_id;
unsigned long num_rows;
};
struct COM_STMT_SEND_LONG_DATA_DATA {
unsigned long stmt_id;
unsigned int param_number;
unsigned char *longdata;
unsigned long length;
};
struct COM_STMT_PREPARE_DATA {
const char *query;
unsigned int length;
};
struct COM_STMT_CLOSE_DATA {
unsigned int stmt_id;
};
struct COM_STMT_RESET_DATA {
unsigned int stmt_id;
};
struct COM_QUERY_DATA {
const char *query;
unsigned int length;
PS_PARAM *parameters;
unsigned long parameter_count;
};
struct COM_FIELD_LIST_DATA {
unsigned char *table_name;
unsigned int table_name_length;
const unsigned char *query;
unsigned int query_length;
};
union COM_DATA {
COM_INIT_DB_DATA com_init_db;
COM_REFRESH_DATA com_refresh;
COM_KILL_DATA com_kill;
COM_SET_OPTION_DATA com_set_option;
COM_STMT_EXECUTE_DATA com_stmt_execute;
COM_STMT_FETCH_DATA com_stmt_fetch;
COM_STMT_SEND_LONG_DATA_DATA com_stmt_send_long_data;
COM_STMT_PREPARE_DATA com_stmt_prepare;
COM_STMT_CLOSE_DATA com_stmt_close;
COM_STMT_RESET_DATA com_stmt_reset;
COM_QUERY_DATA com_query;
COM_FIELD_LIST_DATA com_field_list;
};
dispatch_command函数又是一个比较长的函数，里面充斥着各种类型的分支跳转：
bool dispatch_command(THD *thd, const COM_DATA *com_data,
enum enum_server_command command) {
bool error = false;
Global_THD_manager *thd_manager = Global_THD_manager::get_instance();
DBUG_TRACE;
DBUG_PRINT("info", ("command: %d", command));
Sql_cmd_clone *clone_cmd = nullptr;
/* For per-query performance counters with log_slow_statement */
struct System_status_var query_start_status;
struct System_status_var *query_start_status_ptr = nullptr;
if (opt_log_slow_extra) {
query_start_status_ptr = &query_start_status;
query_start_status = thd->status_var;
}
/* SHOW PROFILE instrumentation, begin */
#if defined(ENABLED_PROFILING)
thd->profiling->start_new_query();
#endif
/* Performance Schema Interface instrumentation, begin */
thd->m_statement_psi = MYSQL_REFINE_STATEMENT(
thd->m_statement_psi, com_statement_info[command].m_key);
thd->set_command(command);
/*
Commands which always take a long time are logged into
the slow log only if opt_log_slow_admin_statements is set.
*/
thd->enable_slow_log = true;
thd->lex->sql_command = SQLCOM_END; /* to avoid confusing VIEW detectors */
/*
KILL QUERY may come after cleanup in mysql_execute_command(). Next query
execution is interrupted due to this. So resetting THD::killed here.
THD::killed value can not be KILL_TIMEOUT here as timer used for statement
max execution time is disarmed in the cleanup stage of
mysql_execute_command. KILL CONNECTION should terminate the connection.
Hence resetting THD::killed only for KILL QUERY case here.
*/
if (thd->killed == THD::KILL_QUERY) thd->killed = THD::NOT_KILLED;
thd->set_time();
if (is_time_t_valid_for_timestamp(thd->query_start_in_secs()) == false) {
/*
If the time has gone past 2038 we need to shutdown the server. But
there is possibility of getting invalid time value on some platforms.
For example, gettimeofday() might return incorrect value on solaris
platform. Hence validating the current time with 5 iterations before
initiating the normal server shutdown process because of time getting
past 2038.
*/
const int max_tries = 5;
LogErr(WARNING_LEVEL, ER_CONFIRMING_THE_FUTURE, max_tries);
int tries = 0;
while (++tries <= max_tries) {
thd->set_time();
if (is_time_t_valid_for_timestamp(thd->query_start_in_secs()) == true) {
LogErr(WARNING_LEVEL, ER_BACK_IN_TIME, tries);
break;
}
LogErr(WARNING_LEVEL, ER_FUTURE_DATE, tries);
}
if (tries > max_tries) {
/*
If the time has got past 2038 we need to shut this server down
We do this by making sure every command is a shutdown and we
have enough privileges to shut the server down
TODO: remove this when we have full 64 bit my_time_t support
*/
LogErr(ERROR_LEVEL, ER_UNSUPPORTED_DATE);
ulong master_access = thd->security_context()->master_access();
thd->security_context()->set_master_access(master_access | SHUTDOWN_ACL);
error = true;
kill_mysql();
}
}
thd->set_query_id(next_query_id());
thd->reset_rewritten_query();
thd_manager->inc_thread_running();
if (!(server_command_flags[command] & CF_SKIP_QUESTIONS))
thd->status_var.questions++;
/**
Clear the set of flags that are expected to be cleared at the
beginning of each command.
*/
thd->server_status &= ~SERVER_STATUS_CLEAR_SET;
if (thd->get_protocol()->type() == Protocol::PROTOCOL_PLUGIN &&
!(server_command_flags[command] & CF_ALLOW_PROTOCOL_PLUGIN)) {
my_error(ER_PLUGGABLE_PROTOCOL_COMMAND_NOT_SUPPORTED, MYF(0));
thd->killed = THD::KILL_CONNECTION;
error = true;
goto done;
}
/**
Enforce password expiration for all RPC commands, except the
following:
COM_QUERY/COM_STMT_PREPARE and COM_STMT_EXECUTE do a more
fine-grained check later.
COM_STMT_CLOSE and COM_STMT_SEND_LONG_DATA don't return anything.
COM_PING only discloses information that the server is running,
and that's available through other means.
COM_QUIT should work even for expired statements.
*/
if (unlikely(thd->security_context()->password_expired() &&
command != COM_QUERY && command != COM_STMT_CLOSE &&
command != COM_STMT_SEND_LONG_DATA && command != COM_PING &&
command != COM_QUIT && command != COM_STMT_PREPARE &&
command != COM_STMT_EXECUTE)) {
my_error(ER_MUST_CHANGE_PASSWORD, MYF(0));
goto done;
}
if (mysql_audit_notify(thd, AUDIT_EVENT(MYSQL_AUDIT_COMMAND_START), command,
command_name[command].str)) {
goto done;
}
switch (command) {
case COM_INIT_DB: {
LEX_STRING tmp;
thd->status_var.com_stat[SQLCOM_CHANGE_DB]++;
thd->convert_string(&tmp, system_charset_info,
com_data->com_init_db.db_name,
com_data->com_init_db.length, thd->charset());
LEX_CSTRING tmp_cstr = {tmp.str, tmp.length};
if (!mysql_change_db(thd, tmp_cstr, false)) {
query_logger.general_log_write(thd, command, thd->db().str,
thd->db().length);
my_ok(thd);
}
break;
}
case COM_REGISTER_SLAVE: {
// TODO: access of protocol_classic should be removed
if (!register_slave(thd, thd->get_protocol_classic()->get_raw_packet(),
thd->get_protocol_classic()->get_packet_length()))
my_ok(thd);
break;
}
case COM_RESET_CONNECTION: {
thd->status_var.com_other++;
thd->cleanup_connection();
my_ok(thd);
break;
}
case COM_CLONE: {
thd->status_var.com_other++;
/* Try loading clone plugin */
clone_cmd = new (thd->mem_root) Sql_cmd_clone();
if (clone_cmd && clone_cmd->load(thd)) {
clone_cmd = nullptr;
}
thd->lex->m_sql_cmd = clone_cmd;
thd->lex->sql_command = SQLCOM_CLONE;
break;
}
case COM_CHANGE_USER: {
int auth_rc;
thd->status_var.com_other++;
thd->cleanup_connection();
USER_CONN *save_user_connect =
const_cast<USER_CONN *>(thd->get_user_connect());
LEX_CSTRING save_db = thd->db();
Security_context save_security_ctx(*(thd->security_context()));
auth_rc = acl_authenticate(thd, COM_CHANGE_USER);
auth_rc |= mysql_audit_notify(
thd, AUDIT_EVENT(MYSQL_AUDIT_CONNECTION_CHANGE_USER));
if (auth_rc) {
*thd->security_context() = save_security_ctx;
thd->set_user_connect(save_user_connect);
thd->reset_db(save_db);
my_error(ER_ACCESS_DENIED_CHANGE_USER_ERROR, MYF(0),
thd->security_context()->user().str,
thd->security_context()->host_or_ip().str,
(thd->password ? ER_THD(thd, ER_YES) : ER_THD(thd, ER_NO)));
thd->killed = THD::KILL_CONNECTION;
error = true;
} else {
#ifdef HAVE_PSI_THREAD_INTERFACE
/* we've authenticated new user */
PSI_THREAD_CALL(notify_session_change_user)(thd->get_psi());
#endif /* HAVE_PSI_THREAD_INTERFACE */
if (save_user_connect) decrease_user_connections(save_user_connect);
mysql_mutex_lock(&thd->LOCK_thd_data);
my_free(const_cast<char *>(save_db.str));
save_db = NULL_CSTR;
mysql_mutex_unlock(&thd->LOCK_thd_data);
}
break;
}
case COM_STMT_EXECUTE: {
/* Clear possible warnings from the previous command */
thd->reset_for_next_command();
Prepared_statement *stmt = nullptr;
if (!mysql_stmt_precheck(thd, com_data, command, &stmt)) {
PS_PARAM *parameters = com_data->com_stmt_execute.parameters;
copy_bind_parameter_values(thd, parameters,
com_data->com_stmt_execute.parameter_count);
mysqld_stmt_execute(thd, stmt, com_data->com_stmt_execute.has_new_types,
com_data->com_stmt_execute.open_cursor, parameters);
thd->bind_parameter_values = nullptr;
thd->bind_parameter_values_count = 0;
}
break;
}
case COM_STMT_FETCH: {
/* Clear possible warnings from the previous command */
thd->reset_for_next_command();
Prepared_statement *stmt = nullptr;
if (!mysql_stmt_precheck(thd, com_data, command, &stmt))
mysqld_stmt_fetch(thd, stmt, com_data->com_stmt_fetch.num_rows);
break;
}
case COM_STMT_SEND_LONG_DATA: {
Prepared_statement *stmt;
thd->get_stmt_da()->disable_status();
if (!mysql_stmt_precheck(thd, com_data, command, &stmt))
mysql_stmt_get_longdata(thd, stmt,
com_data->com_stmt_send_long_data.param_number,
com_data->com_stmt_send_long_data.longdata,
com_data->com_stmt_send_long_data.length);
break;
}
case COM_STMT_PREPARE: {
/* Clear possible warnings from the previous command */
thd->reset_for_next_command();
Prepared_statement *stmt = nullptr;
DBUG_EXECUTE_IF("parser_stmt_to_error_log", {
LogErr(INFORMATION_LEVEL, ER_PARSER_TRACE,
com_data->com_stmt_prepare.query);
});
DBUG_EXECUTE_IF("parser_stmt_to_error_log_with_system_prio", {
LogErr(SYSTEM_LEVEL, ER_PARSER_TRACE, com_data->com_stmt_prepare.query);
});
if (!mysql_stmt_precheck(thd, com_data, command, &stmt))
mysqld_stmt_prepare(thd, com_data->com_stmt_prepare.query,
com_data->com_stmt_prepare.length, stmt);
break;
}
case COM_STMT_CLOSE: {
Prepared_statement *stmt = nullptr;
thd->get_stmt_da()->disable_status();
if (!mysql_stmt_precheck(thd, com_data, command, &stmt))
mysqld_stmt_close(thd, stmt);
break;
}
case COM_STMT_RESET: {
/* Clear possible warnings from the previous command */
thd->reset_for_next_command();
Prepared_statement *stmt = nullptr;
if (!mysql_stmt_precheck(thd, com_data, command, &stmt))
mysqld_stmt_reset(thd, stmt);
break;
}
case COM_QUERY: {
assert(thd->m_digest == nullptr);
thd->m_digest = &thd->m_digest_state;
thd->m_digest->reset(thd->m_token_array, max_digest_length);
if (alloc_query(thd, com_data->com_query.query,
com_data->com_query.length))
break; // fatal error is set
const char *packet_end = thd->query().str + thd->query().length;
if (opt_general_log_raw)
query_logger.general_log_write(thd, command, thd->query().str,
thd->query().length);
DBUG_PRINT("query", ("%-.4096s", thd->query().str));
#if defined(ENABLED_PROFILING)
thd->profiling->set_query_source(thd->query().str, thd->query().length);
#endif
const LEX_CSTRING orig_query = thd->query();
Parser_state parser_state;
if (parser_state.init(thd, thd->query().str, thd->query().length)) break;
// we produce digest if it's not explicitly turned off
// by setting maximum digest length to zero
if (get_max_digest_length() != 0)
parser_state.m_input.m_compute_digest = true;
// Initially, prepare and optimize the statement for the primary
// storage engine. If an eligible secondary storage engine is
// found, the statement may be reprepared for the secondary
// storage engine later.
const auto saved_secondary_engine = thd->secondary_engine_optimization();
thd->set_secondary_engine_optimization(
Secondary_engine_optimization::PRIMARY_TENTATIVELY);
copy_bind_parameter_values(thd, com_data->com_query.parameters,
com_data->com_query.parameter_count);
dispatch_sql_command(thd, &parser_state);
// Check if the statement failed and needs to be restarted in
// another storage engine.
check_secondary_engine_statement(thd, &parser_state, orig_query.str,
orig_query.length);
thd->set_secondary_engine_optimization(saved_secondary_engine);
DBUG_EXECUTE_IF("parser_stmt_to_error_log", {
LogErr(INFORMATION_LEVEL, ER_PARSER_TRACE, thd->query().str);
});
DBUG_EXECUTE_IF("parser_stmt_to_error_log_with_system_prio", {
LogErr(SYSTEM_LEVEL, ER_PARSER_TRACE, thd->query().str);
});
while (!thd->killed && (parser_state.m_lip.found_semicolon != nullptr) &&
!thd->is_error()) {
/*
Multiple queries exits, execute them individually
*/
const char *beginning_of_next_stmt = parser_state.m_lip.found_semicolon;
/* Finalize server status flags after executing a statement. */
thd->update_slow_query_status();
thd->send_statement_status();
mysql_audit_notify(
thd, AUDIT_EVENT(MYSQL_AUDIT_GENERAL_STATUS),
thd->get_stmt_da()->is_error() ? thd->get_stmt_da()->mysql_errno()
: 0,
command_name[command].str, command_name[command].length);
size_t length =
static_cast<size_t>(packet_end - beginning_of_next_stmt);
log_slow_statement(thd, query_start_status_ptr);
if (query_start_status_ptr) {
/* Reset for values at start of next statement */
query_start_status = thd->status_var;
}
/* Remove garbage at start of query */
while (length > 0 &&
my_isspace(thd->charset(), *beginning_of_next_stmt)) {
beginning_of_next_stmt++;
length--;
}
/* PSI end */
MYSQL_END_STATEMENT(thd->m_statement_psi, thd->get_stmt_da());
thd->m_statement_psi = nullptr;
thd->m_digest = nullptr;
/* SHOW PROFILE end */
#if defined(ENABLED_PROFILING)
thd->profiling->finish_current_query();
#endif
/* SHOW PROFILE begin */
#if defined(ENABLED_PROFILING)
thd->profiling->start_new_query("continuing");
thd->profiling->set_query_source(beginning_of_next_stmt, length);
#endif
/* PSI begin */
thd->m_digest = &thd->m_digest_state;
thd->m_digest->reset(thd->m_token_array, max_digest_length);
thd->m_statement_psi = MYSQL_START_STATEMENT(
&thd->m_statement_state, com_statement_info[command].m_key,
thd->db().str, thd->db().length, thd->charset(), nullptr);
THD_STAGE_INFO(thd, stage_starting);
thd->set_query(beginning_of_next_stmt, length);
thd->set_query_id(next_query_id());
/*
Count each statement from the client.
*/
thd->status_var.questions++;
thd->set_time(); /* Reset the query start time. */
parser_state.reset(beginning_of_next_stmt, length);
thd->set_secondary_engine_optimization(
Secondary_engine_optimization::PRIMARY_TENTATIVELY);
/* TODO: set thd->lex->sql_command to SQLCOM_END here */
dispatch_sql_command(thd, &parser_state);
check_secondary_engine_statement(thd, &parser_state,
beginning_of_next_stmt, length);
thd->set_secondary_engine_optimization(saved_secondary_engine);
}
thd->bind_parameter_values = nullptr;
thd->bind_parameter_values_count = 0;
/* Need to set error to true for graceful shutdown */
if ((thd->lex->sql_command == SQLCOM_SHUTDOWN) &&
(thd->get_stmt_da()->is_ok()))
error = true;
DBUG_PRINT("info", ("query ready"));
break;
}
case COM_FIELD_LIST: // This isn't actually needed
{
char *fields;
/* Locked closure of all tables */
LEX_STRING table_name;
LEX_STRING db;
push_deprecated_warn(thd, "COM_FIELD_LIST",
"SHOW COLUMNS FROM statement");
/*
SHOW statements should not add the used tables to the list of tables
used in a transaction.
*/
MDL_savepoint mdl_savepoint = thd->mdl_context.mdl_savepoint();
thd->status_var.com_stat[SQLCOM_SHOW_FIELDS]++;
if (thd->copy_db_to(&db.str, &db.length)) break;
thd->convert_string(&table_name, system_charset_info,
(char *)com_data->com_field_list.table_name,
com_data->com_field_list.table_name_length,
thd->charset());
Ident_name_check ident_check_status =
check_table_name(table_name.str, table_name.length);
if (ident_check_status == Ident_name_check::WRONG) {
/* this is OK due to convert_string() null-terminating the string */
my_error(ER_WRONG_TABLE_NAME, MYF(0), table_name.str);
break;
} else if (ident_check_status == Ident_name_check::TOO_LONG) {
my_error(ER_TOO_LONG_IDENT, MYF(0), table_name.str);
break;
}
mysql_reset_thd_for_next_command(thd);
lex_start(thd);
/* Must be before we init the table list. */
if (lower_case_table_names && !is_infoschema_db(db.str, db.length))
table_name.length = my_casedn_str(files_charset_info, table_name.str);
TABLE_LIST table_list(db.str, db.length, table_name.str,
table_name.length, table_name.str, TL_READ);
/*
Init TABLE_LIST members necessary when the undelrying
table is view.
*/
table_list.query_block = thd->lex->query_block;
thd->lex->query_block->table_list.link_in_list(&table_list,
&table_list.next_local);
thd->lex->add_to_query_tables(&table_list);
if (is_infoschema_db(table_list.db, table_list.db_length)) {
ST_SCHEMA_TABLE *schema_table =
find_schema_table(thd, table_list.alias);
if (schema_table) table_list.schema_table = schema_table;
}
if (!(fields =
(char *)thd->memdup(com_data->com_field_list.query,
com_data->com_field_list.query_length)))
break;
// Don't count end \0
thd->set_query(fields, com_data->com_field_list.query_length - 1);
query_logger.general_log_print(thd, command, "%s %s",
table_list.table_name, fields);
if (open_temporary_tables(thd, &table_list)) break;
if (check_table_access(thd, SELECT_ACL, &table_list, true, UINT_MAX,
false))
break;
thd->lex->sql_command = SQLCOM_SHOW_FIELDS;
// See comment in opt_trace_disable_if_no_security_context_access()
Opt_trace_start ots(thd, &table_list, thd->lex->sql_command, nullptr,
nullptr, 0, nullptr, nullptr);
mysqld_list_fields(thd, &table_list, fields);
thd->lex->cleanup(thd, true);
/* No need to rollback statement transaction, it's not started. */
assert(thd->get_transaction()->is_empty(Transaction_ctx::STMT));
close_thread_tables(thd);
thd->mdl_context.rollback_to_savepoint(mdl_savepoint);
if (thd->transaction_rollback_request) {
/*
Transaction rollback was requested since MDL deadlock was
discovered while trying to open tables. Rollback transaction
in all storage engines including binary log and release all
locks.
*/
trans_rollback_implicit(thd);
thd->mdl_context.release_transactional_locks();
}
thd->cleanup_after_query();
break;
}
case COM_QUIT:
/* Prevent results of the form, "n>0 rows sent, 0 bytes sent" */
thd->set_sent_row_count(0);
/* We don't calculate statistics for this command */
query_logger.general_log_print(thd, command, NullS);
// Don't give 'abort' message
// TODO: access of protocol_classic should be removed
if (thd->is_classic_protocol())
thd->get_protocol_classic()->get_net()->error = NET_ERROR_UNSET;
thd->get_stmt_da()->disable_status(); // Don't send anything back
error = true; // End server
break;
case COM_BINLOG_DUMP_GTID:
// TODO: access of protocol_classic should be removed
error = com_binlog_dump_gtid(
thd, (char *)thd->get_protocol_classic()->get_raw_packet(),
thd->get_protocol_classic()->get_packet_length());
break;
case COM_BINLOG_DUMP:
// TODO: access of protocol_classic should be removed
error = com_binlog_dump(
thd, (char *)thd->get_protocol_classic()->get_raw_packet(),
thd->get_protocol_classic()->get_packet_length());
break;
case COM_REFRESH: {
int not_used;
push_deprecated_warn(thd, "COM_REFRESH", "FLUSH statement");
/*
Initialize thd->lex since it's used in many base functions, such as
open_tables(). Otherwise, it remains uninitialized and may cause crash
during execution of COM_REFRESH.
*/
lex_start(thd);
thd->status_var.com_stat[SQLCOM_FLUSH]++;
ulong options = (ulong)com_data->com_refresh.options;
if (trans_commit_implicit(thd)) break;
thd->mdl_context.release_transactional_locks();
if (check_global_access(thd, RELOAD_ACL)) break;
query_logger.general_log_print(thd, command, NullS);
#ifndef NDEBUG
bool debug_simulate = false;
DBUG_EXECUTE_IF("simulate_detached_thread_refresh",
debug_simulate = true;);
if (debug_simulate) {
/*
Simulate a reload without a attached thread session.
Provides a environment similar to that of when the
server receives a SIGHUP signal and reloads caches
and flushes tables.
*/
bool res;
current_thd = nullptr;
res = handle_reload_request(nullptr, options | REFRESH_FAST, nullptr,
¬_used);
current_thd = thd;
if (res) break;
} else
#endif
if (handle_reload_request(thd, options, (TABLE_LIST *)nullptr,
¬_used))
break;
if (trans_commit_implicit(thd)) break;
close_thread_tables(thd);
thd->mdl_context.release_transactional_locks();
my_ok(thd);
break;
}
case COM_STATISTICS: {
System_status_var current_global_status_var;
ulong uptime;
size_t length MY_ATTRIBUTE((unused));
ulonglong queries_per_second1000;
char buff[250];
size_t buff_len = sizeof(buff);
query_logger.general_log_print(thd, command, NullS);
thd->status_var.com_stat[SQLCOM_SHOW_STATUS]++;
mysql_mutex_lock(&LOCK_status);
calc_sum_of_all_status(¤t_global_status_var);
mysql_mutex_unlock(&LOCK_status);
if (!(uptime = (ulong)(thd->query_start_in_secs() - server_start_time)))
queries_per_second1000 = 0;
else
queries_per_second1000 = thd->query_id * 1000LL / uptime;
length = snprintf(buff, buff_len - 1,
"Uptime: %lu Threads: %d Questions: %lu "
"Slow queries: %llu Opens: %llu Flush tables: %lu "
"Open tables: %u Queries per second avg: %u.%03u",
uptime, (int)thd_manager->get_thd_count(),
(ulong)thd->query_id,
current_global_status_var.long_query_count,
current_global_status_var.opened_tables,
refresh_version, table_cache_manager.cached_tables(),
(uint)(queries_per_second1000 / 1000),
(uint)(queries_per_second1000 % 1000));
// TODO: access of protocol_classic should be removed.
// should be rewritten using store functions
if (thd->get_protocol_classic()->write(pointer_cast<const uchar *>(buff),
length))
break;
if (thd->get_protocol()->flush()) break;
thd->get_stmt_da()->disable_status();
break;
}
case COM_PING:
thd->status_var.com_other++;
my_ok(thd); // Tell client we are alive
break;
case COM_PROCESS_INFO:
bool global_access;
LEX_CSTRING db_saved;
thd->status_var.com_stat[SQLCOM_SHOW_PROCESSLIST]++;
push_deprecated_warn(thd, "COM_PROCESS_INFO",
"SHOW PROCESSLIST statement");
global_access = (check_global_access(thd, PROCESS_ACL) == 0);
if (!thd->security_context()->priv_user().str[0] && !global_access) break;
query_logger.general_log_print(thd, command, NullS);
db_saved = thd->db();
DBUG_EXECUTE_IF("force_db_name_to_null", thd->reset_db(NULL_CSTR););
mysqld_list_processes(
thd, global_access ? NullS : thd->security_context()->priv_user().str,
false);
DBUG_EXECUTE_IF("force_db_name_to_null", thd->reset_db(db_saved););
break;
case COM_PROCESS_KILL: {
push_deprecated_warn(thd, "COM_PROCESS_KILL",
"KILL CONNECTION/QUERY statement");
if (thd_manager->get_thread_id() & (~0xfffffffful))
my_error(ER_DATA_OUT_OF_RANGE, MYF(0), "thread_id", "mysql_kill()");
else {
thd->status_var.com_stat[SQLCOM_KILL]++;
sql_kill(thd, com_data->com_kill.id, false);
}
break;
}
case COM_SET_OPTION: {
thd->status_var.com_stat[SQLCOM_SET_OPTION]++;
switch (com_data->com_set_option.opt_command) {
case (int)MYSQL_OPTION_MULTI_STATEMENTS_ON:
// TODO: access of protocol_classic should be removed
thd->get_protocol_classic()->add_client_capability(
CLIENT_MULTI_STATEMENTS);
my_eof(thd);
break;
case (int)MYSQL_OPTION_MULTI_STATEMENTS_OFF:
thd->get_protocol_classic()->remove_client_capability(
CLIENT_MULTI_STATEMENTS);
my_eof(thd);
break;
default:
my_error(ER_UNKNOWN_COM_ERROR, MYF(0));
break;
}
break;
}
case COM_DEBUG:
thd->status_var.com_other++;
if (check_global_access(thd, SUPER_ACL)) break; /* purecov: inspected */
query_logger.general_log_print(thd, command, NullS);
my_eof(thd);
#ifdef WITH_LOCK_ORDER
LO_dump();
#endif /* WITH_LOCK_ORDER */
break;
case COM_SLEEP:
case COM_CONNECT: // Impossible here
case COM_TIME: // Impossible from client
case COM_DELAYED_INSERT: // INSERT DELAYED has been removed.
case COM_END:
default:
my_error(ER_UNKNOWN_COM_ERROR, MYF(0));
break;
}
done:
assert(thd->open_tables == nullptr ||
(thd->locked_tables_mode == LTM_LOCK_TABLES));
/* Finalize server status flags after executing a command. */
thd->update_slow_query_status();
if (thd->killed) thd->send_kill_message();
thd->send_statement_status();
/* After sending response, switch to clone protocol */
if (clone_cmd != nullptr) {
assert(command == COM_CLONE);
error = clone_cmd->execute_server(thd);
}
thd->rpl_thd_ctx.session_gtids_ctx().notify_after_response_packet(thd);
if (!thd->is_error() && !thd->killed)
mysql_audit_notify(thd, AUDIT_EVENT(MYSQL_AUDIT_GENERAL_RESULT), 0, nullptr,
0);
mysql_audit_notify(
thd, AUDIT_EVENT(MYSQL_AUDIT_GENERAL_STATUS),
thd->get_stmt_da()->is_error() ? thd->get_stmt_da()->mysql_errno() : 0,
command_name[command].str, command_name[command].length);
/* command_end is informational only. The plugin cannot abort
execution of the command at thie point. */
mysql_audit_notify(thd, AUDIT_EVENT(MYSQL_AUDIT_COMMAND_END), command,
command_name[command].str);
log_slow_statement(thd, query_start_status_ptr);
THD_STAGE_INFO(thd, stage_cleaning_up);
thd->reset_query();
thd->set_command(COM_SLEEP);
thd->proc_info = nullptr;
thd->lex->sql_command = SQLCOM_END;
/* Performance Schema Interface instrumentation, end */
MYSQL_END_STATEMENT(thd->m_statement_psi, thd->get_stmt_da());
thd->m_statement_psi = nullptr;
thd->m_digest = nullptr;
thd->reset_query_for_display();
/* Prevent rewritten query from getting "stuck" in SHOW PROCESSLIST. */
thd->reset_rewritten_query();
thd_manager->dec_thread_running();
/* Freeing the memroot will leave the THD::work_part_info invalid. */
thd->work_part_info = nullptr;
/*
If we've allocated a lot of memory (compared to the user's desired
preallocation size; note that we don't actually preallocate anymore), free
it so that one big query won't cause us to hold on to a lot of RAM forever.
If not, keep the last block so that the next query will hopefully be able to
run without allocating memory from the OS.
The factor 5 is pretty much arbitrary, but ends up allowing three
allocations (1 + 1.5 + 1.5²) under the current allocation policy.
*/
if (thd->mem_root->allocated_size() < 5 * thd->variables.query_prealloc_size)
thd->mem_root->ClearForReuse();
else
thd->mem_root->Clear();
/* SHOW PROFILE instrumentation, end */
#if defined(ENABLED_PROFILING)
thd->profiling->finish_current_query();
#endif
return error;
}
可以看到在do_command中得到的com_data通过指针传入到这个函数里。当然THD这个庞然大物也跟了进来。这里虽然有很多case分支，但是重点分析一个Query，这也是在Sql语句中用得最多的一个。它会调用dispatch_sql_command函数，在这个函数内部，会看到如下的代码：
void dispatch_sql_command(THD *thd, Parser_state *parser_state) {
DBUG_TRACE;
DBUG_PRINT("dispatch_sql_command", ("query: '%s'", thd->query().str));
DBUG_EXECUTE_IF("parser_debug", turn_parser_debug_on(););
//学过编译知识的的一眼就看明白了。没有的，就略过
mysql_reset_thd_for_next_command(thd);
lex_start(thd);
thd->m_parser_state = parser_state;
invoke_pre_parse_rewrite_plugins(thd);
thd->m_parser_state = nullptr;
// we produce digest if it's not explicitly turned off
// by setting maximum digest length to zero
if (get_max_digest_length() != 0)
parser_state->m_input.m_compute_digest = true;
LEX *lex = thd->lex;
const char *found_semicolon = nullptr;
bool err = thd->get_stmt_da()->is_error();
if (!err) {
err = parse_sql(thd, parser_state, nullptr);
if (!err) err = invoke_post_parse_rewrite_plugins(thd, false);
found_semicolon = parser_state->m_lip.found_semicolon;
}
DEBUG_SYNC_C("sql_parse_before_rewrite");
if (!err) {
/*
Rewrite the query for logging and for the Performance Schema
statement tables. (Raw logging happened earlier.)
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->m_rewritten_query is still
empty from being reset in alloc_query().
*/
if (thd->rewritten_query().length() == 0) mysql_rewrite_query(thd);
if (thd->rewritten_query().length()) {
lex->safe_to_cache_query = false; // see comments below
thd->set_query_for_display(thd->rewritten_query().ptr(),
thd->rewritten_query().length());
} else if (thd->slave_thread) {
/*
In the slave, we add the information to pfs.events_statements_history,
but not to pfs.threads, as that is what the test suite expects.
*/
MYSQL_SET_STATEMENT_TEXT(thd->m_statement_psi, thd->query().str,
thd->query().length);
} else {
thd->set_query_for_display(thd->query().str, thd->query().length);
}
if (!(opt_general_log_raw || thd->slave_thread)) {
if (thd->rewritten_query().length())
query_logger.general_log_write(thd, COM_QUERY,
thd->rewritten_query().ptr(),
thd->rewritten_query().length());
else {
size_t qlen = found_semicolon ? (found_semicolon - thd->query().str)
: thd->query().length;
query_logger.general_log_write(thd, COM_QUERY, thd->query().str, qlen);
}
}
}
DEBUG_SYNC_C("sql_parse_after_rewrite");
if (!err) {
thd->m_statement_psi = MYSQL_REFINE_STATEMENT(
thd->m_statement_psi, sql_statement_info[thd->lex->sql_command].m_key);
if (mqh_used && thd->get_user_connect() &&
check_mqh(thd, lex->sql_command)) {
if (thd->is_classic_protocol())
thd->get_protocol_classic()->get_net()->error = NET_ERROR_UNSET;
} else {
if (!thd->is_error()) {
/*
Binlog logs a string starting from thd->query and having length
thd->query_length; so we set thd->query_length correctly (to not
log several statements in one event, when we executed only first).
We set it to not see the ';' (otherwise it would get into binlog
and Query_log_event::print() would give ';;' output).
This also helps display only the current query in SHOW
PROCESSLIST.
*/
if (found_semicolon && (ulong)(found_semicolon - thd->query().str))
thd->set_query(
thd->query().str,
static_cast<size_t>(found_semicolon - thd->query().str - 1));
/* Actually execute the query */
if (found_semicolon) {
lex->safe_to_cache_query = false;
thd->server_status |= SERVER_MORE_RESULTS_EXISTS;
}
lex->set_trg_event_type_for_tables();
int error MY_ATTRIBUTE((unused));
if (unlikely(thd->security_context()->password_expired() &&
lex->sql_command != SQLCOM_SET_PASSWORD &&
lex->sql_command != SQLCOM_SET_OPTION &&
lex->sql_command != SQLCOM_ALTER_USER)) {
my_error(ER_MUST_CHANGE_PASSWORD, MYF(0));
error = 1;
} else {
resourcegroups::Resource_group *src_res_grp = nullptr;
resourcegroups::Resource_group *dest_res_grp = nullptr;
MDL_ticket *ticket = nullptr;
MDL_ticket *cur_ticket = nullptr;
auto mgr_ptr = resourcegroups::Resource_group_mgr::instance();
bool switched = mgr_ptr->switch_resource_group_if_needed(
thd, &src_res_grp, &dest_res_grp, &ticket, &cur_ticket);
error = mysql_execute_command(thd, true);
if (switched)
mgr_ptr->restore_original_resource_group(thd, src_res_grp,
dest_res_grp);
thd->resource_group_ctx()->m_switch_resource_group_str[0] = '\0';
if (ticket != nullptr)
mgr_ptr->release_shared_mdl_for_resource_group(thd, ticket);
if (cur_ticket != nullptr)
mgr_ptr->release_shared_mdl_for_resource_group(thd, cur_ticket);
}
}
}
} else {
/*
Log the failed raw query in the Performance Schema. This statement did not
parse, so there is no way to tell if it may contain a password of not.
The tradeoff is:
a) If we do log the query, a user typing by accident a broken query
containing a password will have the password exposed. This is very
unlikely, and this behavior can be documented. Remediation is to use
a new password when retyping the corrected query.
b) If we do not log the query, finding broken queries in the client
application will be much more difficult. This is much more likely.
Considering that broken queries can typically be generated by attempts at
SQL injection, finding the source of the SQL injection is critical, so the
design choice is to log the query text of broken queries (a).
*/
thd->set_query_for_display(thd->query().str, thd->query().length);
/* Instrument this broken statement as "statement/sql/error" */
thd->m_statement_psi = MYSQL_REFINE_STATEMENT(
thd->m_statement_psi, sql_statement_info[SQLCOM_END].m_key);
assert(thd->is_error());
DBUG_PRINT("info",
("Command aborted. Fatal_error: %d", thd->is_fatal_error()));
}
THD_STAGE_INFO(thd, stage_freeing_items);
sp_cache_enforce_limit(thd->sp_proc_cache, stored_program_cache_size);
sp_cache_enforce_limit(thd->sp_func_cache, stored_program_cache_size);
thd->lex->destroy();
thd->end_statement();
thd->cleanup_after_query();
assert(thd->change_list.is_empty());
DEBUG_SYNC(thd, "query_rewritten");
}
然后它又调用了一个巨长的命令处理函数：
int mysql_execute_command(THD *thd, bool first_level) {
int res = false;
LEX *const lex = thd->lex;
/* first Query_block (have special meaning for many of non-SELECTcommands) */
Query_block *const query_block = lex->query_block;
/* first table of first Query_block */
TABLE_LIST *const first_table = query_block->get_table_list();
/* list of all tables in query */
TABLE_LIST *all_tables;
// keep GTID violation state in order to roll it back on statement failure
bool gtid_consistency_violation_state = thd->has_gtid_consistency_violation;
assert(query_block->master_query_expression() == lex->unit);
DBUG_TRACE;
/* EXPLAIN OTHER isn't explainable command, but can have describe flag. */
assert(!lex->is_explain() || is_explainable_query(lex->sql_command) ||
lex->sql_command == SQLCOM_EXPLAIN_OTHER);
assert(!thd->m_transactional_ddl.inited() ||
thd->in_active_multi_stmt_transaction());
/*
If there is a CREATE TABLE...START TRANSACTION command which
is not yet committed or rollbacked, then we should allow only
BINLOG INSERT, COMMIT or ROLLBACK command.
TODO: Should we really check name of table when we cable BINLOG INSERT ?
*/
if (thd->m_transactional_ddl.inited() && lex->sql_command != SQLCOM_COMMIT &&
lex->sql_command != SQLCOM_ROLLBACK &&
lex->sql_command != SQLCOM_BINLOG_BASE64_EVENT) {
my_error(ER_STATEMENT_NOT_ALLOWED_AFTER_START_TRANSACTION, MYF(0));
binlog_gtid_end_transaction(thd);
return 1;
}
......
DBUG_EXECUTE_IF(
"force_rollback_in_slave_on_transactional_ddl_commit",
if (thd->m_transactional_ddl.inited() &&
thd->lex->sql_command == SQLCOM_COMMIT) {
lex->sql_command = SQLCOM_ROLLBACK;
});
/*
We do not flag "is DML" (TX_STMT_DML) here as replication expects us to
test for LOCK TABLE etc. first. To rephrase, we try not to set TX_STMT_DML
until we have the MDL, and LOCK TABLE could massively delay this.
*/
switch (lex->sql_command) {
case SQLCOM_PREPARE: {
mysql_sql_stmt_prepare(thd);
break;
}
case SQLCOM_EXECUTE: {
mysql_sql_stmt_execute(thd);
break;
}
case SQLCOM_DEALLOCATE_PREPARE: {
mysql_sql_stmt_close(thd);
break;
}
......
case SQLCOM_CHECKSUM: {
assert(first_table == all_tables && first_table != nullptr);
if (check_table_access(thd, SELECT_ACL, all_tables, false, UINT_MAX,
false))
goto error; /* purecov: inspected */
res = mysql_checksum_table(thd, first_table, &lex->check_opt);
break;
}
case SQLCOM_REPLACE:
case SQLCOM_INSERT:
case SQLCOM_REPLACE_SELECT:
case SQLCOM_INSERT_SELECT:
case SQLCOM_DELETE:
case SQLCOM_DELETE_MULTI:
case SQLCOM_UPDATE:
case SQLCOM_UPDATE_MULTI:
case SQLCOM_CREATE_TABLE:
case SQLCOM_CREATE_INDEX:
case SQLCOM_DROP_INDEX:
case SQLCOM_ASSIGN_TO_KEYCACHE:
case SQLCOM_PRELOAD_KEYS:
case SQLCOM_LOAD: {
assert(first_table == all_tables && first_table != nullptr);
assert(lex->m_sql_cmd != nullptr);
res = lex->m_sql_cmd->execute(thd);
break;
}
......
case SQLCOM_DROP_TRIGGER: {
/* Conditionally writes to binlog. */
assert(lex->m_sql_cmd != nullptr);
static_cast<Sql_cmd_ddl_trigger_common *>(lex->m_sql_cmd)
->set_table(all_tables);
res = lex->m_sql_cmd->execute(thd);
break;
}
case SQLCOM_BINLOG_BASE64_EVENT: {
mysql_client_binlog_statement(thd);
break;
}
case SQLCOM_ANALYZE:
......
return res || thd->is_error();
}
而在上面的代码中可以看到，常见的CRUD都调用了lex->m_sql_cmd->execute(thd);这个函数,这个函数是一个虚拟函数，可以由DDL,DML等类来操作，而这里明显是DML，所以找到相关的类：
struct LEX;
class Query_result;
class Sql_cmd_dml : public Sql_cmd {
public:
/// @return true if data change statement, false if not (SELECT statement)
virtual bool is_data_change_stmt() const { return true; }
/**
Command-specific resolving (doesn't include LEX::prepare())
@param thd Current THD.
@returns false on success, true on error
*/
bool prepare(THD *thd) override;
/**
Execute a DML statement.
@param thd thread handler
@returns false if success, true if error
@details
Processing a statement goes through 6 phases (parsing is already done)
- Prelocking
- Preparation
- Locking of tables
- Optimization
- Execution or explain
- Cleanup
If the statement is already prepared, this step is skipped.
The queries handled by this function are:
SELECT
INSERT ... SELECT
INSERT ... VALUES
REPLACE ... SELECT
REPLACE ... VALUES
UPDATE (single-table and multi-table)
DELETE (single-table and multi-table)
DO
@todo make this function also handle SET.
*/
bool execute(THD *thd) override;
bool is_dml() const override { return true; }
virtual bool may_use_cursor() const { return false; }
bool is_single_table_plan() const override { return false; }
/// @return the query result associated with a prepared query
Query_result *query_result() const;
/// Set query result object for this query statement
void set_query_result(Query_result *result);
/// Signal that root result object needs preparing in next execution
void set_lazy_result() { m_lazy_result = true; }
protected:
Sql_cmd_dml()
: Sql_cmd(),
lex(nullptr),
result(nullptr),
m_empty_query(false),
m_lazy_result(false) {}
/// @return true if query is guaranteed to return no data
/**
@todo Also check this for the following cases:
- Empty source for multi-table UPDATE and DELETE.
- Check empty query expression for INSERT
*/
bool is_empty_query() const {
assert(is_prepared());
return m_empty_query;
}
/// Set statement as returning no data
void set_empty_query() { m_empty_query = true; }
/**
Perform a precheck of table privileges for the specific operation.
@details
Check that user has some relevant privileges for all tables involved in
the statement, e.g. SELECT privileges for tables selected from, INSERT
privileges for tables inserted into, etc. This function will also populate
TABLE_LIST::grant with all privileges the user has for each table, which
is later used during checking of column privileges.
Note that at preparation time, views are not expanded yet. Privilege
checking is thus rudimentary and must be complemented with later calls to
Query_block::check_view_privileges().
The reason to call this function at such an early stage is to be able to
quickly reject statements for which the user obviously has insufficient
privileges.
This function is called before preparing the statement.
The function must also be complemented with proper privilege checks for all
involved columns (e.g. check_column_grant_*).
@see also the function comment of Query_block::prepare().
During execution of a prepared statement, call check_privileges() instead.
@param thd thread handler
@returns false if success, true if false
*/
virtual bool precheck(THD *thd) = 0;
/**
Check privileges on a prepared statement, called at start of execution
of the statement.
@details
Check that user has all relevant privileges to the statement,
ie. INSERT privilege for columns inserted into, UPDATE privilege
for columns that are updated, DELETE privilege for tables that are
deleted from, SELECT privilege for columns that are referenced, etc.
@param thd thread handler
@returns false if success, true if false
*/
virtual bool check_privileges(THD *thd) = 0;
/**
Read and check privileges for all tables in a DML statement.
@param thd thread handler
@returns false if success, true if false
*/
bool check_all_table_privileges(THD *thd);
/**
Perform the command-specific parts of DML command preparation,
to be called from prepare()
@param thd the current thread
@returns false if success, true if error
*/
virtual bool prepare_inner(THD *thd) = 0;
/**
The inner parts of query optimization and execution.
Single-table DML operations needs to reimplement this.
@param thd Thread handler
@returns false on success, true on error
*/
virtual bool execute_inner(THD *thd);
/**
Restore command properties before execution
- Bind metadata for tables and fields
- Restore clauses (e.g ORDER BY, GROUP BY) that were destroyed in
last optimization.
*/
virtual bool restore_cmd_properties(THD *thd);
/// Save command properties, such as prepared query details and table props
virtual bool save_cmd_properties(THD *thd);
/**
Helper function that checks if the command is eligible for secondary engine
and if that's true returns the name of that eligible secondary storage
engine.
@return nullptr if not eligible or the name of the engine otherwise
*/
const MYSQL_LEX_CSTRING *get_eligible_secondary_engine() const;
protected:
LEX *lex; ///< Pointer to LEX for this statement
Query_result *result; ///< Pointer to object for handling of the result
bool m_empty_query; ///< True if query will produce no rows
bool m_lazy_result; ///< True: prepare query result on next execution
};
bool Sql_cmd_dml::execute(THD *thd) {
DBUG_TRACE;
lex = thd->lex;
Query_expression *const unit = lex->unit;
bool statement_timer_armed = false;
bool error_handler_active = false;
Ignore_error_handler ignore_handler;
Strict_error_handler strict_handler;
// If statement is preparable, it must be prepared
assert(owner() == nullptr || is_prepared());
// If statement is regular, it must be unprepared
assert(!is_regular() || !is_prepared());
// If statement is part of SP, it can be both prepared and unprepared.
// If a timer is applicable to statement, then set it.
if (is_timer_applicable_to_statement(thd))
statement_timer_armed = set_statement_timer(thd);
if (is_data_change_stmt()) {
// Push ignore / strict error handler
if (lex->is_ignore()) {
thd->push_internal_handler(&ignore_handler);
error_handler_active = true;
/*
UPDATE IGNORE can be unsafe. We therefore use row based
logging if mixed or row based logging is available.
TODO: Check if the order of the output of the select statement is
deterministic. Waiting for BUG#42415
*/
if (lex->sql_command == SQLCOM_UPDATE)
lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_UPDATE_IGNORE);
} else if (thd->is_strict_mode()) {
thd->push_internal_handler(&strict_handler);
error_handler_active = true;
}
}
if (!is_prepared()) {
if (prepare(thd)) goto err;
} else {
/*
Prepared statement, open tables referenced in statement and check
privileges for it.
*/
cleanup(thd);
if (open_tables_for_query(thd, lex->query_tables, 0)) goto err;
#ifndef NDEBUG
if (sql_command_code() == SQLCOM_SELECT)
DEBUG_SYNC(thd, "after_table_open");
#endif
// Bind table and field information
if (restore_cmd_properties(thd)) return true;
if (check_privileges(thd)) goto err;
if (m_lazy_result) {
Prepared_stmt_arena_holder ps_arena_holder(thd);
if (result->prepare(thd, *unit->get_unit_column_types(), unit)) goto err;
m_lazy_result = false;
}
}
if (validate_use_secondary_engine(lex)) goto err;
lex->set_exec_started();
DBUG_EXECUTE_IF("use_attachable_trx",
thd->begin_attachable_ro_transaction(););
THD_STAGE_INFO(thd, stage_init);
thd->clear_current_query_costs();
// Replication may require extra check of data change statements
if (is_data_change_stmt() && run_before_dml_hook(thd)) goto err;
// Revertable changes are not supported during preparation
assert(thd->change_list.is_empty());
assert(!lex->is_query_tables_locked());
/*
Locking of tables is done after preparation but before optimization.
This allows to do better partition pruning and avoid locking unused
partitions. As a consequence, in such a case, prepare stage can rely only
on metadata about tables used and not data from them.
*/
if (!is_empty_query()) {
if (lock_tables(thd, lex->query_tables, lex->table_count, 0)) goto err;
}
// Perform statement-specific execution
//这里调用执行---fjf
if (execute_inner(thd)) goto err;
// Count the number of statements offloaded to a secondary storage engine.
if (using_secondary_storage_engine() && lex->unit->is_executed())
++thd->status_var.secondary_engine_execution_count;
assert(!thd->is_error());
// Pop ignore / strict error handler
if (error_handler_active) thd->pop_internal_handler();
THD_STAGE_INFO(thd, stage_end);
// Do partial cleanup (preserve plans for EXPLAIN).
lex->cleanup(thd, false);
lex->clear_values_map();
lex->set_secondary_engine_execution_context(nullptr);
// Perform statement-specific cleanup for Query_result
if (result != nullptr) result->cleanup(thd);
thd->save_current_query_costs();
thd->update_previous_found_rows();
DBUG_EXECUTE_IF("use_attachable_trx", thd->end_attachable_transaction(););
if (statement_timer_armed && thd->timer) reset_statement_timer(thd);
/*
This sync point is normally right before thd->query_plan is reset, so
EXPLAIN FOR CONNECTION can catch the plan. It is copied here as
after unprepare() EXPLAIN considers the query as "not ready".
@todo remove in WL#6570 when unprepare() is gone.
*/
DEBUG_SYNC(thd, "before_reset_query_plan");
return false;
err:
assert(thd->is_error() || thd->killed);
DBUG_PRINT("info", ("report_error: %d", thd->is_error()));
THD_STAGE_INFO(thd, stage_end);
lex->cleanup(thd, false);
lex->clear_values_map();
lex->set_secondary_engine_execution_context(nullptr);
// Abort and cleanup the result set (if it has been prepared).
if (result != nullptr) {
result->abort_result_set(thd);
result->cleanup(thd);
}
if (error_handler_active) thd->pop_internal_handler();
if (statement_timer_armed && thd->timer) reset_statement_timer(thd);
/*
There are situations where we want to know the cost of a query that
has failed during execution, e.g because of a timeout.
*/
thd->save_current_query_costs();
DBUG_EXECUTE_IF("use_attachable_trx", thd->end_attachable_transaction(););
return thd->is_error();
}
bool Sql_cmd_dml::execute_inner(THD *thd) {
Query_expression *unit = lex->unit;
if (unit->optimize(thd, /*materialize_destination=*/nullptr,
/*create_iterators=*/true))
return true;
// Calculate the current statement cost. It will be made available in
// the Last_query_cost status variable.
thd->m_current_query_cost = accumulate_statement_cost(lex);
// Perform secondary engine optimizations, if needed.
if (optimize_secondary_engine(thd)) return true;
// We know by now that execution will complete (successful or with error)
lex->set_exec_completed();
if (lex->is_explain()) {
if (explain_query(thd, thd, unit)) return true; /* purecov: inspected */
} else {
if (unit->execute(thd)) return true;
}
return false;
}
execute_inner这个函数又会调用两个处理函数一个返回一个执行：
bool explain_query(THD *explain_thd, const THD *query_thd,
Query_expression *unit) {
DBUG_TRACE;
const bool other = (explain_thd != query_thd);
LEX *lex = explain_thd->lex;
if (lex->explain_format->is_tree()) {
const bool secondary_engine =
explain_thd->lex->m_sql_cmd != nullptr &&
explain_thd->lex->m_sql_cmd->using_secondary_storage_engine();
if (lex->is_explain_analyze) {
if (secondary_engine) {
my_error(ER_NOT_SUPPORTED_YET, MYF(0),
"EXPLAIN ANALYZE with secondary engine");
return true;
}
if (unit->root_iterator() == nullptr) {
// TODO(sgunders): Remove when the iterator executor supports
// all queries.
my_error(ER_NOT_SUPPORTED_YET, MYF(0), "EXPLAIN ANALYZE on this query");
unit->set_executed();
return true;
}
// Run the query, but with the result suppressed.
Query_result_null null_result;
unit->set_query_result(&null_result);
explain_thd->running_explain_analyze = true;
unit->execute(explain_thd);
explain_thd->running_explain_analyze = false;
unit->set_executed();
if (query_thd->is_error()) return true;
}
if (secondary_engine)
push_warning(explain_thd, Sql_condition::SL_NOTE, ER_YES,
"Query is executed in secondary engine; the actual"
" query plan may diverge from the printed one");
return ExplainIterator(explain_thd, query_thd, unit);
}
if (query_thd->lex->using_hypergraph_optimizer) {
my_error(ER_HYPERGRAPH_NOT_SUPPORTED_YET, MYF(0),
"EXPLAIN with non-tree formats");
return true;
}
Query_result *explain_result = nullptr;
if (!other)
explain_result = unit->query_result()
? unit->query_result()
: unit->first_query_block()->query_result();
Query_result_explain explain_wrapper(unit, explain_result);
if (other) {
if (!((explain_result = new (explain_thd->mem_root) Query_result_send())))
return true; /* purecov: inspected */
mem_root_deque<Item *> dummy(explain_thd->mem_root);
if (explain_result->prepare(explain_thd, dummy, explain_thd->lex->unit))
return true; /* purecov: inspected */
} else {
assert(unit->is_optimized());
if (explain_result->need_explain_interceptor())
explain_result = &explain_wrapper;
}
explain_thd->lex->explain_format->send_headers(explain_result);
// Reset OFFSET/LIMIT for EXPLAIN output
explain_thd->lex->unit->offset_limit_cnt = 0;
explain_thd->lex->unit->select_limit_cnt = 0;
const bool res = mysql_explain_query_expression(explain_thd, query_thd, unit);
/*
1) The code which prints the extended description is not robust
against malformed queries, so skip it if we have an error.
2) The code also isn't thread-safe, skip if explaining other thread
(see Explain::can_print_clauses())
3) Only certain statements can be explained.
*/
if (!res && // (1)
!other && // (2)
(query_thd->query_plan.get_command() == SQLCOM_SELECT ||
query_thd->query_plan.get_command() == SQLCOM_INSERT_SELECT ||
query_thd->query_plan.get_command() == SQLCOM_REPLACE_SELECT ||
query_thd->query_plan.get_command() == SQLCOM_DELETE ||
query_thd->query_plan.get_command() == SQLCOM_DELETE_MULTI ||
query_thd->query_plan.get_command() == SQLCOM_UPDATE ||
query_thd->query_plan.get_command() == SQLCOM_UPDATE_MULTI)) // (3)
{
StringBuffer<1024> str;
/*
The warnings system requires input in utf8, see mysqld_show_warnings().
*/
enum_query_type eqt =
enum_query_type(QT_TO_SYSTEM_CHARSET | QT_SHOW_SELECT_NUMBER);
/**
For DML statements use QT_NO_DATA_EXPANSION to avoid over-simplification.
*/
if (query_thd->query_plan.get_command() != SQLCOM_SELECT)
eqt = enum_query_type(eqt | QT_NO_DATA_EXPANSION);
unit->print(explain_thd, &str, eqt);
str.append('\0');
push_warning(explain_thd, Sql_condition::SL_NOTE, ER_YES, str.ptr());
}
if (res)
explain_result->abort_result_set(explain_thd);
else
explain_result->send_eof(explain_thd);
if (other) destroy(explain_result);
return res;
}
bool Query_expression::execute(THD *thd) {
DBUG_TRACE;
assert(is_optimized());
if (is_executed() && !uncacheable) return false;
assert(!unfinished_materialization());
/*
Even if we return "true" the statement might continue
(e.g. ER_SUBQUERY_1_ROW in stmt with IGNORE), so we want to restore
current_query_block():
*/
Change_current_query_block save_query_block(thd);
return ExecuteIteratorQuery(thd);
}
bool Query_expression::ExecuteIteratorQuery(THD *thd) {
THD_STAGE_INFO(thd, stage_executing);
DEBUG_SYNC(thd, "before_join_exec");
Opt_trace_context *const trace = &thd->opt_trace;
Opt_trace_object trace_wrapper(trace);
Opt_trace_object trace_exec(trace, "join_execution");
if (is_simple()) {
trace_exec.add_select_number(first_query_block()->select_number);
}
Opt_trace_array trace_steps(trace, "steps");
if (ClearForExecution(thd)) {
return true;
}
mem_root_deque<Item *> *fields = get_field_list();
Query_result *query_result = this->query_result();
assert(query_result != nullptr);
if (query_result->start_execution(thd)) return true;
if (query_result->send_result_set_metadata(
thd, *fields, Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) {
return true;
}
set_executed();
// Hand over the query to the secondary engine if needed.
if (first_query_block()->join->override_executor_func != nullptr) {
thd->current_found_rows = 0;
for (Query_block *select = first_query_block(); select != nullptr;
select = select->next_query_block()) {
if (select->join->override_executor_func(select->join, query_result)) {
return true;
}
thd->current_found_rows += select->join->send_records;
}
const bool calc_found_rows =
(first_query_block()->active_options() & OPTION_FOUND_ROWS);
if (!calc_found_rows) {
// This is for backwards compatibility reasons only;
// we have documented that without SQL_CALC_FOUND_ROWS,
// we return the actual number of rows returned.
thd->current_found_rows =
std::min(thd->current_found_rows, select_limit_cnt);
}
return query_result->send_eof(thd);
}
if (item) {
item->reset_value_registration();
if (item->assigned()) {
item->assigned(false); // Prepare for re-execution of this unit
item->reset();
}
}
// We need to accumulate in the first join's send_records as long as
// we support SQL_CALC_FOUND_ROWS, since LimitOffsetIterator will use it
// for reporting rows skipped by OFFSET or LIMIT. When we get rid of
// SQL_CALC_FOUND_ROWS, we can use a local variable here instead.
ha_rows *send_records_ptr;
if (fake_query_block != nullptr) {
// UNION with LIMIT: found_rows() applies to the outermost block.
// LimitOffsetIterator will write skipped OFFSET rows into the
// fake_query_block's send_records, so use that.
send_records_ptr = &fake_query_block->join->send_records;
} else if (is_simple()) {
// Not an UNION: found_rows() applies to the join.
// LimitOffsetIterator will write skipped OFFSET rows into the JOIN's
// send_records, so use that.
send_records_ptr = &first_query_block()->join->send_records;
} else {
// UNION, but without a fake_query_block (may or may not have a
// LIMIT): found_rows() applies to the outermost block. See
// Query_expression::send_records for more information.
send_records_ptr = &send_records;
}
*send_records_ptr = 0;
thd->get_stmt_da()->reset_current_row_for_condition();
{
auto join_cleanup = create_scope_guard([this, thd] {
for (Query_block *sl = first_query_block(); sl;
sl = sl->next_query_block()) {
JOIN *join = sl->join;
join->join_free();
thd->inc_examined_row_count(join->examined_rows);
}
if (fake_query_block != nullptr) {
thd->inc_examined_row_count(fake_query_block->join->examined_rows);
}
});
if (m_root_iterator->Init()) {
return true;
}
PFSBatchMode pfs_batch_mode(m_root_iterator.get());
for (;;) {
int error = m_root_iterator->Read();
DBUG_EXECUTE_IF("bug13822652_1", thd->killed = THD::KILL_QUERY;);
if (error > 0 || thd->is_error()) // Fatal error
return true;
else if (error < 0)
break;
else if (thd->killed) // Aborted by user
{
thd->send_kill_message();
return true;
}
++*send_records_ptr;
if (query_result->send_data(thd, *fields)) {
return true;
}
thd->get_stmt_da()->inc_current_row_for_condition();
}
// NOTE: join_cleanup must be done before we send EOF, so that we get the
// row counts right.
}
thd->current_found_rows = *send_records_ptr;
return query_result->send_eof(thd);
}
当然，还是创建等几个类，都有类似的继承，它们都继承了Sql_cmd这个类：
class Sql_cmd {
private:
Sql_cmd(const Sql_cmd &); // No copy constructor wanted
void operator=(Sql_cmd &); // No assignment operator wanted
public:
/**
@brief Return the command code for this statement
*/
virtual enum_sql_command sql_command_code() const = 0;
/**
@return true if object represents a preparable statement, ie. a query
that is prepared with a PREPARE statement and executed with an EXECUTE
statement. False is returned for regular statements (non-preparable
statements) that are executed directly. Also false if statement is part
of a stored procedure.
*/
bool needs_explicit_preparation() const {
return m_owner != nullptr && !m_part_of_sp;
}
/**
@return true if statement is regular, ie not prepared statement and not
part of stored procedure.
*/
bool is_regular() const { return m_owner == nullptr && !m_part_of_sp; }
/// @return true if this statement is prepared
bool is_prepared() const { return m_prepared; }
/**
Prepare this SQL statement.
param thd the current thread
@returns false if success, true if error
*/
virtual bool prepare(THD *) {
// Default behavior for a statement is to have no preparation code.
/* purecov: begin inspected */
assert(!is_prepared());
set_prepared();
return false;
/* purecov: end */
}
/**
Execute this SQL statement.
@param thd the current thread.
@returns false if success, true if error
*/
virtual bool execute(THD *thd) = 0;
/**
Command-specific reinitialization before execution of prepared statement
param thd Current THD.
*/
virtual void cleanup(THD *) { m_secondary_engine = nullptr; }
/// Set the owning prepared statement
void set_owner(Prepared_statement *stmt) {
assert(!m_part_of_sp);
m_owner = stmt;
}
/// Get the owning prepared statement
Prepared_statement *owner() const { return m_owner; }
/**
Mark statement as part of procedure. Such statements can be executed
multiple times, the first execute() call will also prepare it.
*/
void set_as_part_of_sp() {
assert(!m_part_of_sp && m_owner == nullptr);
m_part_of_sp = true;
}
/// @returns true if statement is part of a stored procedure
bool is_part_of_sp() const { return m_part_of_sp; }
/// @return true if SQL command is a DML statement
virtual bool is_dml() const { return false; }
/// @return true if implemented as single table plan, DML statement only
virtual bool is_single_table_plan() const {
/* purecov: begin inspected */
assert(is_dml());
return false;
/* purecov: end */
}
virtual bool accept(THD *, Select_lex_visitor *) { return false; }
/**
Is this statement of a type and on a form that makes it eligible
for execution in a secondary storage engine?
@return the name of the secondary storage engine, or nullptr if
the statement is not eligible for execution in a secondary storage
engine
*/
virtual const MYSQL_LEX_CSTRING *eligible_secondary_storage_engine() const {
return nullptr;
}
/**
Disable use of secondary storage engines in this statement. After
a call to this function, the statement will not try to use a
secondary storage engine until it is reprepared.
*/
void disable_secondary_storage_engine() {
assert(m_secondary_engine == nullptr);
m_secondary_engine_enabled = false;
}
/**
Has use of secondary storage engines been disabled for this statement?
*/
bool secondary_storage_engine_disabled() const {
return !m_secondary_engine_enabled;
}
/**
Mark the current statement as using a secondary storage engine.
This function must be called before the statement starts opening
tables in a secondary engine.
*/
void use_secondary_storage_engine(const handlerton *hton) {
assert(m_secondary_engine_enabled);
m_secondary_engine = hton;
}
/**
Is this statement using a secondary storage engine?
@note that this is reliable during optimization and afterwards; during
preparation, if this is an explicit preparation (SQL PREPARE, C API
PREPARE, and automatic repreparation), it may be false as RAPID tables have
not yet been opened. Therefore, during preparation, it is safer to test
THD::secondary_engine_optimization().
*/
bool using_secondary_storage_engine() const {
return m_secondary_engine != nullptr;
}
/**
Get the handlerton of the secondary engine that is used for
executing this statement, or nullptr if a secondary engine is not
used.
*/
const handlerton *secondary_engine() const { return m_secondary_engine; }
void set_optional_transform_prepared(bool value) {
m_prepared_with_optional_transform = value;
}
bool is_optional_transform_prepared() {
return m_prepared_with_optional_transform;
}
protected:
Sql_cmd() : m_owner(nullptr), m_part_of_sp(false), m_prepared(false) {}
virtual ~Sql_cmd() {
/*
Sql_cmd objects are allocated in thd->mem_root.
In MySQL, the C++ destructor is never called, the underlying MEM_ROOT is
simply destroyed instead.
Do not rely on the destructor for any cleanup.
*/
assert(false);
}
/// Set this statement as prepared
void set_prepared() { m_prepared = true; }
private:
Prepared_statement *m_owner; /// Owning prepared statement, NULL if non-prep.
bool m_part_of_sp; /// True when statement is part of stored proc.
bool m_prepared; /// True when statement has been prepared
/**
Tells if a secondary storage engine can be used for this
statement. If it is false, use of a secondary storage engine will
not be considered for executing this statement.
*/
bool m_secondary_engine_enabled{true};
/**
Keeps track of whether the statement was prepared optional
transformation.
*/
bool m_prepared_with_optional_transform{false};
/**
The secondary storage engine to use for execution of this
statement, if any, or nullptr if the primary engine is used.
This property is reset at the start of each execution.
*/
const handlerton *m_secondary_engine{nullptr};
};
在上面看到了LEX的解析和）Parse的分析执行，这样，一条相对完整的流程就出现了。具体的查询操作类和函数都在sql目前下的sql_select.cc,select_insert.cc等中。从头尾两头逼近，就可以迅速找到目标。
四、总结
端午节假日，努力吧！不负年华不负卿！
832
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
