sql_parse.cc

/* Copyright (c) 1999, 2025, Oracle and/or its affiliates.

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License, version 2.0,
 as published by the Free Software Foundation.

 This program is designed to work with certain software (including
 but not limited to OpenSSL) that is licensed under separate terms,
 as designated in a particular file or component or in included license
 documentation. The authors of MySQL hereby grant you an additional
 permission to link the program and your derivative works with the
 separately licensed software that they have either included with
 the program or referenced in the documentation.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU General Public License, version 2.0, for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */

#include"sql/sql_parse.h"

#include<algorithm>
#include<atomic>
#include<climits>
#include<cstdint>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<functional>
#include<iterator>
#include<memory>
#include<optional>
#include<string>
#include<utility>
#include<vector>

#include"my_config.h"
#ifdef HAVE_LSAN_DO_RECOVERABLE_LEAK_CHECK
#include<sanitizer/lsan_interface.h>
#endif

#include"dur_prop.h"
#include"field_types.h"// enum_field_types
#include"m_ctype.h"
#include"m_string.h"
#include"mem_root_deque.h"
#include"mutex_lock.h"// MUTEX_LOCK
#include"my_alloc.h"
#include"my_compiler.h"
#include"my_dbug.h"
#include"my_hostname.h"
#include"my_inttypes.h"// TODO: replace with cstdint
#include"my_io.h"
#include"my_loglevel.h"
#include"my_macros.h"
#include"my_psi_config.h"
#include"my_sys.h"
#include"my_table_map.h"
#include"my_thread_local.h"
#include"my_time.h"
#include"mysql/com_data.h"
#include"mysql/components/services/bits/plugin_audit_connection_types.h"// MYSQL_AUDIT_CONNECTION_CHANGE_USER
#include"mysql/components/services/bits/psi_statement_bits.h"// PSI_statement_info
#include"mysql/components/services/log_builtins.h"// LogErr
#include"mysql/plugin_audit.h"
#include"mysql/psi/mysql_mutex.h"
#include"mysql/psi/mysql_rwlock.h"
#include"mysql/psi/mysql_statement.h"
#include"mysql/service_mysql_alloc.h"
#include"mysql/udf_registration_types.h"
#include"mysql_version.h"
#include"mysqld_error.h"
#include"mysys_err.h"// EE_CAPACITY_EXCEEDED
#include"pfs_thread_provider.h"
#include"prealloced_array.h"
#include"scope_guard.h"
#include"sql/auth/auth_acls.h"
#include"sql/auth/sql_security_ctx.h"
#include"sql/binlog.h"// purge_source_logs
#include"sql/clone_handler.h"
#include"sql/comp_creator.h"
#include"sql/create_field.h"
#include"sql/current_thd.h"
#include"sql/dd/cache/dictionary_client.h"// dd::cache::Dictionary_client::Auto_releaser
#include"sql/dd/dd.h"// dd::get_dictionary
#include"sql/dd/dd_schema.h"// Schema_MDL_locker
#include"sql/dd/dictionary.h"// dd::Dictionary::is_system_view_name
#include"sql/dd/info_schema/table_stats.h"
#include"sql/dd/types/column.h"
#include"sql/debug_sync.h"// DEBUG_SYNC
#include"sql/derror.h"// ER_THD
#include"sql/discrete_interval.h"
#include"sql/error_handler.h"// Strict_error_handler
#include"sql/events.h"// Events
#include"sql/field.h"
#include"sql/gis/srid.h"
#include"sql/item.h"
#include"sql/item_cmpfunc.h"
#include"sql/item_func.h"
#include"sql/item_subselect.h"
#include"sql/item_timefunc.h"// Item_func_unix_timestamp
#include"sql/key_spec.h"// Key_spec
#include"sql/locked_tables_list.h"
#include"sql/log.h"// query_logger
#include"sql/log_event.h"// slave_execute_deferred_events
#include"sql/mdl.h"
#include"sql/mem_root_array.h"
#include"sql/mysqld.h"// stage_execution_of_init_command
#include"sql/mysqld_thd_manager.h"// Find_thd_with_id
#include"sql/nested_join.h"
#include"sql/opt_hints.h"
#include"sql/opt_trace.h"// Opt_trace_start
#include"sql/parse_location.h"
#include"sql/parse_tree_node_base.h"
#include"sql/parse_tree_nodes.h"
#include"sql/parser_yystype.h"
#include"sql/persisted_variable.h"
#include"sql/protocol.h"
#include"sql/protocol_classic.h"
#include"sql/psi_memory_key.h"
#include"sql/query_options.h"
#include"sql/query_result.h"
#include"sql/resourcegroups/resource_group_basic_types.h"
#include"sql/resourcegroups/resource_group_mgr.h"// Resource_group_mgr::instance
#include"sql/rpl_context.h"
#include"sql/rpl_filter.h"// rpl_filter
#include"sql/rpl_group_replication.h"// group_replication_start
#include"sql/rpl_gtid.h"
#include"sql/rpl_handler.h"// launch_hook_trans_begin
#include"sql/rpl_replica.h"// change_master_cmd
#include"sql/rpl_source.h"// register_slave
#include"sql/rpl_utility.h"
#include"sql/session_tracker.h"
#include"sql/set_var.h"
#include"sql/sp.h"// sp_create_routine
#include"sql/sp_cache.h"// sp_cache_enforce_limit
#include"sql/sp_head.h"// sp_head
#include"sql/sql_admin.h"
#include"sql/sql_alter.h"
#include"sql/sql_audit.h"// MYSQL_AUDIT_NOTIFY_CONNECTION_CHANGE_USER
#include"sql/sql_base.h"// find_temporary_table
#include"sql/sql_binlog.h"// mysql_client_binlog_statement
#include"sql/sql_check_constraint.h"
#include"sql/sql_class.h"
#include"sql/sql_cmd.h"
#include"sql/sql_connect.h"// decrease_user_connections
#include"sql/sql_const.h"
#include"sql/sql_db.h"// mysql_change_db
#include"sql/sql_digest.h"
#include"sql/sql_digest_stream.h"
#include"sql/sql_error.h"
#include"sql/sql_handler.h"// mysql_ha_rm_tables
#include"sql/sql_help.h"// mysqld_help
#include"sql/sql_lex.h"
#include"sql/sql_list.h"
#include"sql/sql_prepare.h"// mysql_stmt_execute
#include"sql/sql_profile.h"
#include"sql/sql_query_rewrite.h"// invoke_pre_parse_rewrite_plugins
#include"sql/sql_reload.h"// handle_reload_request
#include"sql/sql_rename.h"// mysql_rename_tables
#include"sql/sql_rewrite.h"// mysql_rewrite_query
#include"sql/sql_show.h"// find_schema_table
#include"sql/sql_table.h"// mysql_create_table
#include"sql/sql_trigger.h"// add_table_for_trigger
#include"sql/sql_udf.h"
#include"sql/sql_view.h"// mysql_create_view
#include"sql/strfunc.h"
#include"sql/system_variables.h"// System_status_var
#include"sql/table.h"
#include"sql/table_cache.h"// table_cache_manager
#include"sql/thd_raii.h"
#include"sql/transaction.h"// trans_rollback_implicit
#include"sql/transaction_info.h"
#include"sql_string.h"
#include"template_utils.h"
#include"thr_lock.h"
#include"violite.h"

#ifdef WITH_LOCK_ORDER
#include"sql/debug_lock_order.h"
#endif/* WITH_LOCK_ORDER */

namespaceresourcegroups {
classResource_group;
} // namespace resourcegroups
structmysql_rwlock_t;

namespacedd {
classSchema;
} // namespace dd

namespacedd {
classAbstract_table;
} // namespace dd

using std::max;

/**
 @defgroup Runtime_Environment Runtime Environment
 @{
*/

/* Used in error handling only */
#defineSP_COM_STRING(LP) \
 ((LP)->sql_command == SQLCOM_CREATE_SPFUNCTION || \
 (LP)->sql_command == SQLCOM_ALTER_FUNCTION || \
 (LP)->sql_command == SQLCOM_SHOW_CREATE_FUNC || \
 (LP)->sql_command == SQLCOM_DROP_FUNCTION \
 ? "FUNCTION" \
 : "PROCEDURE")

staticvoidsql_kill(THD *thd, my_thread_id id, bool only_kill_query);

const std::string Command_names::m_names[] = {
"Sleep",
"Quit",
"Init DB",
"Query",
"Field List",
"Create DB",
"Drop DB",
"Refresh",
"Shutdown",
"Statistics",
"Processlist",
"Connect",
"Kill",
"Debug",
"Ping",
"Time",
"Delayed insert",
"Change user",
"Binlog Dump",
"Table Dump",
"Connect Out",
"Register Replica",
"Prepare",
"Execute",
"Long Data",
"Close stmt",
"Reset stmt",
"Set option",
"Fetch",
"Daemon",
"Binlog Dump GTID",
"Reset Connection",
"clone",
"Group Replication Data Stream subscription",
"Error"// Last command number
};

const std::string &Command_names::translate(const System_variables &sysvars) {
 terminology_use_previous::enum_compatibility_version version =
static_cast<terminology_use_previous::enum_compatibility_version>(
 sysvars.terminology_use_previous);
if (version != terminology_use_previous::NONE && version <= m_replace_version)
return m_replace_str;
return m_names[m_replace_com];
}

const std::string &Command_names::str_session(enum_server_command cmd) {
assert(current_thd);
if (cmd != m_replace_com || current_thd == nullptr) return m_names[cmd];
returntranslate(current_thd->variables);
}

const std::string &Command_names::str_global(enum_server_command cmd) {
if (cmd != m_replace_com) return m_names[cmd];
returntranslate(global_system_variables);
}

const std::string Command_names::m_replace_str{"Register Slave"};

boolcommand_satisfy_acl_cache_requirement(unsigned command) {
return !((sql_command_flags[command] & CF_REQUIRE_ACL_CACHE) > 0 &&
skip_grant_tables());
}

/**
 Returns true if all tables should be ignored.
*/
boolall_tables_not_ok(THD *thd, Table_ref *tables) {
 Rpl_filter *rpl_filter = thd->rli_slave->rpl_filter;

return rpl_filter->is_on() && tables && !thd->sp_runtime_ctx &&
 !rpl_filter->tables_ok(thd->db().str, tables);
}

boolis_normal_transaction_boundary_stmt(enum_sql_command sql_cmd) {
switch (sql_cmd) {
case SQLCOM_BEGIN:
case SQLCOM_COMMIT:
case SQLCOM_SAVEPOINT:
case SQLCOM_ROLLBACK:
case SQLCOM_ROLLBACK_TO_SAVEPOINT:
returntrue;
default:
returnfalse;
 }

returnfalse;
}

boolis_xa_transaction_boundary_stmt(enum_sql_command sql_cmd) {
switch (sql_cmd) {
case SQLCOM_XA_START:
case SQLCOM_XA_END:
case SQLCOM_XA_COMMIT:
case SQLCOM_XA_ROLLBACK:
returntrue;
default:
returnfalse;
 }

returnfalse;
}

/**
 Checks whether the event for the given database, db, should
 be ignored or not. This is done by checking whether there are
 active rules in ignore_db or in do_db containers. If there
 are, then check if there is a match, if not then check the
 wild_do rules.

 NOTE: This means that when using this function replicate-do-db
 and replicate-ignore-db take precedence over wild do
 rules.

 @param thd Thread handle.
 @param db Database name used while evaluating the filtering
 rules.
 @param sql_cmd Represents the current query that needs to be
 verified against the database filter rules.
 @return true Query should not be filtered out from the execution.
 false Query should be filtered out from the execution.

*/
inlineboolcheck_database_filters(THD *thd, constchar *db,
 enum_sql_command sql_cmd) {
 DBUG_TRACE;
assert(thd->slave_thread);
if (!db || is_normal_transaction_boundary_stmt(sql_cmd) ||
is_xa_transaction_boundary_stmt(sql_cmd))
returntrue;

 Rpl_filter *rpl_filter = thd->rli_slave->rpl_filter;
auto db_ok{rpl_filter->db_ok(db)};
/*
 No filters exist in ignore/do_db ? Then, just check
 wild_do_table filtering for 'DATABASE' related
 statements (CREATE/DROP/ATLER DATABASE)
*/
if (db_ok && (rpl_filter->get_do_db()->is_empty() &&
 rpl_filter->get_ignore_db()->is_empty())) {
switch (sql_cmd) {
case SQLCOM_CREATE_DB:
case SQLCOM_ALTER_DB:
case SQLCOM_DROP_DB:
 db_ok = rpl_filter->db_ok_with_wild_table(db);
default:
break;
 }
 }
return db_ok;
}

boolsome_non_temp_table_to_be_updated(THD *thd, Table_ref *tables) {
for (Table_ref *table = tables; table; table = table->next_global) {
assert(table->db && table->table_name);
/*
 Update on performance_schema and temp tables are allowed
 in readonly mode.
*/
if (table->updating && !find_temporary_table(thd, table) &&
 !is_perfschema_db(table->db, table->db_length))
returntrue;
 }
returnfalse;
}

/**
 Returns whether the command in thd->lex->sql_command should cause an
 implicit commit. An active transaction should be implicitly committed if the
 statement requires so.

 @param thd Thread handle.
 @param mask Bitmask used for the SQL command match.

 @retval true This statement shall cause an implicit commit.
 @retval false This statement shall not cause an implicit commit.
*/
boolstmt_causes_implicit_commit(const THD *thd, uint mask) {
 DBUG_TRACE;
const LEX *lex = thd->lex;

if ((sql_command_flags[lex->sql_command] & mask) == 0 ||
 thd->is_plugin_fake_ddl())
returnfalse;

switch (lex->sql_command) {
case SQLCOM_DROP_TABLE:
return !lex->drop_temporary;
case SQLCOM_ALTER_TABLE:
case SQLCOM_CREATE_TABLE:
/* If CREATE TABLE of non-temporary table or without
 START TRANSACTION, do implicit commit */
return (lex->create_info->options & HA_LEX_CREATE_TMP_TABLE ||
 lex->create_info->m_transactional_ddl) == 0;
case SQLCOM_SET_OPTION:
/* Implicitly commit a transaction started by a SET statement */
return lex->autocommit;
case SQLCOM_RESET:
return lex->option_type != OPT_PERSIST;
case SQLCOM_STOP_GROUP_REPLICATION:
return lex->was_replication_command_executed();
default:
returntrue;
 }
}

/**
 @brief Iterates over all post replication filter actions registered and
 executes them.

 All actions registered will be executed at most once. They are executed in
 the order that they were registered. Shall there be an error while iterating
 through the list of actions and executing them, then the process stops and an
 error is returned immediately. This means that in that case, some actions may
 have executed successfully and some not. In other words, this procedure is
 not atomic.

 This function will consume all actions from the list if there is no error.
 This means that actions run only once per statement. Should there be any
 sub-statements then actions only run on the top level statement execution.

 @param thd The thread context.
 @return true If there was an error while executing the registered actions.
 @return false If all actions executed successfully.
*/
staticboolrun_post_replication_filters_actions(THD *thd) {
 DBUG_TRACE;
auto &actions{thd->rpl_thd_ctx.post_filters_actions()};
for (auto &action : actions) {
if (action()) returntrue;
 }
 actions.clear();
returnfalse;
}

/**
 @brief This function determines if the current statement parsed violates the
 require_row_format check.

 Given a parsed context within the THD object, this function will infer
 whether the require row format check is violated or not. If it is, this
 function returns true, false otherwise. Note that this function can be called
 from both, normal sessions and replication applier, execution paths.

 @param thd The session context holding the parsed statement.
 @return true if there was a require row format validation failure.
 @return false if the check was successful, meaning no require row format
 validation failure.
*/
staticboolcheck_and_report_require_row_format_violation(THD *thd) {
 DBUG_TRACE;
assert(thd != nullptr);
auto perform_check{thd->slave_thread
 ? thd->rli_slave->is_row_format_required()
 : thd->variables.require_row_format};
if (!perform_check) returnfalse;

if (is_require_row_format_violation(thd)) {
if (thd->slave_thread) thd->is_slave_error = true;
my_error(ER_CLIENT_QUERY_FAILURE_INVALID_NON_ROW_FORMAT, MYF(0));
returntrue;
 }
returnfalse;
}

/**
 Mark all commands that somehow changes a table.

 This is used to check number of updates / hour.

 sql_command is actually set to SQLCOM_END sometimes
 so we need the +1 to include it in the array.

 See COMMAND_FLAG_xxx for different type of commands
 2 - query that returns meaningful ROW_COUNT() -
 a number of modified rows
*/

uint sql_command_flags[SQLCOM_END + 1];
uint server_command_flags[COM_END + 1];

voidinit_sql_command_flags() {
/* Initialize the server command flags array. */
memset(server_command_flags, 0, sizeof(server_command_flags));

 server_command_flags[COM_SLEEP] = CF_ALLOW_PROTOCOL_PLUGIN;
 server_command_flags[COM_INIT_DB] = CF_ALLOW_PROTOCOL_PLUGIN;
 server_command_flags[COM_QUERY] = CF_ALLOW_PROTOCOL_PLUGIN;
 server_command_flags[COM_FIELD_LIST] = CF_ALLOW_PROTOCOL_PLUGIN;
 server_command_flags[COM_REFRESH] = CF_ALLOW_PROTOCOL_PLUGIN;
 server_command_flags[COM_STATISTICS] = CF_SKIP_QUESTIONS;
 server_command_flags[COM_PROCESS_KILL] = CF_ALLOW_PROTOCOL_PLUGIN;
 server_command_flags[COM_PING] = CF_SKIP_QUESTIONS;
 server_command_flags[COM_STMT_PREPARE] =
 CF_SKIP_QUESTIONS | CF_ALLOW_PROTOCOL_PLUGIN;
 server_command_flags[COM_STMT_EXECUTE] = CF_ALLOW_PROTOCOL_PLUGIN;
 server_command_flags[COM_STMT_SEND_LONG_DATA] = CF_ALLOW_PROTOCOL_PLUGIN;
 server_command_flags[COM_STMT_CLOSE] =
 CF_SKIP_QUESTIONS | CF_ALLOW_PROTOCOL_PLUGIN;
 server_command_flags[COM_STMT_RESET] =
 CF_SKIP_QUESTIONS | CF_ALLOW_PROTOCOL_PLUGIN;
 server_command_flags[COM_STMT_FETCH] = CF_ALLOW_PROTOCOL_PLUGIN;
 server_command_flags[COM_RESET_CONNECTION] = CF_ALLOW_PROTOCOL_PLUGIN;
 server_command_flags[COM_END] = CF_ALLOW_PROTOCOL_PLUGIN;

/* Initialize the sql command flags array. */
memset(sql_command_flags, 0, sizeof(sql_command_flags));

/*
 In general, DDL statements do not generate row events and do not go
 through a cache before being written to the binary log. However, the
 CREATE TABLE...SELECT is an exception because it may generate row
 events. For that reason, the SQLCOM_CREATE_TABLE which represents
 a CREATE TABLE, including the CREATE TABLE...SELECT, has the
 CF_CAN_GENERATE_ROW_EVENTS flag. The distinction between a regular
 CREATE TABLE and the CREATE TABLE...SELECT is made in other parts of
 the code, in particular in the Query_log_event's constructor.
*/
 sql_command_flags[SQLCOM_CREATE_TABLE] =
 CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | CF_AUTO_COMMIT_TRANS |
 CF_CAN_GENERATE_ROW_EVENTS;
 sql_command_flags[SQLCOM_CREATE_INDEX] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_ALTER_TABLE] =
 CF_CHANGES_DATA | CF_WRITE_LOGS_COMMAND | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_TRUNCATE] =
 CF_CHANGES_DATA | CF_WRITE_LOGS_COMMAND | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_DROP_TABLE] = CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_LOAD] =
 CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | CF_CAN_GENERATE_ROW_EVENTS;
 sql_command_flags[SQLCOM_CREATE_DB] = CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_DROP_DB] = CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_ALTER_DB] = CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_RENAME_TABLE] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_DROP_INDEX] = CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_CREATE_VIEW] =
 CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_DROP_VIEW] = CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_CREATE_TRIGGER] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_DROP_TRIGGER] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_CREATE_EVENT] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_ALTER_EVENT] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_DROP_EVENT] = CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_IMPORT] = CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;

 sql_command_flags[SQLCOM_UPDATE] = CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE |
 CF_CAN_GENERATE_ROW_EVENTS |
 CF_OPTIMIZER_TRACE | CF_CAN_BE_EXPLAINED;
 sql_command_flags[SQLCOM_UPDATE_MULTI] =
 CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | CF_CAN_GENERATE_ROW_EVENTS |
 CF_OPTIMIZER_TRACE | CF_CAN_BE_EXPLAINED;
// This is INSERT VALUES(...), can be VALUES(stored_func()) so we trace it
 sql_command_flags[SQLCOM_INSERT] = CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE |
 CF_CAN_GENERATE_ROW_EVENTS |
 CF_OPTIMIZER_TRACE | CF_CAN_BE_EXPLAINED;
 sql_command_flags[SQLCOM_INSERT_SELECT] =
 CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | CF_CAN_GENERATE_ROW_EVENTS |
 CF_OPTIMIZER_TRACE | CF_CAN_BE_EXPLAINED;
 sql_command_flags[SQLCOM_DELETE] = CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE |
 CF_CAN_GENERATE_ROW_EVENTS |
 CF_OPTIMIZER_TRACE | CF_CAN_BE_EXPLAINED;
 sql_command_flags[SQLCOM_DELETE_MULTI] =
 CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | CF_CAN_GENERATE_ROW_EVENTS |
 CF_OPTIMIZER_TRACE | CF_CAN_BE_EXPLAINED;
 sql_command_flags[SQLCOM_REPLACE] = CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE |
 CF_CAN_GENERATE_ROW_EVENTS |
 CF_OPTIMIZER_TRACE | CF_CAN_BE_EXPLAINED;
 sql_command_flags[SQLCOM_REPLACE_SELECT] =
 CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | CF_CAN_GENERATE_ROW_EVENTS |
 CF_OPTIMIZER_TRACE | CF_CAN_BE_EXPLAINED;
 sql_command_flags[SQLCOM_SELECT] =
 CF_REEXECUTION_FRAGILE | CF_CAN_GENERATE_ROW_EVENTS | CF_OPTIMIZER_TRACE |
 CF_HAS_RESULT_SET | CF_CAN_BE_EXPLAINED;
// (1) so that subquery is traced when doing "SET @var = (subquery)"
/*
 @todo SQLCOM_SET_OPTION should have CF_CAN_GENERATE_ROW_EVENTS
 set, because it may invoke a stored function that generates row
 events. /Sven
*/
 sql_command_flags[SQLCOM_SET_OPTION] =
 CF_REEXECUTION_FRAGILE | CF_AUTO_COMMIT_TRANS |
 CF_CAN_GENERATE_ROW_EVENTS | CF_OPTIMIZER_TRACE; // (1)
// (1) so that subquery is traced when doing "DO @var := (subquery)"
 sql_command_flags[SQLCOM_DO] = CF_REEXECUTION_FRAGILE |
 CF_CAN_GENERATE_ROW_EVENTS |
 CF_OPTIMIZER_TRACE; // (1)

 sql_command_flags[SQLCOM_SET_PASSWORD] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS | CF_NEEDS_AUTOCOMMIT_OFF |
 CF_POTENTIAL_ATOMIC_DDL | CF_DISALLOW_IN_RO_TRANS;

 sql_command_flags[SQLCOM_SHOW_STATUS_PROC] =
 CF_STATUS_COMMAND | CF_REEXECUTION_FRAGILE | CF_HAS_RESULT_SET;
 sql_command_flags[SQLCOM_SHOW_STATUS] =
 CF_STATUS_COMMAND | CF_REEXECUTION_FRAGILE | CF_HAS_RESULT_SET;
 sql_command_flags[SQLCOM_SHOW_DATABASES] =
 CF_STATUS_COMMAND | CF_REEXECUTION_FRAGILE | CF_HAS_RESULT_SET;
 sql_command_flags[SQLCOM_SHOW_TRIGGERS] =
 CF_STATUS_COMMAND | CF_REEXECUTION_FRAGILE | CF_HAS_RESULT_SET;
 sql_command_flags[SQLCOM_SHOW_EVENTS] =
 CF_STATUS_COMMAND | CF_REEXECUTION_FRAGILE | CF_HAS_RESULT_SET;
 sql_command_flags[SQLCOM_SHOW_OPEN_TABLES] =
 CF_STATUS_COMMAND | CF_REEXECUTION_FRAGILE | CF_HAS_RESULT_SET;
 sql_command_flags[SQLCOM_SHOW_PLUGINS] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_FIELDS] =
 CF_STATUS_COMMAND | CF_REEXECUTION_FRAGILE | CF_HAS_RESULT_SET;
 sql_command_flags[SQLCOM_SHOW_KEYS] =
 CF_STATUS_COMMAND | CF_REEXECUTION_FRAGILE | CF_HAS_RESULT_SET;
 sql_command_flags[SQLCOM_SHOW_VARIABLES] =
 CF_STATUS_COMMAND | CF_REEXECUTION_FRAGILE | CF_HAS_RESULT_SET;
 sql_command_flags[SQLCOM_SHOW_CHARSETS] =
 CF_STATUS_COMMAND | CF_REEXECUTION_FRAGILE | CF_HAS_RESULT_SET;
 sql_command_flags[SQLCOM_SHOW_COLLATIONS] =
 CF_STATUS_COMMAND | CF_HAS_RESULT_SET | CF_REEXECUTION_FRAGILE;
 sql_command_flags[SQLCOM_SHOW_BINLOGS] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_SLAVE_HOSTS] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_BINLOG_EVENTS] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_STORAGE_ENGINES] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_PRIVILEGES] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_WARNS] = CF_STATUS_COMMAND | CF_DIAGNOSTIC_STMT;
 sql_command_flags[SQLCOM_SHOW_ERRORS] =
 CF_STATUS_COMMAND | CF_DIAGNOSTIC_STMT;
 sql_command_flags[SQLCOM_SHOW_ENGINE_STATUS] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_ENGINE_MUTEX] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_ENGINE_LOGS] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_PROCESSLIST] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_GRANTS] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_CREATE_DB] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_CREATE] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_MASTER_STAT] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_SLAVE_STAT] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_CREATE_PROC] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_CREATE_FUNC] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_CREATE_TRIGGER] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_STATUS_FUNC] =
 CF_STATUS_COMMAND | CF_REEXECUTION_FRAGILE | CF_HAS_RESULT_SET;
 sql_command_flags[SQLCOM_SHOW_PROC_CODE] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_FUNC_CODE] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_CREATE_EVENT] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_PROFILES] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_SHOW_PROFILE] = CF_STATUS_COMMAND;
 sql_command_flags[SQLCOM_BINLOG_BASE64_EVENT] =
 CF_STATUS_COMMAND | CF_CAN_GENERATE_ROW_EVENTS;

 sql_command_flags[SQLCOM_SHOW_TABLES] =
 (CF_STATUS_COMMAND | CF_SHOW_TABLE_COMMAND | CF_HAS_RESULT_SET |
 CF_REEXECUTION_FRAGILE);
 sql_command_flags[SQLCOM_SHOW_TABLE_STATUS] =
 (CF_STATUS_COMMAND | CF_SHOW_TABLE_COMMAND | CF_HAS_RESULT_SET |
 CF_REEXECUTION_FRAGILE);
/**
 ACL DDLs do not access data-dictionary tables. However, they still
 need to be marked to avoid autocommit. This is necessary because
 code which saves GTID state or slave state in the system tables
 at commit time does statement commit on low-level (see
 System_table_access::close_table()) and thus can pre-maturely commit
 DDL otherwise.
*/
 sql_command_flags[SQLCOM_CREATE_USER] =
 CF_CHANGES_DATA | CF_NEEDS_AUTOCOMMIT_OFF | CF_POTENTIAL_ATOMIC_DDL;
 sql_command_flags[SQLCOM_RENAME_USER] =
 CF_CHANGES_DATA | CF_NEEDS_AUTOCOMMIT_OFF | CF_POTENTIAL_ATOMIC_DDL;
 sql_command_flags[SQLCOM_DROP_USER] =
 CF_CHANGES_DATA | CF_NEEDS_AUTOCOMMIT_OFF | CF_POTENTIAL_ATOMIC_DDL;
 sql_command_flags[SQLCOM_ALTER_USER] =
 CF_CHANGES_DATA | CF_NEEDS_AUTOCOMMIT_OFF | CF_POTENTIAL_ATOMIC_DDL;
 sql_command_flags[SQLCOM_GRANT] =
 CF_CHANGES_DATA | CF_NEEDS_AUTOCOMMIT_OFF | CF_POTENTIAL_ATOMIC_DDL;
 sql_command_flags[SQLCOM_REVOKE] =
 CF_CHANGES_DATA | CF_NEEDS_AUTOCOMMIT_OFF | CF_POTENTIAL_ATOMIC_DDL;
 sql_command_flags[SQLCOM_REVOKE_ALL] =
 CF_CHANGES_DATA | CF_NEEDS_AUTOCOMMIT_OFF | CF_POTENTIAL_ATOMIC_DDL;
 sql_command_flags[SQLCOM_ALTER_USER_DEFAULT_ROLE] =
 CF_CHANGES_DATA | CF_NEEDS_AUTOCOMMIT_OFF | CF_POTENTIAL_ATOMIC_DDL;
 sql_command_flags[SQLCOM_GRANT_ROLE] =
 CF_CHANGES_DATA | CF_NEEDS_AUTOCOMMIT_OFF | CF_POTENTIAL_ATOMIC_DDL;
 sql_command_flags[SQLCOM_REVOKE_ROLE] =
 CF_CHANGES_DATA | CF_NEEDS_AUTOCOMMIT_OFF | CF_POTENTIAL_ATOMIC_DDL;
 sql_command_flags[SQLCOM_DROP_ROLE] =
 CF_CHANGES_DATA | CF_NEEDS_AUTOCOMMIT_OFF | CF_POTENTIAL_ATOMIC_DDL;
 sql_command_flags[SQLCOM_CREATE_ROLE] =
 CF_CHANGES_DATA | CF_NEEDS_AUTOCOMMIT_OFF | CF_POTENTIAL_ATOMIC_DDL;

 sql_command_flags[SQLCOM_OPTIMIZE] = CF_CHANGES_DATA;
 sql_command_flags[SQLCOM_ALTER_INSTANCE] = CF_CHANGES_DATA;
 sql_command_flags[SQLCOM_CREATE_FUNCTION] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_CREATE_PROCEDURE] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_CREATE_SPFUNCTION] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_DROP_PROCEDURE] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_DROP_FUNCTION] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_ALTER_PROCEDURE] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_ALTER_FUNCTION] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_INSTALL_PLUGIN] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_UNINSTALL_PLUGIN] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_INSTALL_COMPONENT] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_UNINSTALL_COMPONENT] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_CREATE_RESOURCE_GROUP] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS | CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_ALTER_RESOURCE_GROUP] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS | CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_DROP_RESOURCE_GROUP] =
 CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS | CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SET_RESOURCE_GROUP] =
 CF_CHANGES_DATA | CF_ALLOW_PROTOCOL_PLUGIN;

 sql_command_flags[SQLCOM_CLONE] =
 CF_AUTO_COMMIT_TRANS | CF_ALLOW_PROTOCOL_PLUGIN;

/* Does not change the contents of the Diagnostics Area. */
 sql_command_flags[SQLCOM_GET_DIAGNOSTICS] = CF_DIAGNOSTIC_STMT;

/*
 (1): without it, in "CALL some_proc((subq))", subquery would not be
 traced.
*/
 sql_command_flags[SQLCOM_CALL] = CF_REEXECUTION_FRAGILE |
 CF_CAN_GENERATE_ROW_EVENTS |
 CF_OPTIMIZER_TRACE; // (1)
 sql_command_flags[SQLCOM_EXECUTE] = CF_CAN_GENERATE_ROW_EVENTS;

/*
 The following admin table operations are allowed
 on log tables.
*/
 sql_command_flags[SQLCOM_REPAIR] =
 CF_WRITE_LOGS_COMMAND | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_OPTIMIZE] |=
 CF_WRITE_LOGS_COMMAND | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_ANALYZE] =
 CF_WRITE_LOGS_COMMAND | CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_CHECK] =
 CF_WRITE_LOGS_COMMAND | CF_AUTO_COMMIT_TRANS;

 sql_command_flags[SQLCOM_CREATE_USER] |= CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_CREATE_ROLE] |= CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_DROP_USER] |= CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_DROP_ROLE] |= CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_RENAME_USER] |= CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_ALTER_USER] |= CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_RESTART_SERVER] =
 CF_AUTO_COMMIT_TRANS | CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_REVOKE] |= CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_REVOKE_ALL] |= CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_REVOKE_ROLE] |= CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_GRANT] |= CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_GRANT_ROLE] |= CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_ALTER_USER_DEFAULT_ROLE] |= CF_AUTO_COMMIT_TRANS;

 sql_command_flags[SQLCOM_ASSIGN_TO_KEYCACHE] = CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_PRELOAD_KEYS] = CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_ALTER_INSTANCE] |= CF_AUTO_COMMIT_TRANS;

 sql_command_flags[SQLCOM_FLUSH] = CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_RESET] = CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_CREATE_SERVER] = CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_ALTER_SERVER] = CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_DROP_SERVER] = CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_CHANGE_MASTER] = CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_CHANGE_REPLICATION_FILTER] = CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_SLAVE_START] = CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_SLAVE_STOP] = CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_STOP_GROUP_REPLICATION] = CF_IMPLICIT_COMMIT_END;
 sql_command_flags[SQLCOM_ALTER_TABLESPACE] |= CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_CREATE_SRS] |= CF_AUTO_COMMIT_TRANS;
 sql_command_flags[SQLCOM_DROP_SRS] |= CF_AUTO_COMMIT_TRANS;

/*
 The following statements can deal with temporary tables,
 so temporary tables should be pre-opened for those statements to
 simplify privilege checking.

 There are other statements that deal with temporary tables and open
 them, but which are not listed here. The thing is that the order of
 pre-opening temporary tables for those statements is somewhat custom.
*/
 sql_command_flags[SQLCOM_CREATE_TABLE] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_DROP_TABLE] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_CREATE_INDEX] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_ALTER_TABLE] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_TRUNCATE] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_LOAD] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_DROP_INDEX] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_UPDATE] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_UPDATE_MULTI] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_INSERT] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_INSERT_SELECT] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_DELETE] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_DELETE_MULTI] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_REPLACE] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_REPLACE_SELECT] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_SELECT] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_SET_OPTION] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_DO] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_CALL] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_CHECKSUM] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_ANALYZE] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_CHECK] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_OPTIMIZE] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_REPAIR] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_PRELOAD_KEYS] |= CF_PREOPEN_TMP_TABLES;
 sql_command_flags[SQLCOM_ASSIGN_TO_KEYCACHE] |= CF_PREOPEN_TMP_TABLES;

/*
 DDL statements that should start with closing opened handlers.

 We use this flag only for statements for which open HANDLERs
 have to be closed before emporary tables are pre-opened.
*/
 sql_command_flags[SQLCOM_CREATE_TABLE] |= CF_HA_CLOSE;
 sql_command_flags[SQLCOM_DROP_TABLE] |= CF_HA_CLOSE;
 sql_command_flags[SQLCOM_ALTER_TABLE] |= CF_HA_CLOSE;
 sql_command_flags[SQLCOM_TRUNCATE] |= CF_HA_CLOSE;
 sql_command_flags[SQLCOM_REPAIR] |= CF_HA_CLOSE;
 sql_command_flags[SQLCOM_OPTIMIZE] |= CF_HA_CLOSE;
 sql_command_flags[SQLCOM_ANALYZE] |= CF_HA_CLOSE;
 sql_command_flags[SQLCOM_CHECK] |= CF_HA_CLOSE;
 sql_command_flags[SQLCOM_CREATE_INDEX] |= CF_HA_CLOSE;
 sql_command_flags[SQLCOM_DROP_INDEX] |= CF_HA_CLOSE;
 sql_command_flags[SQLCOM_PRELOAD_KEYS] |= CF_HA_CLOSE;
 sql_command_flags[SQLCOM_ASSIGN_TO_KEYCACHE] |= CF_HA_CLOSE;

/*
 Mark statements that always are disallowed in read-only
 transactions. Note that according to the SQL standard,
 even temporary table DDL should be disallowed.
*/
 sql_command_flags[SQLCOM_CREATE_TABLE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_ALTER_TABLE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_DROP_TABLE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_RENAME_TABLE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_CREATE_INDEX] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_DROP_INDEX] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_CREATE_DB] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_DROP_DB] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_ALTER_DB] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_CREATE_VIEW] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_DROP_VIEW] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_CREATE_TRIGGER] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_DROP_TRIGGER] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_CREATE_EVENT] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_ALTER_EVENT] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_DROP_EVENT] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_CREATE_USER] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_CREATE_ROLE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_RENAME_USER] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_ALTER_USER] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_DROP_USER] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_DROP_ROLE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_CREATE_SERVER] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_ALTER_SERVER] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_DROP_SERVER] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_CREATE_FUNCTION] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_CREATE_PROCEDURE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_CREATE_SPFUNCTION] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_DROP_PROCEDURE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_DROP_FUNCTION] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_ALTER_PROCEDURE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_ALTER_FUNCTION] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_TRUNCATE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_ALTER_TABLESPACE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_REPAIR] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_OPTIMIZE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_GRANT] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_GRANT_ROLE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_REVOKE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_REVOKE_ALL] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_REVOKE_ROLE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_INSTALL_PLUGIN] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_UNINSTALL_PLUGIN] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_INSTALL_COMPONENT] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_UNINSTALL_COMPONENT] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_ALTER_INSTANCE] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_IMPORT] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_CREATE_SRS] |= CF_DISALLOW_IN_RO_TRANS;
 sql_command_flags[SQLCOM_DROP_SRS] |= CF_DISALLOW_IN_RO_TRANS;

/*
 Mark statements that are allowed to be executed by the plugins.
*/
 sql_command_flags[SQLCOM_SELECT] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_CREATE_TABLE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_CREATE_INDEX] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_ALTER_TABLE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_UPDATE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_INSERT] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_INSERT_SELECT] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_DELETE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_TRUNCATE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_DROP_TABLE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_DROP_INDEX] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_DATABASES] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_TABLES] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_FIELDS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_KEYS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_VARIABLES] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_STATUS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_ENGINE_LOGS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_ENGINE_STATUS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_ENGINE_MUTEX] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_PROCESSLIST] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_MASTER_STAT] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_SLAVE_STAT] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_GRANTS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_CREATE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_CHARSETS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_COLLATIONS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_CREATE_DB] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_TABLE_STATUS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_TRIGGERS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_LOAD] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SET_OPTION] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_LOCK_TABLES] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_UNLOCK_TABLES] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_GRANT] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_CHANGE_DB] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_CREATE_DB] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_DROP_DB] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_ALTER_DB] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_REPAIR] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_REPLACE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_REPLACE_SELECT] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_CREATE_FUNCTION] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_DROP_FUNCTION] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_REVOKE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_OPTIMIZE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_CHECK] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_ASSIGN_TO_KEYCACHE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_PRELOAD_KEYS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_FLUSH] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_KILL] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_ANALYZE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_ROLLBACK] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_ROLLBACK_TO_SAVEPOINT] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_COMMIT] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SAVEPOINT] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_RELEASE_SAVEPOINT] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SLAVE_START] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SLAVE_STOP] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_START_GROUP_REPLICATION] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_STOP_GROUP_REPLICATION] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_BEGIN] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_CHANGE_MASTER] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_CHANGE_REPLICATION_FILTER] |=
 CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_RENAME_TABLE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_RESET] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_PURGE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_PURGE_BEFORE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_BINLOGS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_OPEN_TABLES] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_HA_OPEN] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_HA_CLOSE] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_HA_READ] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_SLAVE_HOSTS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_DELETE_MULTI] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_UPDATE_MULTI] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_BINLOG_EVENTS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_DO] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_WARNS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_EMPTY_QUERY] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_ERRORS] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_STORAGE_ENGINES] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_SHOW_PRIVILEGES] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_HELP] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_CREATE_USER] |= CF_ALLOW_PROTOCOL_PLUGIN;
 sql_command_flags[SQLCOM_DROP_USER] |= CF_ALLOW_PROTOCOL_PLUGIN;