|
| static constexpr const unsigned long | DEFAULT_ERROR_COUNT {1024} |
| |
| static constexpr const unsigned long | DEFAULT_SORT_MEMORY {256UL * 1024UL} |
| |
| static constexpr const unsigned | HOST_CACHE_SIZE {128} |
| |
| static constexpr const unsigned long | SCHEMA_DEF_CACHE_DEFAULT {256} |
| |
| static constexpr const unsigned long | STORED_PROGRAM_DEF_CACHE_DEFAULT {256} |
| |
| static constexpr const unsigned long | TABLESPACE_DEF_CACHE_DEFAULT {256} |
| |
| static constexpr const unsigned long | TABLE_DEF_CACHE_MIN {400} |
| | We must have room for at least 400 table definitions in the table cache, since otherwise there is no chance prepared statements that use these many tables can work. More...
|
| |
| static constexpr const unsigned long | SCHEMA_DEF_CACHE_MIN {256} |
| |
| static constexpr const unsigned long | STORED_PROGRAM_DEF_CACHE_MIN {256} |
| |
| static constexpr const unsigned long | TABLESPACE_DEF_CACHE_MIN {256} |
| |
| static constexpr const unsigned long | CONNECT_TIMEOUT {10} |
| |
| static constexpr const unsigned long | DELAYED_LIMIT {100} |
| |
| static constexpr const unsigned long | DELAYED_QUEUE_SIZE {1000} |
| |
| static constexpr const unsigned long | DELAYED_WAIT_TIMEOUT {5 * 60} |
| |
| static constexpr const unsigned long | QUERY_ALLOC_BLOCK_SIZE {8192} |
| |
| static constexpr const unsigned long | QUERY_ALLOC_PREALLOC_SIZE {8192} |
| |
| static constexpr const unsigned long | TRANS_ALLOC_PREALLOC_SIZE {4096} |
| |
| static constexpr const unsigned long | RANGE_ALLOC_BLOCK_SIZE {4096} |
| |
| static constexpr const unsigned long long | OPTIMIZER_SWITCH_DEFAULT |
| |
| static constexpr const unsigned long | MYSQLD_NET_RETRY_COUNT {10} |
| |
| TYPELIB | bool_typelib |
| |
| static Sys_var_bool | Sys_pfs_enabled ("performance_schema", "Enable the performance schema.", READ_ONLY GLOBAL_VAR(pfs_param.m_enabled), CMD_LINE(OPT_ARG), DEFAULT(true), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_charptr | Sys_pfs_instrument ("performance_schema_instrument", "Default startup value for a performance schema instrument.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_pfs_instrument), CMD_LINE(OPT_ARG, OPT_PFS_INSTRUMENT), IN_FS_CHARSET, DEFAULT(""), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_charptr | Sys_pfs_meter ("performance_schema_meter", "Default startup value for a performance schema meter.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_pfs_meter), CMD_LINE(OPT_ARG, OPT_PFS_METER), IN_FS_CHARSET, DEFAULT(""), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_charptr | Sys_pfs_logger ("performance_schema_logger", "Default startup value for a performance schema logger.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_pfs_logger), CMD_LINE(OPT_ARG, OPT_PFS_LOGGER), IN_FS_CHARSET, DEFAULT(""), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_processlist ("performance_schema_show_processlist", "Default startup value to enable SHOW PROCESSLIST " "in the performance schema.", GLOBAL_VAR(pfs_processlist_enabled), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(performance_schema_show_processlist_update), nullptr, sys_var::PARSE_NORMAL) |
| |
| static Sys_var_bool | Sys_pfs_consumer_events_stages_current ("performance_schema_consumer_events_stages_current", "Default startup value for the events_stages_current consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_events_stages_current_enabled), CMD_LINE(OPT_ARG), DEFAULT(false), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_events_stages_history ("performance_schema_consumer_events_stages_history", "Default startup value for the events_stages_history consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_events_stages_history_enabled), CMD_LINE(OPT_ARG), DEFAULT(false), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_events_stages_history_long ("performance_schema_consumer_events_stages_history_long", "Default startup value for the events_stages_history_long consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_events_stages_history_long_enabled), CMD_LINE(OPT_ARG), DEFAULT(false), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_events_statements_cpu ("performance_schema_consumer_events_statements_cpu", "Default startup value for the events_statements_cpu consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_events_statements_cpu_enabled), CMD_LINE(OPT_ARG), DEFAULT(false), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_events_statements_current ("performance_schema_consumer_events_statements_current", "Default startup value for the events_statements_current consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_events_statements_current_enabled), CMD_LINE(OPT_ARG), DEFAULT(true), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_events_statements_history ("performance_schema_consumer_events_statements_history", "Default startup value for the events_statements_history consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_events_statements_history_enabled), CMD_LINE(OPT_ARG), DEFAULT(true), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_events_statements_history_long ("performance_schema_consumer_events_statements_history_long", "Default startup value for the events_statements_history_long consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_events_statements_history_long_enabled), CMD_LINE(OPT_ARG), DEFAULT(false), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_events_transactions_current ("performance_schema_consumer_events_transactions_current", "Default startup value for the events_transactions_current consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_events_transactions_current_enabled), CMD_LINE(OPT_ARG), DEFAULT(true), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_events_transactions_history ("performance_schema_consumer_events_transactions_history", "Default startup value for the events_transactions_history consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_events_transactions_history_enabled), CMD_LINE(OPT_ARG), DEFAULT(true), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_events_transactions_history_long ("performance_schema_consumer_events_transactions_history_long", "Default startup value for the events_transactions_history_long consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_events_transactions_history_long_enabled), CMD_LINE(OPT_ARG), DEFAULT(false), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_events_waits_current ("performance_schema_consumer_events_waits_current", "Default startup value for the events_waits_current consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_events_waits_current_enabled), CMD_LINE(OPT_ARG), DEFAULT(false), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_events_waits_history ("performance_schema_consumer_events_waits_history", "Default startup value for the events_waits_history consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_events_waits_history_enabled), CMD_LINE(OPT_ARG), DEFAULT(false), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_events_waits_history_long ("performance_schema_consumer_events_waits_history_long", "Default startup value for the events_waits_history_long consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_events_waits_history_long_enabled), CMD_LINE(OPT_ARG), DEFAULT(false), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_global_instrumentation ("performance_schema_consumer_global_instrumentation", "Default startup value for the global_instrumentation consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_global_instrumentation_enabled), CMD_LINE(OPT_ARG), DEFAULT(true), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_thread_instrumentation ("performance_schema_consumer_thread_instrumentation", "Default startup value for the thread_instrumentation consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_thread_instrumentation_enabled), CMD_LINE(OPT_ARG), DEFAULT(true), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_bool | Sys_pfs_consumer_statement_digest ("performance_schema_consumer_statements_digest", "Default startup value for the statements_digest consumer.", READ_ONLY NOT_VISIBLE GLOBAL_VAR(pfs_param.m_consumer_statement_digest_enabled), CMD_LINE(OPT_ARG), DEFAULT(true), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_events_waits_history_long_size ("performance_schema_events_waits_history_long_size", "Number of rows in EVENTS_WAITS_HISTORY_LONG." " Use 0 to disable, -1 for automated sizing.", READ_ONLY GLOBAL_VAR(pfs_param.m_events_waits_history_long_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSIZE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_events_waits_history_size ("performance_schema_events_waits_history_size", "Number of rows per thread in EVENTS_WAITS_HISTORY." " Use 0 to disable, -1 for automated sizing.", READ_ONLY GLOBAL_VAR(pfs_param.m_events_waits_history_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024), DEFAULT(PFS_AUTOSIZE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_max_cond_classes ("performance_schema_max_cond_classes", "Maximum number of condition instruments.", READ_ONLY GLOBAL_VAR(pfs_param.m_cond_class_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024), DEFAULT(PFS_MAX_COND_CLASS), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_max_cond_instances ("performance_schema_max_cond_instances", "Maximum number of instrumented condition objects." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_cond_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_max_program_instances ("performance_schema_max_program_instances", "Maximum number of instrumented programs." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_program_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static constexpr int | num_prepared_stmt_limit = 4 * 1024 * 1024 |
| |
| static Sys_var_long | Sys_pfs_max_prepared_stmt_instances ("performance_schema_max_prepared_statements_instances", "Maximum number of instrumented prepared statements." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_prepared_stmt_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, num_prepared_stmt_limit), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_max_file_classes ("performance_schema_max_file_classes", "Maximum number of file instruments.", READ_ONLY GLOBAL_VAR(pfs_param.m_file_class_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024), DEFAULT(PFS_MAX_FILE_CLASS), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_max_file_handles ("performance_schema_max_file_handles", "Maximum number of opened instrumented files.", READ_ONLY GLOBAL_VAR(pfs_param.m_file_handle_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024 *1024), DEFAULT(PFS_MAX_FILE_HANDLE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_max_file_instances ("performance_schema_max_file_instances", "Maximum number of instrumented files." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_file_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_max_sockets ("performance_schema_max_socket_instances", "Maximum number of opened instrumented sockets." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_socket_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_max_socket_classes ("performance_schema_max_socket_classes", "Maximum number of socket instruments.", READ_ONLY GLOBAL_VAR(pfs_param.m_socket_class_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024), DEFAULT(PFS_MAX_SOCKET_CLASS), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_max_mutex_classes ("performance_schema_max_mutex_classes", "Maximum number of mutex instruments.", READ_ONLY GLOBAL_VAR(pfs_param.m_mutex_class_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024), DEFAULT(PFS_MAX_MUTEX_CLASS), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_max_mutex_instances ("performance_schema_max_mutex_instances", "Maximum number of instrumented MUTEX objects." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_mutex_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 100 *1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_max_rwlock_classes ("performance_schema_max_rwlock_classes", "Maximum number of rwlock instruments.", READ_ONLY GLOBAL_VAR(pfs_param.m_rwlock_class_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024), DEFAULT(PFS_MAX_RWLOCK_CLASS), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_max_rwlock_instances ("performance_schema_max_rwlock_instances", "Maximum number of instrumented RWLOCK objects." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_rwlock_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 100 *1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_max_table_handles ("performance_schema_max_table_handles", "Maximum number of opened instrumented tables." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_table_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_max_table_instances ("performance_schema_max_table_instances", "Maximum number of instrumented tables." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_table_share_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_max_table_lock_stat ("performance_schema_max_table_lock_stat", "Maximum number of lock statistics for instrumented tables." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_table_lock_stat_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_max_index_stat ("performance_schema_max_index_stat", "Maximum number of index statistics for instrumented tables." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_index_stat_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_max_thread_classes ("performance_schema_max_thread_classes", "Maximum number of thread instruments.", READ_ONLY GLOBAL_VAR(pfs_param.m_thread_class_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024), DEFAULT(PFS_MAX_THREAD_CLASS), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_max_thread_instances ("performance_schema_max_thread_instances", "Maximum number of instrumented threads." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_thread_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_setup_actors_size ("performance_schema_setup_actors_size", "Maximum number of rows in SETUP_ACTORS." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_setup_actor_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_setup_objects_size ("performance_schema_setup_objects_size", "Maximum number of rows in SETUP_OBJECTS." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_setup_object_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_accounts_size ("performance_schema_accounts_size", "Maximum number of instrumented user@host accounts." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_account_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_hosts_size ("performance_schema_hosts_size", "Maximum number of instrumented hosts." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_host_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_users_size ("performance_schema_users_size", "Maximum number of instrumented users." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_user_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_max_stage_classes ("performance_schema_max_stage_classes", "Maximum number of stage instruments.", READ_ONLY GLOBAL_VAR(pfs_param.m_stage_class_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024), DEFAULT(PFS_MAX_STAGE_CLASS), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_events_stages_history_long_size ("performance_schema_events_stages_history_long_size", "Number of rows in EVENTS_STAGES_HISTORY_LONG." " Use 0 to disable, -1 for automated sizing.", READ_ONLY GLOBAL_VAR(pfs_param.m_events_stages_history_long_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSIZE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_events_stages_history_size ("performance_schema_events_stages_history_size", "Number of rows per thread in EVENTS_STAGES_HISTORY." " Use 0 to disable, -1 for automated sizing.", READ_ONLY GLOBAL_VAR(pfs_param.m_events_stages_history_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024), DEFAULT(PFS_AUTOSIZE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_max_statement_classes ("performance_schema_max_statement_classes", "Maximum number of statement instruments.", READ_ONLY GLOBAL_VAR(pfs_param.m_statement_class_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 256), DEFAULT((ulong) SQLCOM_END+(ulong) COM_END+5+SP_PSI_STATEMENT_INFO_COUNT+CLONE_PSI_STATEMENT_COUNT+STMT_HANDLE_PSI_STATEMENT_INFO_COUNT), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| | Variable performance_schema_max_statement_classes. More...
|
| |
| static Sys_var_long | Sys_pfs_events_statements_history_long_size ("performance_schema_events_statements_history_long_size", "Number of rows in EVENTS_STATEMENTS_HISTORY_LONG." " Use 0 to disable, -1 for automated sizing.", READ_ONLY GLOBAL_VAR(pfs_param.m_events_statements_history_long_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSIZE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_events_statements_history_size ("performance_schema_events_statements_history_size", "Number of rows per thread in EVENTS_STATEMENTS_HISTORY." " Use 0 to disable, -1 for automated sizing.", READ_ONLY GLOBAL_VAR(pfs_param.m_events_statements_history_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024), DEFAULT(PFS_AUTOSIZE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_statement_stack_size ("performance_schema_max_statement_stack", "Number of rows per thread in EVENTS_STATEMENTS_CURRENT.", READ_ONLY GLOBAL_VAR(pfs_param.m_statement_stack_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, 256), DEFAULT(PFS_STATEMENTS_STACK_SIZE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_max_memory_classes ("performance_schema_max_memory_classes", "Maximum number of memory pool instruments.", READ_ONLY GLOBAL_VAR(pfs_param.m_memory_class_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024), DEFAULT(PFS_MAX_MEMORY_CLASS), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_max_meter_classes ("performance_schema_max_meter_classes", "Maximum number of meter source instruments.", READ_ONLY GLOBAL_VAR(pfs_param.m_meter_class_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 64), DEFAULT(PFS_MAX_METER_CLASS), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_max_metric_classes ("performance_schema_max_metric_classes", "Maximum number of metric source instruments.", READ_ONLY GLOBAL_VAR(pfs_param.m_metric_class_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 11000), DEFAULT(PFS_MAX_METRIC_CLASS), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_max_logger_classes ("performance_schema_max_logger_classes", "Maximum number of logger source instruments.", READ_ONLY GLOBAL_VAR(pfs_param.m_logger_class_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 200), DEFAULT(PFS_MAX_LOGGER_CLASS), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_digest_size ("performance_schema_digests_size", "Size of the statement digest." " Use 0 to disable, -1 for automated sizing.", READ_ONLY GLOBAL_VAR(pfs_param.m_digest_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSIZE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_events_transactions_history_long_size ("performance_schema_events_transactions_history_long_size", "Number of rows in EVENTS_TRANSACTIONS_HISTORY_LONG." " Use 0 to disable, -1 for automated sizing.", READ_ONLY GLOBAL_VAR(pfs_param.m_events_transactions_history_long_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSIZE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_events_transactions_history_size ("performance_schema_events_transactions_history_size", "Number of rows per thread in EVENTS_TRANSACTIONS_HISTORY." " Use 0 to disable, -1 for automated sizing.", READ_ONLY GLOBAL_VAR(pfs_param.m_events_transactions_history_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024), DEFAULT(PFS_AUTOSIZE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_max_digest_length ("performance_schema_max_digest_length", "Maximum length considered for digest text, when stored in " "performance_schema tables.", READ_ONLY GLOBAL_VAR(pfs_param.m_max_digest_length), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024 *1024), DEFAULT(1024), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_pfs_max_digest_sample_age ("performance_schema_max_digest_sample_age", "The time in seconds after which a previous query sample is considered old." " When the value is 0, queries are sampled once." " When the value is greater than zero, queries are re sampled if the" " last sample is more than performance_schema_max_digest_sample_age " "seconds old.", GLOBAL_VAR(pfs_param.m_max_digest_sample_age), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024 *1024), DEFAULT(60), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_connect_attrs_size ("performance_schema_session_connect_attrs_size", "Size of session attribute string buffer per thread." " Use 0 to disable, -1 for automated sizing.", READ_ONLY GLOBAL_VAR(pfs_param.m_session_connect_attrs_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 1024 *1024), DEFAULT(PFS_AUTOSIZE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_max_metadata_locks ("performance_schema_max_metadata_locks", "Maximum number of metadata locks." " Use 0 to disable, -1 for automated scaling.", READ_ONLY GLOBAL_VAR(pfs_param.m_metadata_lock_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(-1, 100 *1024 *1024), DEFAULT(PFS_AUTOSCALE_VALUE), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_max_sql_text_length ("performance_schema_max_sql_text_length", "Maximum length of displayed sql text.", READ_ONLY GLOBAL_VAR(pfs_param.m_max_sql_text_length), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024 *1024), DEFAULT(1024), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_long | Sys_pfs_error_size ("performance_schema_error_size", "Number of server errors instrumented.", READ_ONLY GLOBAL_VAR(pfs_param.m_error_sizing), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024 *1024), DEFAULT(PFS_MAX_GLOBAL_SERVER_ERRORS), BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES) |
| |
| static Sys_var_ulong | Sys_auto_increment_increment ("auto_increment_increment", "Auto-increment columns are incremented by this", HINT_UPDATEABLE SESSION_VAR(auto_increment_increment), CMD_LINE(OPT_ARG), VALID_RANGE(1, 65535), DEFAULT(1), BLOCK_SIZE(1), NO_MUTEX_GUARD, IN_BINLOG) |
| |
| static Sys_var_ulong | Sys_auto_increment_offset ("auto_increment_offset", "Offset added to Auto-increment columns. Used when " "auto-increment-increment != 1", HINT_UPDATEABLE SESSION_VAR(auto_increment_offset), CMD_LINE(OPT_ARG), VALID_RANGE(1, 65535), DEFAULT(1), BLOCK_SIZE(1), NO_MUTEX_GUARD, IN_BINLOG) |
| |
| static Sys_var_bool | Sys_windowing_use_high_precision ("windowing_use_high_precision", "For SQL window functions, determines whether to enable inversion " "optimization for moving window frames also for floating values.", HINT_UPDATEABLE SESSION_VAR(windowing_use_high_precision), CMD_LINE(OPT_ARG), DEFAULT(true)) |
| |
| static Sys_var_uint | Sys_cte_max_recursion_depth ("cte_max_recursion_depth", "Abort a recursive common table expression " "if it does more than this number of iterations.", HINT_UPDATEABLE SESSION_VAR(cte_max_recursion_depth), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, UINT_MAX32), DEFAULT(1000), BLOCK_SIZE(1)) |
| |
| static Sys_var_bool | Sys_automatic_sp_privileges ("automatic_sp_privileges", "Creating and dropping stored procedures alters ACLs", GLOBAL_VAR(sp_automatic_privileges), CMD_LINE(OPT_ARG), DEFAULT(true)) |
| |
| static Sys_var_ulong | Sys_back_log ("back_log", "The number of outstanding connection requests " "MySQL can have. This comes into play when the main MySQL thread " "gets very many connection requests in a very short time", READ_ONLY GLOBAL_VAR(back_log), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 65535), DEFAULT(0), BLOCK_SIZE(1)) |
| |
| static Sys_var_charptr | Sys_basedir ("basedir", "Path to installation directory. All paths are " "usually resolved relative to this", READ_ONLY NON_PERSIST GLOBAL_VAR(mysql_home_ptr), CMD_LINE(REQUIRED_ARG, 'b'), IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static PolyLock_mutex Plock_default_password_lifetime & | LOCK_default_password_lifetime |
| |
| static Sys_var_uint | Sys_default_password_lifetime ("default_password_lifetime", "The number of days after which the " "password will expire.", GLOBAL_VAR(default_password_lifetime), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, UINT_MAX16), DEFAULT(0), BLOCK_SIZE(1), &Plock_default_password_lifetime) |
| |
| static Sys_var_charptr | Sys_my_bind_addr ("bind_address", "IP address(es) to bind to. Syntax: address[,address]...," " where address can be an IPv4 address, IPv6 address," " host name or one of the wildcard values *, ::, 0.0.0.0." " In case more than one address is specified in a" " comma-separated list, wildcard values are not allowed." " Every address can have optional network namespace separated" " by the delimiter / from the address value. E.g., the following value" " 192.168.1.1/red,172.16.1.1/green,193.168.1.1 specifies three IP" " addresses to listen for incoming TCP connections two of that have" " to be placed in corresponding namespaces: the address 192.168.1.1" " must be placed into the namespace red and the address 172.16.1.1" " must be placed into the namespace green. Using of network namespace" " requires its support from underlying Operating System. Attempt to specify" " a network namespace for a platform that doesn't support it results in" " error during socket creation.", READ_ONLY NON_PERSIST GLOBAL_VAR(my_bind_addr_str), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(MY_BIND_ALL_ADDRESSES)) |
| |
| static Sys_var_charptr | Sys_admin_addr ("admin_address", "IP address to bind to for service connection. Address can be an IPv4" " address, IPv6 address, or host name. Wildcard values *, ::, 0.0.0.0" " are not allowed. Address value can have following optional network" " namespace separated by the delimiter / from the address value." " E.g., the following value 192.168.1.1/red specifies IP addresses to" " listen for incoming TCP connections that have to be placed into" " the namespace 'red'. Using of network namespace requires its support" " from underlying Operating System. Attempt to specify a network namespace" " for a platform that doesn't support it results in error during socket" " creation.", READ_ONLY NON_PERSIST GLOBAL_VAR(my_admin_bind_addr_str), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_uint | Sys_admin_port ("admin_port", "Port number to use for service connection," " built-in default (" STRINGIFY_ARG(MYSQL_ADMIN_PORT) ")", READ_ONLY NON_PERSIST GLOBAL_VAR(mysqld_admin_port), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 65535), DEFAULT(MYSQL_ADMIN_PORT), BLOCK_SIZE(1)) |
| |
| static Sys_var_bool | Sys_use_separate_thread_for_admin ("create_admin_listener_thread", "Use a dedicated thread for listening incoming connections on admin" " interface", READ_ONLY NON_PERSIST GLOBAL_VAR(listen_admin_interface_in_separate_thread), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_bool | Sys_password_require_current ("password_require_current", "Current password is needed to be specified in order to change it", GLOBAL_VAR(password_require_current), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static PolyLock_mutex Plock_partial_revokes & | LOCK_partial_revokes |
| | We also modify the global variable outside of sys_var structure. More...
|
| |
| static Sys_var_bool | Sys_partial_revokes ("partial_revokes", "Access of database objects can be restricted, " "even if user has global privileges granted.", GLOBAL_VAR(opt_partial_revokes), CMD_LINE(OPT_ARG), DEFAULT(DEFAULT_PARTIAL_REVOKES), &Plock_partial_revokes, IN_BINLOG, ON_CHECK(check_partial_revokes), ON_UPDATE(partial_revokes_update), nullptr, sys_var::PARSE_EARLY) |
| |
| static Sys_var_ulong | Sys_binlog_cache_size ("binlog_cache_size", "The size of the transactional cache for " "updates to transactional engines for the binary log. " "If you often use transactions containing many statements, " "you can increase this to get more performance", GLOBAL_VAR(binlog_cache_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(IO_SIZE, ULONG_MAX), DEFAULT(32768), BLOCK_SIZE(IO_SIZE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_binlog_cache_size)) |
| |
| static Sys_var_ulong | Sys_binlog_stmt_cache_size ("binlog_stmt_cache_size", "The size of the statement cache for " "updates to non-transactional engines for the binary log. " "If you often use statements updating a great number of rows, " "you can increase this to get more performance", GLOBAL_VAR(binlog_stmt_cache_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(IO_SIZE, ULONG_MAX), DEFAULT(32768), BLOCK_SIZE(IO_SIZE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_binlog_stmt_cache_size)) |
| |
| static Sys_var_int32 | Sys_binlog_max_flush_queue_time ("binlog_max_flush_queue_time", "The maximum time that the binary log group commit will keep reading" " transactions before it flush the transactions to the binary log (and" " optionally sync, depending on the value of sync_binlog).", GLOBAL_VAR(opt_binlog_max_flush_queue_time), CMD_LINE(REQUIRED_ARG, OPT_BINLOG_MAX_FLUSH_QUEUE_TIME), VALID_RANGE(0, 100000), DEFAULT(0), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_long | Sys_binlog_group_commit_sync_delay ("binlog_group_commit_sync_delay", "The number of microseconds the server waits for the " "binary log group commit sync queue to fill before " "continuing. Default: 0. Min: 0. Max: 1000000.", GLOBAL_VAR(opt_binlog_group_commit_sync_delay), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1000000), DEFAULT(0), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG) |
| |
| static Sys_var_ulong | Sys_binlog_group_commit_sync_no_delay_count ("binlog_group_commit_sync_no_delay_count", "If there are this many transactions in the commit sync " "queue and the server is waiting for more transactions " "to be enqueued (as set using --binlog-group-commit-sync-delay), " "the commit procedure resumes.", GLOBAL_VAR(opt_binlog_group_commit_sync_no_delay_count), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 100000), DEFAULT(0), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG) |
| |
| static Sys_var_test_flag | Sys_core_file ("core_file", "write a core-file on crashes", TEST_CORE_ON_SIGNAL) |
| |
| static Sys_var_enum | Sys_binlog_format ("binlog_format", "The format used when writing the binary log. ROW writes each changed " "row in a binary format. STATEMENT writes SQL statements. MIXED writes " "SQL statements for most statements, and row format for statements that " "cannot be replayed in a deterministic manner using SQL. If NDBCLUSTER " "is enabled and binlog-format is MIXED, the format switches to row-based " "and back implicitly for each query accessing an NDBCLUSTER table." " This option is deprecated and will be removed in a future version.", SESSION_VAR(binlog_format), CMD_LINE(REQUIRED_ARG, OPT_BINLOG_FORMAT), binlog_format_names, DEFAULT(BINLOG_FORMAT_ROW), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(binlog_format_check), ON_UPDATE(fix_binlog_format_after_update), DEPRECATED_VAR("")) |
| |
| static const char * | rbr_exec_mode_names [] = {"STRICT", "IDEMPOTENT", nullptr} |
| |
| static Sys_var_enum | rbr_exec_mode ("rbr_exec_mode", "Modes for how row events should be executed. Legal values " "are STRICT (default) and IDEMPOTENT. In IDEMPOTENT mode, " "the server will not throw errors for operations that are idempotent. " "In STRICT mode, server will throw errors for the operations that " "cause a conflict.", SESSION_VAR(rbr_exec_mode_options), NO_CMD_LINE, rbr_exec_mode_names, DEFAULT(RBR_EXEC_MODE_STRICT), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(prevent_global_rbr_exec_mode_idempotent), ON_UPDATE(nullptr)) |
| |
| static const char * | binlog_row_image_names [] |
| |
| static Sys_var_enum | Sys_binlog_row_image ("binlog_row_image", "Controls whether rows should be logged in 'FULL', 'NOBLOB' or " "'MINIMAL' formats. 'FULL', means that all columns in the before " "and after image are logged. 'NOBLOB', means that mysqld avoids logging " "blob columns whenever possible (e.g. blob column was not changed or " "is not part of primary key). 'MINIMAL', means that a PK equivalent (PK " "columns or full row if there is no PK in the table) is logged in the " "before image, and only changed columns are logged in the after image. " "(Default: FULL).", SESSION_VAR(binlog_row_image), CMD_LINE(REQUIRED_ARG), binlog_row_image_names, DEFAULT(BINLOG_ROW_IMAGE_FULL), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_binlog_row_image), ON_UPDATE(nullptr)) |
| |
| static const char * | binlog_row_metadata_names [] = {"MINIMAL", "FULL", NullS} |
| |
| static Sys_var_enum | Sys_binlog_row_metadata ("binlog_row_metadata", "Controls how much type information is written to the binary log when " "using ROW format. FULL causes all metadata to be logged. MINIMAL means " "that only metadata actually needed by replicas is logged.", GLOBAL_VAR(binlog_row_metadata), CMD_LINE(REQUIRED_ARG), binlog_row_metadata_names, DEFAULT(BINLOG_ROW_METADATA_MINIMAL), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static Sys_var_bool | Sys_binlog_trx_compression ("binlog_transaction_compression", "Whether to compress transactions or not. Transactions are compressed " "using the ZSTD compression algorythm.", SESSION_VAR(binlog_trx_compression), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_binlog_trx_compression)) |
| |
| static Sys_var_uint | Sys_binlog_transaction_compression_level_zstd ("binlog_transaction_compression_level_zstd", "Specifies the transaction compression level for ZSTD " "transaction compression in the binary log.", SESSION_VAR(binlog_trx_compression_level_zstd), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, 22), DEFAULT(mysql::binlog::event::compression::Zstd_comp::default_compression_level), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_binlog_trx_compression), ON_UPDATE(nullptr)) |
| |
| static const char * | session_track_gtids_names [] |
| |
| static Sys_var_enum | Sys_session_track_gtids ("session_track_gtids", "Controls the amount of global transaction ids to be " "included in the response packet sent by the server." "(Default: OFF).", SESSION_VAR(session_track_gtids), CMD_LINE(REQUIRED_ARG), session_track_gtids_names, DEFAULT(SESSION_TRACK_GTIDS_OFF), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_outside_trx), ON_UPDATE(on_session_track_gtids_update)) |
| |
| static Sys_var_bool | Sys_binlog_direct ("binlog_direct_non_transactional_updates", "Causes updates to non-transactional engines using statement format to " "be written directly to binary log, after executing them and before " "committing the transaction. Before using this option make sure " "that there are no dependencies between transactional and " "non-transactional tables such as in the statement INSERT INTO t_myisam " "SELECT * FROM t_innodb; otherwise, replicas may diverge.", SESSION_VAR(binlog_direct_non_trans_update), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(binlog_direct_check)) |
| |
| static Sys_var_bool | Sys_explicit_defaults_for_timestamp ("explicit_defaults_for_timestamp", "This option causes CREATE TABLE to create all TIMESTAMP columns " "as NULL with DEFAULT NULL attribute, Without this option, " "TIMESTAMP columns are NOT NULL and have implicit DEFAULT clauses. " "The old behavior is deprecated. " "The variable can only be set by users having the SUPER privilege.", SESSION_VAR(explicit_defaults_for_timestamp), CMD_LINE(OPT_ARG), DEFAULT(true), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_explicit_defaults_for_timestamp)) |
| | This variable is read only to users. More...
|
| |
| static Sys_var_bool | Sys_binlog_rows_query ("binlog_rows_query_log_events", "Allow writing of Rows_query_log events into binary log.", SESSION_VAR(binlog_rows_query_log_events), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin)) |
| |
| static Sys_var_bool | Sys_binlog_order_commits ("binlog_order_commits", "Issue internal commit calls in the same order as transactions are" " written to the binary log. Default is to order commits.", GLOBAL_VAR(opt_binlog_order_commits), CMD_LINE(OPT_ARG), DEFAULT(true)) |
| |
| static Sys_var_ulong | Sys_bulk_insert_buff_size ("bulk_insert_buffer_size", "Size of tree cache used in bulk " "insert optimisation. Note that this is a limit per thread!", HINT_UPDATEABLE SESSION_VAR(bulk_insert_buff_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, ULONG_MAX), DEFAULT(8192 *1024), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin)) |
| |
| static Sys_var_charptr | Sys_character_sets_dir ("character_sets_dir", "Directory where character sets are", READ_ONLY NON_PERSIST GLOBAL_VAR(charsets_dir), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_ulong | Sys_select_into_buffer_size ("select_into_buffer_size", "Buffer size for SELECT INTO OUTFILE/DUMPFILE.", HINT_UPDATEABLE SESSION_VAR(select_into_buffer_size), CMD_LINE(OPT_ARG), VALID_RANGE(IO_SIZE *2, INT_MAX32), DEFAULT(128 *1024), BLOCK_SIZE(IO_SIZE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin_no_super)) |
| |
| static Sys_var_bool | Sys_select_into_disk_sync ("select_into_disk_sync", "Synchronize flushed buffer with disk for SELECT INTO OUTFILE/DUMPFILE.", HINT_UPDATEABLE SESSION_VAR(select_into_disk_sync), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_uint | Sys_select_into_disk_sync_delay ("select_into_disk_sync_delay", "The delay in milliseconds after each buffer sync " "for SELECT INTO OUTFILE/DUMPFILE. Requires select_into_sync_disk = ON.", HINT_UPDATEABLE SESSION_VAR(select_into_disk_sync_delay), CMD_LINE(OPT_ARG), VALID_RANGE(0, LONG_TIMEOUT), DEFAULT(0), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin_no_super)) |
| |
| static CHARSET_INFO * | charset_system_default = &my_charset_utf8mb3_general_ci |
| |
| static Sys_var_struct< CHARSET_INFO, Get_csname > | Sys_character_set_system ("character_set_system", "The character set used by the server " "for storing identifiers", READ_ONLY NON_PERSIST GLOBAL_VAR(system_charset_info), NO_CMD_LINE, DEFAULT(&charset_system_default)) |
| |
| static Sys_var_struct< CHARSET_INFO, Get_csname > | Sys_character_set_server ("character_set_server", "The default character set", PERSIST_AS_READONLY SESSION_VAR(collation_server), NO_CMD_LINE, DEFAULT(&default_charset_info), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_charset_not_null)) |
| |
| static Sys_var_struct< CHARSET_INFO, Get_csname > | Sys_character_set_database ("character_set_database", " The character set used by the default database", SESSION_VAR(collation_database), NO_CMD_LINE, DEFAULT(&default_charset_info), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_charset_db), ON_UPDATE(update_deprecated)) |
| |
| static Sys_var_struct< CHARSET_INFO, Get_csname > | Sys_character_set_client ("character_set_client", "The character set for statements " "that arrive from the client", SESSION_VAR(character_set_client), NO_CMD_LINE, DEFAULT(&default_charset_info), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_cs_client), ON_UPDATE(fix_thd_charset)) |
| |
| static Sys_var_struct< CHARSET_INFO, Get_csname > | Sys_character_set_connection ("character_set_connection", "The character set used for " "literals that do not have a character set introducer and for " "number-to-string conversion", SESSION_VAR(collation_connection), NO_CMD_LINE, DEFAULT(&default_charset_info), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_charset_not_null), ON_UPDATE(fix_thd_charset)) |
| |
| static Sys_var_struct< CHARSET_INFO, Get_csname > | Sys_character_set_results ("character_set_results", "The character set used for returning " "query results to the client", SESSION_VAR(character_set_results), NO_CMD_LINE, DEFAULT(&default_charset_info), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_charset)) |
| |
| static Sys_var_struct< CHARSET_INFO, Get_csname > | Sys_character_set_filesystem ("character_set_filesystem", "The filesystem character set", SESSION_VAR(character_set_filesystem), NO_CMD_LINE, DEFAULT(&character_set_filesystem), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_cs_filesystem), ON_UPDATE(fix_thd_charset)) |
| |
| static const char * | completion_type_names [] |
| |
| static Sys_var_enum | Sys_completion_type ("completion_type", "The transaction completion type, one of " "NO_CHAIN, CHAIN, RELEASE", SESSION_VAR(completion_type), CMD_LINE(REQUIRED_ARG), completion_type_names, DEFAULT(0)) |
| |
| static Sys_var_struct< CHARSET_INFO, Get_name > | Sys_collation_connection ("collation_connection", "The collation of the connection " "character set", SESSION_VAR(collation_connection), NO_CMD_LINE, DEFAULT(&default_charset_info), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_collation_not_null), ON_UPDATE(fix_thd_charset)) |
| |
| static Sys_var_struct< CHARSET_INFO, Get_name > | Sys_collation_database ("collation_database", "The collation of the database " "character set", SESSION_VAR(collation_database), NO_CMD_LINE, DEFAULT(&default_charset_info), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_collation_db), ON_UPDATE(update_deprecated)) |
| |
| static Sys_var_struct< CHARSET_INFO, Get_name > | Sys_collation_server ("collation_server", "The server default collation", SESSION_VAR(collation_server), NO_CMD_LINE, DEFAULT(&default_charset_info), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_collation_not_null)) |
| |
| static const char * | concurrent_insert_names [] |
| |
| static Sys_var_enum | Sys_concurrent_insert ("concurrent_insert", "Use concurrent insert with MyISAM. Possible " "values are NEVER, AUTO, ALWAYS", GLOBAL_VAR(myisam_concurrent_insert), CMD_LINE(OPT_ARG), concurrent_insert_names, DEFAULT(1)) |
| |
| static Sys_var_ulong | Sys_connect_timeout ("connect_timeout", "The number of seconds the mysqld server is waiting for a connect " "packet before responding with 'Bad handshake'", GLOBAL_VAR(connect_timeout), CMD_LINE(REQUIRED_ARG), VALID_RANGE(2, LONG_TIMEOUT), DEFAULT(CONNECT_TIMEOUT), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_information_schema_stats_expiry ("information_schema_stats_expiry", "The number of seconds after which mysqld server will fetch " "data from storage engine and replace the data in cache.", SESSION_VAR(information_schema_stats_expiry), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, LONG_TIMEOUT), DEFAULT(24 *60 *60), BLOCK_SIZE(1)) |
| |
| static Sys_var_charptr | Sys_datadir ("datadir", "Path to the database root directory", READ_ONLY NON_PERSIST GLOBAL_VAR(mysql_real_data_home_ptr), CMD_LINE(REQUIRED_ARG, 'h'), IN_FS_CHARSET, DEFAULT(mysql_real_data_home)) |
| |
| static Sys_var_dbug | Sys_dbug ("debug", "Debug log", sys_var::SESSION, CMD_LINE(OPT_ARG, '#'), DEFAULT(""), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin)) |
| |
| static const char * | delay_key_write_names [] = {"OFF", "ON", "ALL", NullS} |
| |
| static Sys_var_enum | Sys_delay_key_write ("delay_key_write", "Type of DELAY_KEY_WRITE", GLOBAL_VAR(delay_key_write_options), CMD_LINE(OPT_ARG), delay_key_write_names, DEFAULT(DELAY_KEY_WRITE_ON), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_delay_key_write)) |
| |
| static Sys_var_ulong | Sys_delayed_insert_limit ("delayed_insert_limit", "After inserting delayed_insert_limit rows, the INSERT DELAYED " "handler will check if there are any SELECT statements pending. " "If so, it allows these to execute before continuing. " "This variable is deprecated along with INSERT DELAYED.", GLOBAL_VAR(delayed_insert_limit), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, ULONG_MAX), DEFAULT(DELAYED_LIMIT), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_ulong | Sys_delayed_insert_timeout ("delayed_insert_timeout", "How long a INSERT DELAYED thread should wait for INSERT statements " "before terminating. " "This variable is deprecated along with INSERT DELAYED.", GLOBAL_VAR(delayed_insert_timeout), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, LONG_TIMEOUT), DEFAULT(DELAYED_WAIT_TIMEOUT), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_ulong | Sys_delayed_queue_size ("delayed_queue_size", "What size queue (in rows) should be allocated for handling INSERT " "DELAYED. If the queue becomes full, any client that does INSERT " "DELAYED will wait until there is room in the queue again. " "This variable is deprecated along with INSERT DELAYED.", GLOBAL_VAR(delayed_queue_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, ULONG_MAX), DEFAULT(DELAYED_QUEUE_SIZE), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static const char * | event_scheduler_names [] = {"OFF", "ON", "DISABLED", NullS} |
| |
| static Sys_var_enum | Sys_event_scheduler ("event_scheduler", "Enable the event scheduler. Possible values are " "ON, OFF, and DISABLED (keep the event scheduler completely " "deactivated, it cannot be activated run-time)", GLOBAL_VAR(Events::opt_event_scheduler), CMD_LINE(OPT_ARG), event_scheduler_names, DEFAULT(Events::EVENTS_ON), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(event_scheduler_check), ON_UPDATE(event_scheduler_update)) |
| |
| static Sys_var_ulong | Sys_binlog_expire_logs_seconds ("binlog_expire_logs_seconds", "If non-zero, binary logs will be purged after binlog_expire_logs_seconds" " seconds; Purges happen at startup and at binary log rotation.", GLOBAL_VAR(binlog_expire_logs_seconds), CMD_LINE(REQUIRED_ARG, OPT_BINLOG_EXPIRE_LOGS_SECONDS), VALID_RANGE(0, 0xFFFFFFFF), DEFAULT(2592000), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static Sys_var_bool | Sys_binlog_expire_logs_auto_purge ("binlog_expire_logs_auto_purge", "Controls whether the server shall automatically purge binary log " "files or not. If this variable is set to FALSE then the server will " "not purge binary log files automatically.", GLOBAL_VAR(opt_binlog_expire_logs_auto_purge), CMD_LINE(OPT_ARG), DEFAULT(true)) |
| |
| static Sys_var_bool | Sys_flush ("flush", "Flush MyISAM tables to disk between SQL commands", GLOBAL_VAR(myisam_flush), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_ulong | Sys_flush_time ("flush_time", "A dedicated thread is created to flush all tables at the " "given interval", GLOBAL_VAR(flush_time), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, LONG_TIMEOUT), DEFAULT(0), BLOCK_SIZE(1)) |
| |
| static Sys_var_charptr | Sys_ft_boolean_syntax ("ft_boolean_syntax", "List of operators for " "MATCH ... AGAINST ( ... IN BOOLEAN MODE)", GLOBAL_VAR(ft_boolean_syntax), CMD_LINE(REQUIRED_ARG), IN_SYSTEM_CHARSET, DEFAULT(DEFAULT_FTB_SYNTAX), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_ftb_syntax)) |
| |
| static Sys_var_ulong | Sys_ft_max_word_len ("ft_max_word_len", "The maximum length of the word to be included in a FULLTEXT index. " "Note: FULLTEXT indexes must be rebuilt after changing this variable", READ_ONLY GLOBAL_VAR(ft_max_word_len), CMD_LINE(REQUIRED_ARG), VALID_RANGE(10, HA_FT_MAXCHARLEN), DEFAULT(HA_FT_MAXCHARLEN), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_ft_min_word_len ("ft_min_word_len", "The minimum length of the word to be included in a FULLTEXT index. " "Note: FULLTEXT indexes must be rebuilt after changing this variable", READ_ONLY GLOBAL_VAR(ft_min_word_len), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, HA_FT_MAXCHARLEN), DEFAULT(4), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_ft_query_expansion_limit ("ft_query_expansion_limit", "Number of best matches to use for query expansion", READ_ONLY GLOBAL_VAR(ft_query_expansion_limit), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1000), DEFAULT(20), BLOCK_SIZE(1)) |
| |
| static Sys_var_charptr | Sys_ft_stopword_file ("ft_stopword_file", "Use stopwords from this file instead of built-in list", READ_ONLY NON_PERSIST GLOBAL_VAR(ft_stopword_file), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static PolyLock_rwlock PLock_sys_init_connect & | LOCK_sys_init_connect |
| |
| static Sys_var_lexstring | Sys_init_connect ("init_connect", "Command(s) that are executed for each " "new connection", GLOBAL_VAR(opt_init_connect), CMD_LINE(REQUIRED_ARG), IN_SYSTEM_CHARSET, DEFAULT(""), &PLock_sys_init_connect, NOT_IN_BINLOG, ON_CHECK(check_init_string)) |
| |
| static Sys_var_charptr | Sys_init_file ("init_file", "Read SQL commands from this file at startup", READ_ONLY NON_PERSIST GLOBAL_VAR(opt_init_file), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static PolyLock_rwlock PLock_sys_init_replica & | LOCK_sys_init_replica |
| |
| static Sys_var_lexstring | Sys_init_replica ("init_replica", "Command(s) that are executed by the replication applier thread " "each time the applier threads start.", GLOBAL_VAR(opt_init_replica), CMD_LINE(REQUIRED_ARG), IN_SYSTEM_CHARSET, DEFAULT(""), &PLock_sys_init_replica, NOT_IN_BINLOG, ON_CHECK(check_init_string)) |
| |
| static Sys_var_deprecated_alias | Sys_init_slave ("init_slave", Sys_init_replica) |
| |
| static Sys_var_ulong | Sys_interactive_timeout ("interactive_timeout", "The number of seconds the server waits for activity on an interactive " "connection before closing it", SESSION_VAR(net_interactive_timeout), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, LONG_TIMEOUT), DEFAULT(NET_WAIT_TIMEOUT), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_join_buffer_size ("join_buffer_size", "The size of the buffer that is used for full joins", HINT_UPDATEABLE SESSION_VAR(join_buff_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(128, ULONG_MAX), DEFAULT(256 *1024), BLOCK_SIZE(128)) |
| |
| static Sys_var_keycache | Sys_key_buffer_size ("key_buffer_size", "The size of the buffer used for " "index blocks for MyISAM tables. Increase this to get better index " "handling (for all reads and multiple writes) to as much as you can " "afford", KEYCACHE_VAR(param_buff_size), CMD_LINE(REQUIRED_ARG, OPT_KEY_BUFFER_SIZE), VALID_RANGE(0, SIZE_T_MAX), DEFAULT(KEY_CACHE_SIZE), BLOCK_SIZE(IO_SIZE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_buffer_size)) |
| |
| static Sys_var_keycache | Sys_key_cache_block_size ("key_cache_block_size", "The default size of key cache blocks", KEYCACHE_VAR(param_block_size), CMD_LINE(REQUIRED_ARG, OPT_KEY_CACHE_BLOCK_SIZE), VALID_RANGE(512, 1024 *16), DEFAULT(KEY_CACHE_BLOCK_SIZE), BLOCK_SIZE(512), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_keycache_param)) |
| |
| static Sys_var_keycache | Sys_key_cache_division_limit ("key_cache_division_limit", "The minimum percentage of warm blocks in key cache", KEYCACHE_VAR(param_division_limit), CMD_LINE(REQUIRED_ARG, OPT_KEY_CACHE_DIVISION_LIMIT), VALID_RANGE(1, 100), DEFAULT(100), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_keycache_param)) |
| |
| static Sys_var_keycache | Sys_key_cache_age_threshold ("key_cache_age_threshold", "This characterizes the number of " "hits a hot block has to be untouched until it is considered aged " "enough to be downgraded to a warm block. This specifies the " "percentage ratio of that number of hits to the total number of " "blocks in key cache", KEYCACHE_VAR(param_age_threshold), CMD_LINE(REQUIRED_ARG, OPT_KEY_CACHE_AGE_THRESHOLD), VALID_RANGE(100, ULONG_MAX), DEFAULT(300), BLOCK_SIZE(100), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_keycache_param)) |
| |
| static Sys_var_bool | Sys_large_files_support ("large_files_support", "Whether mysqld was compiled with options for large file support", READ_ONLY NON_PERSIST GLOBAL_VAR(opt_large_files), NO_CMD_LINE, DEFAULT(sizeof(my_off_t) > 4)) |
| |
| static Sys_var_uint | Sys_large_page_size ("large_page_size", "If large page support is enabled, this shows the size of memory pages", READ_ONLY NON_PERSIST GLOBAL_VAR(opt_large_page_size), NO_CMD_LINE, VALID_RANGE(0, UINT_MAX), DEFAULT(0), BLOCK_SIZE(1)) |
| |
| static Sys_var_bool | Sys_large_pages ("large_pages", "Enable support for large pages", READ_ONLY GLOBAL_VAR(opt_large_pages), IF_WIN(NO_CMD_LINE, CMD_LINE(OPT_ARG)), DEFAULT(false)) |
| |
| static Sys_var_charptr | Sys_language ("lc_messages_dir", "Directory where error messages are", READ_ONLY NON_PERSIST GLOBAL_VAR(lc_messages_dir_ptr), CMD_LINE(REQUIRED_ARG, OPT_LC_MESSAGES_DIRECTORY), IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_bool | Sys_local_infile ("local_infile", "Enable LOAD DATA LOCAL INFILE", GLOBAL_VAR(opt_local_infile), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_ulong | Sys_lock_wait_timeout ("lock_wait_timeout", "Timeout in seconds to wait for a lock before returning an error.", HINT_UPDATEABLE SESSION_VAR(lock_wait_timeout), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, LONG_TIMEOUT), DEFAULT(LONG_TIMEOUT), BLOCK_SIZE(1)) |
| |
| static Sys_var_bool | Sys_locked_in_memory ("locked_in_memory", "Whether mysqld was locked in memory with --memlock", READ_ONLY NON_PERSIST GLOBAL_VAR(locked_in_memory), NO_CMD_LINE, DEFAULT(false)) |
| |
| static Sys_var_bool | Sys_log_bin ("log_bin", "Whether the binary log is enabled", READ_ONLY NON_PERSIST GLOBAL_VAR(opt_bin_log), NO_CMD_LINE, DEFAULT(true)) |
| |
| static Sys_var_ulong | Sys_rpl_stop_replica_timeout ("rpl_stop_replica_timeout", "Timeout in seconds to wait for replication threads to stop, before " "STOP REPLICA returns a warning.", GLOBAL_VAR(rpl_stop_replica_timeout), CMD_LINE(REQUIRED_ARG), VALID_RANGE(2, LONG_TIMEOUT), DEFAULT(LONG_TIMEOUT), BLOCK_SIZE(1)) |
| |
| static Sys_var_deprecated_alias | Sys_rpl_stop_slave_timeout ("rpl_stop_slave_timeout", Sys_rpl_stop_replica_timeout) |
| |
| static Sys_var_enum | Sys_binlog_error_action ("binlog_error_action", "When statements cannot be written to the binary log due to a fatal " "error, this option determines whether the server ignores the error and " "closes the binary log, or aborts.", GLOBAL_VAR(binlog_error_action), CMD_LINE(REQUIRED_ARG), binlog_error_action_list, DEFAULT(ABORT_SERVER)) |
| |
| static Sys_var_bool | Sys_trust_function_creators ("log_bin_trust_function_creators", "If set to FALSE (the default), then when --log-bin is used, creation " "of a stored function (or trigger) is allowed only to users having the " "SUPER privilege and only if this stored function (trigger) may not " "break binary logging. Note that if ALL connections to this server " "ALWAYS use row-based binary logging, the security issues do not " "exist and the binary logging cannot break, so you can safely set " "this to TRUE. This variable is deprecated and will be removed in a " "future version.", GLOBAL_VAR(trust_function_creators), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_bool | Sys_check_proxy_users ("check_proxy_users", "If set to FALSE (the default), then proxy user identity will not be " "mapped for authentication plugins which support mapping from grant " "tables. When set to TRUE, users associated with authentication " "plugins which signal proxy user mapping should be done according to " "GRANT PROXY privilege definition.", GLOBAL_VAR(check_proxy_users), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_bool | Sys_sha256_password_proxy_users ("sha256_password_proxy_users", "If set to FALSE (the default), then the sha256_password authentication " "plugin will not signal for authenticated users to be checked for " "mapping " "to proxy users. When set to TRUE, the plugin will flag associated " "authenticated accounts to be mapped to proxy users when the server " "option " "check_proxy_users is enabled.", GLOBAL_VAR(sha256_password_proxy_users), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_charptr | Sys_log_error ("log_error", "Error log file", READ_ONLY NON_PERSIST GLOBAL_VAR(log_error_dest), CMD_LINE(OPT_ARG, OPT_LOG_ERROR), IN_FS_CHARSET, DEFAULT(disabled_my_option), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), nullptr, sys_var::PARSE_EARLY) |
| |
| static Sys_var_charptr | Sys_log_error_services ("log_error_services", "Services that should be called when an error event is received", PERSIST_AS_READONLY GLOBAL_VAR(opt_log_error_services), CMD_LINE(REQUIRED_ARG), IN_SYSTEM_CHARSET, DEFAULT(LOG_ERROR_SERVICES_DEFAULT), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_log_error_services), ON_UPDATE(fix_log_error_services), nullptr, sys_var::PARSE_EARLY) |
| |
| static Sys_var_charptr | Sys_log_error_suppression_list ("log_error_suppression_list", "Comma-separated list of error-codes. Error messages corresponding to " "these codes will not be included in the error log. Only events with a " "severity of Warning or Information can be suppressed; events with " "System " "or Error severity will always be included. Requires the filter " "\'log_filter_internal\' to be set in @@global.log_error_services, which " "is the default.", PERSIST_AS_READONLY GLOBAL_VAR(opt_log_error_suppression_list), CMD_LINE(REQUIRED_ARG), IN_SYSTEM_CHARSET, DEFAULT(""), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_log_error_suppression_list), ON_UPDATE(fix_log_error_suppression_list)) |
| |
| static Sys_var_bool | Sys_log_queries_not_using_indexes ("log_queries_not_using_indexes", "Log queries that are executed without benefit of any index to the " "slow log if it is open", GLOBAL_VAR(opt_log_queries_not_using_indexes), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_bool | Sys_log_slow_admin_statements ("log_slow_admin_statements", "Log slow OPTIMIZE, ANALYZE, ALTER and other administrative statements " "to " "the slow log if it is open.", GLOBAL_VAR(opt_log_slow_admin_statements), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_bool | Sys_log_slow_replica_statements ("log_slow_replica_statements", "Log slow statements executed by the replication applier threads to the " "slow log if it is open.", GLOBAL_VAR(opt_log_slow_replica_statements), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_deprecated_alias | Sys_log_slow_slave_statements ("log_slow_slave_statements", Sys_log_slow_replica_statements) |
| |
| static Sys_var_ulong | Sys_log_throttle_queries_not_using_indexes ("log_throttle_queries_not_using_indexes", "Log at most this many 'not using index' warnings per minute to the " "slow log. Any further warnings will be condensed into a single " "summary line. A value of 0 disables throttling. " "Option has no effect unless --log_queries_not_using_indexes is set.", GLOBAL_VAR(opt_log_throttle_queries_not_using_indexes), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, ULONG_MAX), DEFAULT(0), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_log_throttle_queries_not_using_indexes)) |
| |
| static Sys_var_ulong | Sys_log_error_verbosity ("log_error_verbosity", "How detailed the error log should be. " "1, log errors only. " "2, log errors and warnings. " "3, log errors, warnings, and notes. " "Messages sent to the client are unaffected by this setting.", PERSIST_AS_READONLY GLOBAL_VAR(log_error_verbosity), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, 3), DEFAULT(2), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_log_error_verbosity)) |
| |
| static Sys_var_enum | Sys_log_timestamps ("log_timestamps", "UTC to timestamp log files in zulu time, for more concise timestamps " "and easier correlation of logs from servers from multiple time zones, " "or SYSTEM to use the system's local time. " "This affects only log files, not log tables, as the timestamp columns " "of the latter can be converted at will.", GLOBAL_VAR(opt_log_timestamps), CMD_LINE(REQUIRED_ARG), timestamp_type_names, DEFAULT(0), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), nullptr, sys_var::PARSE_EARLY) |
| |
| static Sys_var_bool | Sys_log_statements_unsafe_for_binlog ("log_statements_unsafe_for_binlog", "Log statements considered unsafe when using statement based binary " "logging. This variable is deprecated and will be removed in a " "future version.", GLOBAL_VAR(opt_log_unsafe_statements), CMD_LINE(OPT_ARG), DEFAULT(true), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_double | Sys_long_query_time ("long_query_time", "Log all queries that have taken more than long_query_time seconds " "to execute to file. The argument will be treated as a decimal value " "with microsecond precision", SESSION_VAR(long_query_time_double), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, LONG_TIMEOUT), DEFAULT(10), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_cached_long_query_time)) |
| |
| static Sys_var_bool | Sys_low_priority_updates ("low_priority_updates", "INSERT/DELETE/UPDATE has lower priority than selects", SESSION_VAR(low_priority_updates), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin_no_super), ON_UPDATE(fix_low_prio_updates)) |
| |
| static Sys_var_bool | Sys_lower_case_file_system ("lower_case_file_system", "Case sensitivity of file names on the file system where the " "data directory is located", READ_ONLY NON_PERSIST GLOBAL_VAR(lower_case_file_system), NO_CMD_LINE, DEFAULT(false)) |
| |
| static Sys_var_uint | Sys_lower_case_table_names ("lower_case_table_names", "If set to 1 table names are stored in lowercase on disk and table " "names will be case-insensitive. Should be set to 2 if you are using " "a case insensitive file system", READ_ONLY GLOBAL_VAR(lower_case_table_names), CMD_LINE(OPT_ARG, OPT_LOWER_CASE_TABLE_NAMES), VALID_RANGE(0, 2), DEFAULT(0), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_max_allowed_packet ("max_allowed_packet", "Max packet length to send to or receive from the server", SESSION_VAR(max_allowed_packet), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1024, 1024 *1024 *1024), DEFAULT(64 *1024 *1024), BLOCK_SIZE(1024), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_max_allowed_packet)) |
| |
| static Sys_var_ulong | Sys_replica_max_allowed_packet ("replica_max_allowed_packet", "The maximum size of packets sent from an upstream source server to this " "server.", GLOBAL_VAR(replica_max_allowed_packet), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1024, mysql::binlog::event::max_log_event_size), DEFAULT(mysql::binlog::event::max_log_event_size), BLOCK_SIZE(1024)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_max_allowed_packet ("slave_max_allowed_packet", Sys_replica_max_allowed_packet) |
| |
| static Sys_var_ulonglong | Sys_max_binlog_cache_size ("max_binlog_cache_size", "Sets the total size of the transactional cache", GLOBAL_VAR(max_binlog_cache_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(IO_SIZE, ULLONG_MAX), DEFAULT((ULLONG_MAX/IO_SIZE) *IO_SIZE), BLOCK_SIZE(IO_SIZE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_binlog_cache_size)) |
| |
| static Sys_var_ulonglong | Sys_max_binlog_stmt_cache_size ("max_binlog_stmt_cache_size", "Sets the total size of the statement cache", GLOBAL_VAR(max_binlog_stmt_cache_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(IO_SIZE, ULLONG_MAX), DEFAULT((ULLONG_MAX/IO_SIZE) *IO_SIZE), BLOCK_SIZE(IO_SIZE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_binlog_stmt_cache_size)) |
| |
| static Sys_var_ulong | Sys_max_binlog_size ("max_binlog_size", "Binary log will be rotated automatically when the size exceeds this " "value. Will also apply to relay logs if max_relay_log_size is 0", GLOBAL_VAR(max_binlog_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(IO_SIZE, 1024 *1024L *1024L), DEFAULT(1024 *1024L *1024L), BLOCK_SIZE(IO_SIZE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_max_binlog_size)) |
| |
| static Sys_var_ulong | Sys_max_connections ("max_connections", "The number of simultaneous clients allowed", GLOBAL_VAR(max_connections), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, 100000), DEFAULT(MAX_CONNECTIONS_DEFAULT), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), nullptr, sys_var::PARSE_EARLY) |
| |
| static Sys_var_ulong | Sys_max_connect_errors ("max_connect_errors", "If there is more than this number of interrupted connections from " "a host this host will be blocked from further connections", GLOBAL_VAR(max_connect_errors), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, ULONG_MAX), DEFAULT(100), BLOCK_SIZE(1)) |
| |
| static Sys_var_long | Sys_max_digest_length ("max_digest_length", "Maximum length considered for digest text.", READ_ONLY GLOBAL_VAR(max_digest_length), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024 *1024), DEFAULT(1024), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_max_insert_delayed_threads ("max_insert_delayed_threads", "Don't start more than this number of threads to handle INSERT " "DELAYED statements. If set to zero INSERT DELAYED will be not used. " "This variable is deprecated along with INSERT DELAYED.", SESSION_VAR(max_insert_delayed_threads), NO_CMD_LINE, VALID_RANGE(0, 16384), DEFAULT(20), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_max_delayed_threads), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_ulong | Sys_max_delayed_threads ("max_delayed_threads", "Don't start more than this number of threads to handle INSERT " "DELAYED statements. If set to zero INSERT DELAYED will be not used. " "This variable is deprecated along with INSERT DELAYED.", SESSION_VAR(max_insert_delayed_threads), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 16384), DEFAULT(20), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_max_delayed_threads), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_ulong | Sys_max_error_count ("max_error_count", "Max number of errors/warnings to store for a statement", HINT_UPDATEABLE SESSION_VAR(max_error_count), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 65535), DEFAULT(DEFAULT_ERROR_COUNT), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin_no_super)) |
| |
| static Sys_var_ulonglong | Sys_max_heap_table_size ("max_heap_table_size", "Don't allow creation of heap tables bigger than this", HINT_UPDATEABLE SESSION_VAR(max_heap_table_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(16384,(ulonglong) ~(intptr) 0), DEFAULT(16 *1024 *1024), BLOCK_SIZE(1024)) |
| |
| static Sys_var_uint | Sys_pseudo_thread_id ("pseudo_thread_id", "This variable is for internal server use", SESSION_ONLY(pseudo_thread_id), NO_CMD_LINE, VALID_RANGE(0, UINT_MAX32), DEFAULT(0), BLOCK_SIZE(1), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_session_admin)) |
| |
| static Sys_var_harows | Sys_max_join_size ("max_join_size", "Joins that are probably going to read more than max_join_size " "records return an error", HINT_UPDATEABLE SESSION_VAR(max_join_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, HA_POS_ERROR), DEFAULT(HA_POS_ERROR), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_max_join_size)) |
| |
| static Sys_var_ulong | Sys_max_seeks_for_key ("max_seeks_for_key", "Limit assumed max number of seeks when looking up rows based on a key", HINT_UPDATEABLE SESSION_VAR(max_seeks_for_key), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, ULONG_MAX), DEFAULT(ULONG_MAX), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_max_length_for_sort_data ("max_length_for_sort_data", "This variable is deprecated and will be removed in a future release.", HINT_UPDATEABLE SESSION_VAR(max_length_for_sort_data), CMD_LINE(REQUIRED_ARG), VALID_RANGE(4, 8192 *1024L), DEFAULT(4096), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_ulong | Sys_max_points_in_geometry ("max_points_in_geometry", "Maximum number of points in a geometry", HINT_UPDATEABLE SESSION_VAR(max_points_in_geometry), CMD_LINE(OPT_ARG), VALID_RANGE(3, 1024 *1024L), DEFAULT(64 *1024), BLOCK_SIZE(1)) |
| |
| static PolyLock_mutex PLock_prepared_stmt_count & | LOCK_prepared_stmt_count |
| |
| static Sys_var_ulong | Sys_max_prepared_stmt_count ("max_prepared_stmt_count", "Maximum number of prepared statements in the server", GLOBAL_VAR(max_prepared_stmt_count), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, num_prepared_stmt_limit), DEFAULT(16382), BLOCK_SIZE(1), &PLock_prepared_stmt_count, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), nullptr, sys_var::PARSE_EARLY) |
| |
| static Sys_var_ulong | Sys_max_relay_log_size ("max_relay_log_size", "If non-zero: relay log will be rotated automatically when the " "size exceeds this value; if zero: when the size " "exceeds max_binlog_size", GLOBAL_VAR(max_relay_log_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024L *1024 *1024), DEFAULT(0), BLOCK_SIZE(IO_SIZE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_max_relay_log_size)) |
| |
| static Sys_var_ulong | Sys_max_sort_length ("max_sort_length", "The number of bytes to use when sorting long values with PAD SPACE " "collations (only the first max_sort_length bytes of each value are " "used; the rest are ignored)", HINT_UPDATEABLE SESSION_VAR(max_sort_length), CMD_LINE(REQUIRED_ARG), VALID_RANGE(4, 8192 *1024L), DEFAULT(1024), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_max_sp_recursion_depth ("max_sp_recursion_depth", "Maximum stored procedure recursion depth", SESSION_VAR(max_sp_recursion_depth), CMD_LINE(OPT_ARG), VALID_RANGE(0, 255), DEFAULT(0), BLOCK_SIZE(1)) |
| |
| static Sys_var_max_user_conn | Sys_max_user_connections ("max_user_connections", "The maximum number of active connections for a single user " "(0 = no limit)", SESSION_VAR(max_user_connections), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, UINT_MAX), DEFAULT(0), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(session_readonly)) |
| |
| static Sys_var_ulong | Sys_max_write_lock_count ("max_write_lock_count", "After this many write locks, allow some read locks to run in between", GLOBAL_VAR(max_write_lock_count), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, ULONG_MAX), DEFAULT(ULONG_MAX), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_min_examined_row_limit ("min_examined_row_limit", "Don't write queries to slow log that examine fewer rows " "than that", SESSION_VAR(min_examined_row_limit), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, ULONG_MAX), DEFAULT(0), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin_no_super)) |
| |
| static Sys_var_ulong | Sys_net_buffer_length ("net_buffer_length", "Buffer length for TCP/IP and socket communication", SESSION_VAR(net_buffer_length), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1024, 1024 *1024), DEFAULT(16384), BLOCK_SIZE(1024), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_net_buffer_length)) |
| |
| static Sys_var_ulong | Sys_net_read_timeout ("net_read_timeout", "Number of seconds to wait for more data from a connection before " "aborting the read", SESSION_VAR(net_read_timeout), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, LONG_TIMEOUT), DEFAULT(NET_READ_TIMEOUT), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_net_read_timeout)) |
| |
| static Sys_var_ulong | Sys_net_write_timeout ("net_write_timeout", "Number of seconds to wait for a block to be written to a connection " "before aborting the write", SESSION_VAR(net_write_timeout), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, LONG_TIMEOUT), DEFAULT(NET_WRITE_TIMEOUT), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_net_write_timeout)) |
| |
| static Sys_var_ulong | Sys_net_retry_count ("net_retry_count", "If a read on a communication port is interrupted, retry this " "many times before giving up", SESSION_VAR(net_retry_count), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, ULONG_MAX), DEFAULT(MYSQLD_NET_RETRY_COUNT), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_net_retry_count)) |
| |
| static Sys_var_bool | Sys_old_alter_table ("old_alter_table", "Use old, non-optimized alter table", SESSION_VAR(old_alter_table), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_ulong | Sys_open_files_limit ("open_files_limit", "If this is not 0, then mysqld will use this value to reserve file " "descriptors to use with setrlimit(). If this value is 0 then mysqld " "will reserve max_connections*5 or max_connections + table_open_cache*2 " "(whichever is larger) number of file descriptors", READ_ONLY GLOBAL_VAR(open_files_limit), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, OS_FILE_LIMIT), DEFAULT(0), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), nullptr, sys_var::PARSE_EARLY) |
| |
| static Sys_var_ulong | Sys_optimizer_prune_level ("optimizer_prune_level", "Controls the heuristic(s) applied during query optimization to prune " "less-promising partial plans from the optimizer search space. " "Meaning: 0 - do not apply any heuristic, thus perform exhaustive " "search; 1 - prune plans based on number of retrieved rows", HINT_UPDATEABLE SESSION_VAR(optimizer_prune_level), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1), DEFAULT(1), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_optimizer_search_depth ("optimizer_search_depth", "Maximum depth of search performed by the query optimizer. Values " "larger than the number of relations in a query result in better " "query plans, but take longer to compile a query. Values smaller " "than the number of tables in a relation result in faster " "optimization, but may produce very bad query plans. If set to 0, " "the system will automatically pick a reasonable value", HINT_UPDATEABLE SESSION_VAR(optimizer_search_depth), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, MAX_TABLES+1), DEFAULT(MAX_TABLES+1), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_optimizer_max_subgraph_pairs ("optimizer_max_subgraph_pairs", "Maximum depth of subgraph pairs a query can have before the " "hypergraph join optimizer starts reducing the search space " "heuristically. Larger values may result in better query plans " "for large queries, but also more time and memory spent during planning. " "Increasing this larger than the actual number of subgraph pairs " "in the query will have no further effect. " "Ignored by the old (non-hypergraph) join optimizer", HINT_UPDATEABLE SESSION_VAR(optimizer_max_subgraph_pairs), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, INT_MAX), DEFAULT(100000), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_range_optimizer_max_mem_size ("range_optimizer_max_mem_size", "Maximum amount of memory used by the range optimizer " "to allocate predicates during range analysis. " "The larger the number, more memory may be consumed during " "range analysis. If the value is too low to completed range " "optimization of a query, index range scan will not be " "considered for this query. A value of 0 means range optimizer " "does not have any cap on memory. ", HINT_UPDATEABLE SESSION_VAR(range_optimizer_max_mem_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, ULONG_MAX), DEFAULT(8388608), BLOCK_SIZE(1)) |
| |
| constexpr size_t | max_mem_sz = std::numeric_limits<size_t>::max() |
| |
| static Sys_var_ulonglong | Sys_histogram_generation_max_mem_size ("histogram_generation_max_mem_size", "Maximum amount of memory available for generating histograms", SESSION_VAR(histogram_generation_max_mem_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1000000, max_mem_sz), DEFAULT(20000000), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin), ON_UPDATE(nullptr)) |
| |
| static Sys_var_ulonglong | Sys_parser_max_mem_size ("parser_max_mem_size", "Maximum amount of memory available to the parser", SESSION_VAR(parser_max_mem_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(10 *1000 *1000, max_mem_sz), DEFAULT(max_mem_sz), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(limit_parser_max_mem_size), ON_UPDATE(nullptr)) |
| |
| static const char * | optimizer_switch_names [] |
| |
| static Sys_var_flagset | Sys_optimizer_switch ("optimizer_switch", "optimizer_switch=option=val[,option=val...], where option is one of " "{index_merge, index_merge_union, index_merge_sort_union, " "index_merge_intersection, engine_condition_pushdown, " "index_condition_pushdown, mrr, mrr_cost_based" ", materialization, semijoin, loosescan, firstmatch, duplicateweedout," " subquery_materialization_cost_based, skip_scan," " block_nested_loop, batched_key_access, use_index_extensions," " condition_fanout_filter, derived_merge, hash_join," " subquery_to_derived, prefer_ordering_index," " derived_condition_pushdown, hash_set_operations} and val is one of " "{on, off, default}", HINT_UPDATEABLE SESSION_VAR(optimizer_switch), CMD_LINE(REQUIRED_ARG), optimizer_switch_names, DEFAULT(OPTIMIZER_SWITCH_DEFAULT), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_optimizer_switch), ON_UPDATE(nullptr)) |
| |
| static PolyLock_mutex PLock_global_conn_mem_limit & | LOCK_global_conn_mem_limit |
| |
| static Sys_var_ulonglong | Sys_global_connection_memory_limit ("global_connection_memory_limit", "Maximum amount of memory all connections can consume", GLOBAL_VAR(global_conn_mem_limit), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, max_mem_sz), DEFAULT(max_mem_sz), BLOCK_SIZE(1), &PLock_global_conn_mem_limit, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static Sys_var_ulonglong | Sys_global_connection_memory_status_limit ("global_connection_memory_status_limit", "Global connection memory usage threshold for triggering status update", GLOBAL_VAR(global_conn_memory_status_limit), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, max_mem_sz), DEFAULT(max_mem_sz), BLOCK_SIZE(1), &PLock_global_conn_mem_limit, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static Sys_var_ulonglong | Sys_connection_memory_status_limit ("connection_memory_status_limit", "Maximum amount of memory connection can consume before status update", GLOBAL_VAR(conn_memory_status_limit), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, max_mem_sz), DEFAULT(max_mem_sz), BLOCK_SIZE(1), &PLock_global_conn_mem_limit, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static Sys_var_ulonglong | Sys_connection_memory_limit ("connection_memory_limit", "Maximum amount of memory connection can consume", SESSION_VAR(conn_mem_limit), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, max_mem_sz), DEFAULT(max_mem_sz), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin), ON_UPDATE(nullptr)) |
| |
| static Sys_var_ulong | Sys_connection_memory_chunk_size ("connection_memory_chunk_size", "Chunk size regulating frequency of updating the global memory counter", SESSION_VAR(conn_mem_chunk_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, 1024 *1024 *512), DEFAULT(8192), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin), ON_UPDATE(nullptr)) |
| |
| static Sys_var_bool | Sys_connection_global_memory_tracking ("global_connection_memory_tracking", "Enable updating the global memory counter and checking " "the global connection memory limit exceeding", SESSION_VAR(conn_global_mem_tracking), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin), ON_UPDATE(nullptr)) |
| |
| static Sys_var_bool | Sys_var_end_markers_in_json ("end_markers_in_json", "In JSON output (\"EXPLAIN FORMAT=JSON\" and optimizer trace), " "if variable is set to 1, repeats the structure's key (if it has one) " "near the closing bracket", HINT_UPDATEABLE SESSION_VAR(end_markers_in_json), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_flagset | Sys_optimizer_trace ("optimizer_trace", "Controls tracing of the Optimizer:" " optimizer_trace=option=val[,option=val...], where option is one of" " {enabled, one_line}" " and val is one of {on, default}", SESSION_VAR(optimizer_trace), CMD_LINE(REQUIRED_ARG), Opt_trace_context::flag_names, DEFAULT(Opt_trace_context::FLAG_DEFAULT)) |
| |
| export sys_var * | Sys_optimizer_trace_ptr = &Sys_optimizer_trace |
| |
| static Sys_var_flagset | Sys_optimizer_trace_features ("optimizer_trace_features", "Enables/disables tracing of selected features of the Optimizer:" " optimizer_trace_features=option=val[,option=val...], where option is " "one " "of" " {greedy_search, range_optimizer, dynamic_range, repeated_subselect}" " and val is one of {on, off, default}", SESSION_VAR(optimizer_trace_features), CMD_LINE(REQUIRED_ARG), Opt_trace_context::feature_names, DEFAULT(Opt_trace_context::default_features)) |
| | Note how "misc" is not here: it is not accessible to the user; disabling "misc" would disable the top object, which would make an empty trace. More...
|
| |
| static Sys_var_long | Sys_optimizer_trace_offset ("optimizer_trace_offset", "Offset of first optimizer trace to show; see manual", SESSION_VAR(optimizer_trace_offset), CMD_LINE(REQUIRED_ARG), VALID_RANGE(LONG_MIN, LONG_MAX), DEFAULT(-1), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(optimizer_trace_update)) |
| |
| static Sys_var_long | Sys_optimizer_trace_limit ("optimizer_trace_limit", "Maximum number of shown optimizer traces", SESSION_VAR(optimizer_trace_limit), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, LONG_MAX), DEFAULT(1), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(optimizer_trace_update)) |
| |
| static Sys_var_ulong | Sys_optimizer_trace_max_mem_size ("optimizer_trace_max_mem_size", "Maximum allowed cumulated size of stored optimizer traces", SESSION_VAR(optimizer_trace_max_mem_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, ULONG_MAX), DEFAULT(1024 *1024), BLOCK_SIZE(1)) |
| |
| static Sys_var_charptr | Sys_pid_file ("pid_file", "Pid file used by safe_mysqld", READ_ONLY NON_PERSIST GLOBAL_VAR(pidfile_name_ptr), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(pidfile_name)) |
| |
| static Sys_var_charptr | Sys_plugin_dir ("plugin_dir", "Directory for plugins", READ_ONLY NON_PERSIST GLOBAL_VAR(opt_plugin_dir_ptr), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_uint | Sys_port ("port", "Port number to use for connection or 0 to default to, " "my.cnf, $MYSQL_TCP_PORT, " "/etc/services, " "built-in default (" STRINGIFY_ARG(MYSQL_PORT) "), whatever comes first", READ_ONLY NON_PERSIST GLOBAL_VAR(mysqld_port), CMD_LINE(REQUIRED_ARG, 'P'), VALID_RANGE(0, 65535), DEFAULT(0), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_preload_buff_size ("preload_buffer_size", "The size of the buffer that is allocated when preloading indexes", SESSION_VAR(preload_buff_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1024, 1024 *1024 *1024), DEFAULT(32768), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin_no_super)) |
| |
| static Sys_var_uint | Sys_protocol_version ("protocol_version", "The version of the client/server protocol used by the MySQL server", READ_ONLY NON_PERSIST GLOBAL_VAR(protocol_version), NO_CMD_LINE, VALID_RANGE(0, ~0), DEFAULT(PROTOCOL_VERSION), BLOCK_SIZE(1)) |
| |
| static Sys_var_proxy_user | Sys_proxy_user ("proxy_user", "The proxy user account name used when logging in", IN_SYSTEM_CHARSET) |
| |
| static Sys_var_external_user | Sys_external_user ("external_user", "The external user account used when logging in", IN_SYSTEM_CHARSET) |
| |
| static Sys_var_ulong | Sys_read_buff_size ("read_buffer_size", "Each thread that does a sequential scan allocates a buffer of " "this size for each table it scans. If you do many sequential scans, " "you may want to increase this value", HINT_UPDATEABLE SESSION_VAR(read_buff_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(IO_SIZE *2, INT_MAX32), DEFAULT(128 *1024), BLOCK_SIZE(IO_SIZE)) |
| |
| static Sys_var_bool | Sys_require_secure_transport ("require_secure_transport", "When this option is enabled, connections attempted using insecure " "transport will be rejected. Secure transports are SSL/TLS, " "Unix socket or Shared Memory (on Windows).", GLOBAL_VAR(opt_require_secure_transport), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_require_secure_transport), ON_UPDATE(nullptr)) |
| |
| static Sys_var_bool | Sys_readonly ("read_only", "Make all non-temporary tables read-only, with the exception for " "replication applier threads and users with the SUPER privilege.", GLOBAL_VAR(read_only), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_read_only), ON_UPDATE(fix_read_only)) |
| | The read_only boolean is always equal to the opt_readonly boolean except during fix_read_only(); when that function is entered, opt_readonly is the pre-update value and read_only is the post-update value. More...
|
| |
| static Sys_var_bool | Sys_super_readonly ("super_read_only", "Make all non-temporary tables read-only, with the exception for " "replication applier threads. Users with the SUPER privilege are " "affected, unlike read_only. Setting super_read_only to ON " "also sets read_only to ON.", GLOBAL_VAR(super_read_only), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_super_read_only)) |
| | Setting super_read_only to ON triggers read_only to also be set to ON. More...
|
| |
| static Sys_var_ulong | Sys_read_rnd_buff_size ("read_rnd_buffer_size", "When reading rows in sorted order after a sort, the rows are read " "through this buffer to avoid a disk seeks", HINT_UPDATEABLE SESSION_VAR(read_rnd_buff_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, INT_MAX32), DEFAULT(256 *1024), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_div_precincrement ("div_precision_increment", "Precision of the result of '/' " "operator will be increased on that value", HINT_UPDATEABLE SESSION_VAR(div_precincrement), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, DECIMAL_MAX_SCALE), DEFAULT(4), BLOCK_SIZE(1)) |
| |
| static Sys_var_uint | Sys_eq_range_index_dive_limit ("eq_range_index_dive_limit", "The optimizer will use existing index statistics instead of " "doing index dives for equality ranges if the number of equality " "ranges for the index is larger than or equal to this number. " "If set to 0, index dives are always used.", HINT_UPDATEABLE SESSION_VAR(eq_range_index_dive_limit), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, UINT_MAX32), DEFAULT(200), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_range_alloc_block_size ("range_alloc_block_size", "Allocation block size for storing ranges during optimization", HINT_UPDATEABLE SESSION_VAR(range_alloc_block_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(RANGE_ALLOC_BLOCK_SIZE, UINT32_MAX), DEFAULT(RANGE_ALLOC_BLOCK_SIZE), BLOCK_SIZE(1024)) |
| |
| static Sys_var_ulong | Sys_query_alloc_block_size ("query_alloc_block_size", "Allocation block size for query parsing and execution", SESSION_VAR(query_alloc_block_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1024, UINT_MAX32), DEFAULT(QUERY_ALLOC_BLOCK_SIZE), BLOCK_SIZE(1024), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_thd_mem_root)) |
| |
| static Sys_var_ulong | Sys_query_prealloc_size ("query_prealloc_size", "Persistent buffer for query parsing and execution", SESSION_VAR(query_prealloc_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(QUERY_ALLOC_PREALLOC_SIZE, ULONG_MAX), DEFAULT(QUERY_ALLOC_PREALLOC_SIZE), BLOCK_SIZE(1024), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_bool | Sys_skip_external_locking ("skip_external_locking", "Don't use system (external) locking", READ_ONLY NON_PERSIST GLOBAL_VAR(my_disable_locking), NO_CMD_LINE, DEFAULT(true)) |
| |
| static Sys_var_bool | Sys_skip_networking ("skip_networking", "Don't allow connection with TCP/IP", READ_ONLY NON_PERSIST GLOBAL_VAR(opt_disable_networking), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_bool | Sys_skip_name_resolve ("skip_name_resolve", "Don't resolve hostnames. All hostnames are IP's or 'localhost'.", READ_ONLY GLOBAL_VAR(opt_skip_name_resolve), CMD_LINE(OPT_ARG, OPT_SKIP_RESOLVE), DEFAULT(false)) |
| |
| static Sys_var_bool | Sys_skip_show_database ("skip_show_database", "Don't allow 'SHOW DATABASE' commands", READ_ONLY GLOBAL_VAR(opt_skip_show_db), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_charptr | Sys_socket ("socket", "Socket file to use for connection", READ_ONLY NON_PERSIST GLOBAL_VAR(mysqld_unix_port), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_ulong | Sys_thread_stack ("thread_stack", "The stack size for each thread", READ_ONLY GLOBAL_VAR(my_thread_stack_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(128 *1024, ULONG_MAX), DEFAULT(DEFAULT_THREAD_STACK), BLOCK_SIZE(1024)) |
| |
| static Sys_var_charptr | Sys_tmpdir ("tmpdir", "Path for temporary files. Several paths may " "be specified, separated by a " "colon (:)" ", in this case they are used in a round-robin fashion", READ_ONLY NON_PERSIST GLOBAL_VAR(opt_mysql_tmpdir), CMD_LINE(REQUIRED_ARG, 't'), IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_ulong | Sys_trans_alloc_block_size ("transaction_alloc_block_size", "Allocation block size for transactions to be stored in binary log", SESSION_VAR(trans_alloc_block_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1024, 128 *1024), DEFAULT(QUERY_ALLOC_BLOCK_SIZE), BLOCK_SIZE(1024), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_trans_mem_root)) |
| |
| static Sys_var_ulong | Sys_trans_prealloc_size ("transaction_prealloc_size", "Persistent buffer for transactions to be stored in binary log", SESSION_VAR(trans_prealloc_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1024, 128 *1024), DEFAULT(TRANS_ALLOC_PREALLOC_SIZE), BLOCK_SIZE(1024), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static const char * | thread_handling_names [] |
| |
| static Sys_var_enum | Sys_thread_handling ("thread_handling", "Define threads usage for handling queries, one of " "one-thread-per-connection, no-threads, loaded-dynamically", READ_ONLY GLOBAL_VAR(Connection_handler_manager::thread_handling), CMD_LINE(REQUIRED_ARG), thread_handling_names, DEFAULT(0)) |
| |
| static Sys_var_charptr | Sys_secure_file_priv ("secure_file_priv", "Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files " "within specified directory", READ_ONLY NON_PERSIST GLOBAL_VAR(opt_secure_file_priv), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(DEFAULT_SECURE_FILE_PRIV_DIR)) |
| |
| static Sys_var_ulong | Sys_server_id ("server_id", "Uniquely identifies the server instance in the community of " "replication partners", PERSIST_AS_READONLY GLOBAL_VAR(server_id), CMD_LINE(REQUIRED_ARG, OPT_SERVER_ID), VALID_RANGE(0, UINT_MAX32), DEFAULT(1), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_server_id)) |
| |
| static Sys_var_charptr | Sys_server_uuid ("server_uuid", "Uniquely identifies the server instance in the universe", READ_ONLY NON_PERSIST GLOBAL_VAR(server_uuid_ptr), NO_CMD_LINE, IN_FS_CHARSET, DEFAULT(server_uuid)) |
| |
| static Sys_var_charptr | Sys_server_build_id ("build_id", "A unique Build ID generated by the linker, a 160 bit sha1 signature.", READ_ONLY NON_PERSIST GLOBAL_VAR(server_build_id_ptr), NO_CMD_LINE, IN_FS_CHARSET, DEFAULT(server_build_id)) |
| |
| static Sys_var_uint | Sys_server_id_bits ("server_id_bits", "Set number of significant bits in server-id", GLOBAL_VAR(opt_server_id_bits), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 32), DEFAULT(32), BLOCK_SIZE(1)) |
| |
| static Sys_var_int32 | Sys_regexp_time_limit ("regexp_time_limit", "Timeout for regular expressions matches, in steps of the match " "engine, typically on the order of milliseconds.", GLOBAL_VAR(opt_regexp_time_limit), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, INT32_MAX), DEFAULT(32), BLOCK_SIZE(1)) |
| |
| static Sys_var_int32 | Sys_regexp_stack_limit ("regexp_stack_limit", "Stack size limit for regular expressions matches", GLOBAL_VAR(opt_regexp_stack_limit), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, INT32_MAX), DEFAULT(8000000), BLOCK_SIZE(1)) |
| |
| static Sys_var_bool | Sys_replica_compressed_protocol ("replica_compressed_protocol", "Use compression in the source/replica protocol.", GLOBAL_VAR(opt_replica_compressed_protocol), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_compressed_protocol ("slave_compressed_protocol", Sys_replica_compressed_protocol) |
| |
| static const char * | replica_exec_mode_names [] |
| |
| static Sys_var_enum | Sys_replica_exec_mode ("replica_exec_mode", "Modes for how replication events should be executed. Legal values " "are STRICT (default) and IDEMPOTENT. In IDEMPOTENT mode, " "replication will ignore duplicate key errors and key not found errors. " "In STRICT mode, replication will stop at those errors.", GLOBAL_VAR(replica_exec_mode_options), CMD_LINE(REQUIRED_ARG), replica_exec_mode_names, DEFAULT(RBR_EXEC_MODE_STRICT)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_exec_mode ("slave_exec_mode", Sys_replica_exec_mode) |
| |
| const char * | replica_type_conversions_name [] |
| |
| static Sys_var_set | Sys_replica_type_conversions ("replica_type_conversions", "Set of type conversions that may be used by the replication applier " "thread for row events. Allowed values are:" " ALL_LOSSY to enable lossy conversions," " ALL_NON_LOSSY to enable non-lossy conversions," " ALL_UNSIGNED to treat all integer column type data to be unsigned " "values, and" " ALL_SIGNED to treat all integer column type data to be signed values." " Default treatment is ALL_SIGNED. If ALL_SIGNED and ALL_UNSIGNED both " "are" " specified, ALL_SIGNED will take higher priority than ALL_UNSIGNED." " If the variable is assigned the empty set, no conversions are" " allowed and it is expected that the types match exactly.", GLOBAL_VAR(replica_type_conversions_options), CMD_LINE(REQUIRED_ARG), replica_type_conversions_name, DEFAULT(0)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_type_conversions ("slave_type_conversions", Sys_replica_type_conversions) |
| |
| static Sys_var_bool | Sys_replica_sql_verify_checksum ("replica_sql_verify_checksum", "Force checksum verification of replication events after reading them " "from relay log. Note: The replica always verifies checksums for events " "received from the network, if the event has a checksum at all, before " "it writes the event to the relay log. Enabled by default.", GLOBAL_VAR(opt_replica_sql_verify_checksum), CMD_LINE(OPT_ARG), DEFAULT(true)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_sql_verify_checksum ("slave_sql_verify_checksum", Sys_replica_sql_verify_checksum) |
| |
| static const char * | mts_parallel_type_names [] |
| |
| static Sys_var_enum | Sys_replica_parallel_type ("replica_parallel_type", "The method used by the replication applier to parallelize " "transactions. DATABASE, indicates that it " "may apply transactions in parallel in case they update different " "databases. LOGICAL_CLOCK, which is the default, indicates that it decides " "whether two " "transactions can be applied in parallel using the logical timestamps " "computed by the source.", PERSIST_AS_READONLY GLOBAL_VAR(mts_parallel_option), CMD_LINE(REQUIRED_ARG, OPT_REPLICA_PARALLEL_TYPE), mts_parallel_type_names, DEFAULT(MTS_PARALLEL_TYPE_LOGICAL_CLOCK), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_slave_stopped), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_deprecated_alias | Sys_slave_parallel_type ("slave_parallel_type", Sys_replica_parallel_type) |
| |
| static PolyLock_mutex PLock_slave_trans_dep_tracker & | LOCK_replica_trans_dep_tracker |
| |
| static Sys_var_ulong | Binlog_transaction_dependency_history_size ("binlog_transaction_dependency_history_size", "Maximum number of rows to keep in the writeset history.", ->m_opt_max_history_size) |
| |
| static Sys_var_ulong | CMD_LINE (REQUIRED_ARG, 0) |
| |
| static Sys_var_ulong | VALID_RANGE (1, 1000000) |
| |
| static Sys_var_ulong | DEFAULT (25000) |
| |
| static Sys_var_ulong | BLOCK_SIZE (1) |
| |
| static Sys_var_ulong & | PLock_slave_trans_dep_tracker |
| |
| static Sys_var_ulong | NOT_IN_BINLOG |
| |
| static Sys_var_ulong | ON_CHECK (nullptr) |
| |
| static Sys_var_ulong | ON_UPDATE (nullptr)) |
| |
| static Sys_var_bool | Sys_replica_preserve_commit_order ("replica_preserve_commit_order", "Force replication worker threads to commit in the same order as on the " "source. Enabled by default", PERSIST_AS_READONLY GLOBAL_VAR(opt_replica_preserve_commit_order), CMD_LINE(OPT_ARG, OPT_REPLICA_PRESERVE_COMMIT_ORDER), DEFAULT(true), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_slave_stopped), ON_UPDATE(nullptr)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_preserve_commit_order ("slave_preserve_commit_order", Sys_replica_preserve_commit_order) |
| |
| static Sys_var_enum_binlog_checksum | Binlog_checksum_enum ("binlog_checksum", "Type of BINLOG_CHECKSUM_ALG. Include checksum for " "log events in the binary log. Possible values are NONE and CRC32; " "default is CRC32.", GLOBAL_VAR(binlog_checksum_options), CMD_LINE(REQUIRED_ARG), binlog_checksum_type_names, DEFAULT(mysql::binlog::event::BINLOG_CHECKSUM_ALG_CRC32), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_outside_trx)) |
| |
| static Sys_var_bool | Sys_source_verify_checksum ("source_verify_checksum", "Force checksum verification of events in binary log before " "sending them to replicas or printing them in output of SHOW BINLOG " "EVENTS. " "Disabled by default.", GLOBAL_VAR(opt_source_verify_checksum), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_deprecated_alias | Sys_master_verify_checksum ("master_verify_checksum", Sys_source_verify_checksum) |
| |
| static Sys_var_ulong | Sys_slow_launch_time ("slow_launch_time", "If creating the thread takes longer than this value (in seconds), " "the Slow_launch_threads counter will be incremented", GLOBAL_VAR(slow_launch_time), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, LONG_TIMEOUT), DEFAULT(2), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_sort_buffer ("sort_buffer_size", "Each thread that needs to do a sort allocates a buffer of this size", HINT_UPDATEABLE SESSION_VAR(sortbuff_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(MIN_SORT_MEMORY, ULONG_MAX), DEFAULT(DEFAULT_SORT_MEMORY), BLOCK_SIZE(1)) |
| |
| static const char * | sql_mode_names [] |
| |
| static Sys_var_set | Sys_sql_mode ("sql_mode", "Syntax: sql-mode=mode[,mode[,mode...]]. See the manual for the " "complete list of valid sql modes", HINT_UPDATEABLE SESSION_VAR(sql_mode), CMD_LINE(REQUIRED_ARG), sql_mode_names, DEFAULT(MODE_NO_ENGINE_SUBSTITUTION|MODE_ONLY_FULL_GROUP_BY|MODE_STRICT_TRANS_TABLES|MODE_NO_ZERO_IN_DATE|MODE_NO_ZERO_DATE|MODE_ERROR_FOR_DIVISION_BY_ZERO), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_sql_mode), ON_UPDATE(fix_sql_mode)) |
| |
| static Sys_var_ulong | Sys_max_execution_time ("max_execution_time", "Kill SELECT statement that takes over the specified number of " "milliseconds", HINT_UPDATEABLE SESSION_VAR(max_execution_time), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, ULONG_MAX), DEFAULT(0), BLOCK_SIZE(1)) |
| |
| static const char * | ssl_fips_mode_names [] = {"OFF", "ON", "STRICT", nullptr} |
| |
| static Sys_var_enum | Sys_ssl_fips_mode ("ssl_fips_mode", "SSL FIPS mode (applies only for OpenSSL); " "permitted values are: OFF, ON, STRICT", READ_ONLY GLOBAL_VAR(opt_ssl_fips_mode), CMD_LINE(REQUIRED_ARG), ssl_fips_mode_names, DEFAULT(0), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR(""), sys_var::PARSE_EARLY) |
| |
| static Sys_var_bool | Sys_auto_generate_certs ("auto_generate_certs", "Auto generate SSL certificates at server startup if " "none of the other SSL system variables are specified and " "certificate/key files are not present in data directory.", READ_ONLY NON_PERSIST GLOBAL_VAR(opt_auto_generate_certs), CMD_LINE(OPT_ARG), DEFAULT(true), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), nullptr) |
| |
| static const char * | updatable_views_with_limit_names [] = {"NO", "YES", nullptr} |
| |
| static Sys_var_enum | Sys_updatable_views_with_limit ("updatable_views_with_limit", "YES = Don't issue an error message (warning only) if a VIEW without " "presence of a key of the underlying table is used in queries with a " "LIMIT clause for updating. NO = Prohibit update of a VIEW, which " "does not contain a key of the underlying table and the query uses " "a LIMIT clause (usually get from GUI tools)", HINT_UPDATEABLE SESSION_VAR(updatable_views_with_limit), CMD_LINE(REQUIRED_ARG), updatable_views_with_limit_names, DEFAULT(true)) |
| |
| static Sys_var_system_time_zone | Sys_system_time_zone ("system_time_zone", "The server system time zone") |
| |
| static Sys_var_ulong | Sys_table_def_size ("table_definition_cache", "The number of cached table definitions", GLOBAL_VAR(table_def_size), CMD_LINE(REQUIRED_ARG, OPT_TABLE_DEFINITION_CACHE), VALID_RANGE(TABLE_DEF_CACHE_MIN, 512 *1024), DEFAULT(TABLE_DEF_CACHE_DEFAULT), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), nullptr, sys_var::PARSE_EARLY) |
| |
| static Sys_var_ulong | Sys_schema_def_size ("schema_definition_cache", "The number of cached schema definitions", GLOBAL_VAR(schema_def_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(SCHEMA_DEF_CACHE_MIN, 512 *1024), DEFAULT(SCHEMA_DEF_CACHE_DEFAULT), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_tablespace_def_size ("tablespace_definition_cache", "The number of cached tablespace definitions", GLOBAL_VAR(tablespace_def_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(TABLESPACE_DEF_CACHE_MIN, 512 *1024), DEFAULT(TABLESPACE_DEF_CACHE_DEFAULT), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_stored_program_def_size ("stored_program_definition_cache", "The number of cached stored program definitions", GLOBAL_VAR(stored_program_def_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(STORED_PROGRAM_DEF_CACHE_MIN, 512 *1024), DEFAULT(STORED_PROGRAM_DEF_CACHE_DEFAULT), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_table_cache_size ("table_open_cache", "The number of cached open tables " "(total for all table cache instances)", GLOBAL_VAR(table_cache_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, 512 *1024), DEFAULT(TABLE_OPEN_CACHE_DEFAULT), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_table_cache_size), nullptr, sys_var::PARSE_EARLY) |
| |
| static Sys_var_ulong | Sys_table_cache_instances ("table_open_cache_instances", "The number of table cache instances", READ_ONLY GLOBAL_VAR(table_cache_instances), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, Table_cache_manager::MAX_TABLE_CACHES), DEFAULT(Table_cache_manager::DEFAULT_MAX_TABLE_CACHES), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), nullptr, sys_var::PARSE_EARLY) |
| |
| static Sys_var_ulong | Sys_table_cache_triggers ("table_open_cache_triggers", "The number of cached open tables with fully loaded triggers", GLOBAL_VAR(table_cache_triggers), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, 512 *1024), DEFAULT(512 *1024), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_table_cache_triggers), nullptr, sys_var::PARSE_EARLY) |
| |
| static Sys_var_ulong | Sys_thread_cache_size ("thread_cache_size", "How many threads we should keep in a cache for reuse", GLOBAL_VAR(Per_thread_connection_handler::max_blocked_pthreads), CMD_LINE(REQUIRED_ARG, OPT_THREAD_CACHE_SIZE), VALID_RANGE(0, 16384), DEFAULT(0), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, nullptr, ON_UPDATE(modify_thread_cache_size)) |
| |
| static Sys_var_transaction_isolation | Sys_transaction_isolation ("transaction_isolation", "Default transaction isolation level", UNTRACKED_DEFAULT SESSION_VAR(transaction_isolation), NO_CMD_LINE, tx_isolation_names, DEFAULT(ISO_REPEATABLE_READ), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_transaction_isolation)) |
| |
| static Sys_var_transaction_read_only | Sys_transaction_read_only ("transaction_read_only", "Set default transaction access mode to read only.", UNTRACKED_DEFAULT SESSION_VAR(transaction_read_only), NO_CMD_LINE, DEFAULT(0), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_transaction_read_only)) |
| |
| static Sys_var_ulonglong | Sys_tmp_table_size ("tmp_table_size", "If an internal in-memory temporary table in the MEMORY or TempTable " "storage engine exceeds this size, MySQL will automatically convert it " "to an on-disk table ", HINT_UPDATEABLE SESSION_VAR(tmp_table_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1024, std::numeric_limits< ulonglong >::max()), DEFAULT(16 *1024 *1024), BLOCK_SIZE(1)) |
| |
| static char * | server_version_ptr |
| |
| static Sys_var_version | Sys_version ("version", "Server version", READ_ONLY NON_PERSIST GLOBAL_VAR(server_version_ptr), NO_CMD_LINE, IN_SYSTEM_CHARSET, DEFAULT(server_version)) |
| |
| static char * | server_version_comment_ptr |
| |
| static Sys_var_charptr | Sys_version_comment ("version_comment", "version_comment", READ_ONLY NON_PERSIST GLOBAL_VAR(server_version_comment_ptr), NO_CMD_LINE, IN_SYSTEM_CHARSET, DEFAULT(MYSQL_COMPILATION_COMMENT_SERVER)) |
| |
| static char * | server_version_compile_machine_ptr |
| |
| static Sys_var_charptr | Sys_version_compile_machine ("version_compile_machine", "version_compile_machine", READ_ONLY NON_PERSIST GLOBAL_VAR(server_version_compile_machine_ptr), NO_CMD_LINE, IN_SYSTEM_CHARSET, DEFAULT(MACHINE_TYPE)) |
| |
| static char * | server_version_compile_os_ptr |
| |
| static Sys_var_charptr | Sys_version_compile_os ("version_compile_os", "version_compile_os", READ_ONLY NON_PERSIST GLOBAL_VAR(server_version_compile_os_ptr), NO_CMD_LINE, IN_SYSTEM_CHARSET, DEFAULT(SYSTEM_TYPE)) |
| |
| static const char * | server_version_compile_zlib_ptr = ZLIB_VERSION |
| |
| static Sys_var_charptr | Sys_version_compile_zlib ("version_compile_zlib", "version_compile_zlib", READ_ONLY NON_PERSIST GLOBAL_VAR(server_version_compile_zlib_ptr), NO_CMD_LINE, IN_SYSTEM_CHARSET, DEFAULT(ZLIB_VERSION)) |
| |
| static Sys_var_ulong | Sys_net_wait_timeout ("wait_timeout", "The number of seconds the server waits for activity on a " "connection before closing it", SESSION_VAR(net_wait_timeout), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, IF_WIN(INT_MAX32/1000, LONG_TIMEOUT)), DEFAULT(NET_WAIT_TIMEOUT), BLOCK_SIZE(1)) |
| |
| static Sys_var_plugin | Sys_default_storage_engine ("default_storage_engine", "The default storage engine for new tables", SESSION_VAR(table_plugin), NO_CMD_LINE, MYSQL_STORAGE_ENGINE_PLUGIN, DEFAULT(&default_storage_engine), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_storage_engine)) |
| |
| const char * | internal_tmp_mem_storage_engine_names [] |
| |
| static Sys_var_enum | Sys_internal_tmp_mem_storage_engine ("internal_tmp_mem_storage_engine", "The default storage engine for in-memory internal temporary tables.", HINT_UPDATEABLE SESSION_VAR(internal_tmp_mem_storage_engine), CMD_LINE(REQUIRED_ARG), internal_tmp_mem_storage_engine_names, DEFAULT(TMP_TABLE_TEMPTABLE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin_no_super)) |
| |
| static Sys_var_ulonglong | Sys_temptable_max_ram ("temptable_max_ram", "Maximum amount of memory (in bytes) the TempTable storage engine is " "allowed to allocate from the main memory (RAM) before starting to " "store data on disk.", GLOBAL_VAR(temptable_max_ram), CMD_LINE(REQUIRED_ARG), VALID_RANGE(2<< 20, ULLONG_MAX), DEFAULT(std::clamp(ulonglong{3 *(my_physical_memory()/100)}, 1ULL<< 30, 1ULL<< 32)), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulonglong | Sys_temptable_max_mmap ("temptable_max_mmap", "Maximum amount of memory (in bytes) the TempTable storage engine is " "allowed to allocate from MMAP-backed files before starting to " "store data on disk.", GLOBAL_VAR(temptable_max_mmap), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, ULLONG_MAX), DEFAULT(0), BLOCK_SIZE(1)) |
| |
| static Sys_var_bool | Sys_temptable_use_mmap ("temptable_use_mmap", "Use mmap files for temptables. " "This variable is deprecated and will be removed in a future release.", GLOBAL_VAR(temptable_use_mmap), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_deprecated_with_removal_message), nullptr, sys_var::PARSE_NORMAL) |
| |
| static Sys_var_plugin | Sys_default_tmp_storage_engine ("default_tmp_storage_engine", "The default storage engine for new explicit temporary tables", HINT_UPDATEABLE SESSION_VAR(temp_table_plugin), NO_CMD_LINE, MYSQL_STORAGE_ENGINE_PLUGIN, DEFAULT(&default_tmp_storage_engine), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_storage_engine)) |
| |
| static Sys_var_bit | Sys_autocommit ("autocommit", "autocommit", SESSION_VAR(option_bits), NO_CMD_LINE, OPTION_AUTOCOMMIT, DEFAULT(true), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), PRE_UPDATE(pre_autocommit), ON_UPDATE(fix_autocommit)) |
| |
| export sys_var * | Sys_autocommit_ptr = &Sys_autocommit |
| |
| static Sys_var_bool | Sys_big_tables ("big_tables", "Allow big result sets by saving all " "temporary sets on file (Solves most 'table full' errors)", HINT_UPDATEABLE SESSION_VAR(big_tables), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_bit | Sys_big_selects ("sql_big_selects", "sql_big_selects", HINT_UPDATEABLE SESSION_VAR(option_bits), NO_CMD_LINE, OPTION_BIG_SELECTS, DEFAULT(false)) |
| |
| static Sys_var_bit | Sys_log_off ("sql_log_off", "sql_log_off", SESSION_VAR(option_bits), NO_CMD_LINE, OPTION_LOG_OFF, DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin)) |
| |
| static Sys_var_bool | Sys_log_binlog ("sql_log_bin", "Controls whether logging to the binary log is done", SESSION_ONLY(sql_log_bin), NO_CMD_LINE, DEFAULT(true), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_sql_log_bin), ON_UPDATE(fix_sql_log_bin_after_update)) |
| |
| static Sys_var_bit | Sys_transaction_allow_batching ("transaction_allow_batching", "transaction_allow_batching", SESSION_ONLY(option_bits), NO_CMD_LINE, OPTION_ALLOW_BATCH, DEFAULT(false)) |
| |
| static Sys_var_bit | Sys_sql_warnings ("sql_warnings", "sql_warnings", SESSION_VAR(option_bits), NO_CMD_LINE, OPTION_WARNINGS, DEFAULT(false)) |
| |
| static Sys_var_bit | Sys_sql_notes ("sql_notes", "sql_notes", SESSION_VAR(option_bits), NO_CMD_LINE, OPTION_SQL_NOTES, DEFAULT(true)) |
| |
| static Sys_var_bit | Sys_auto_is_null ("sql_auto_is_null", "sql_auto_is_null", HINT_UPDATEABLE SESSION_VAR(option_bits), NO_CMD_LINE, OPTION_AUTO_IS_NULL, DEFAULT(false), NO_MUTEX_GUARD, IN_BINLOG) |
| |
| static Sys_var_bit | Sys_safe_updates ("sql_safe_updates", "sql_safe_updates", HINT_UPDATEABLE SESSION_VAR(option_bits), NO_CMD_LINE, OPTION_SAFE_UPDATES, DEFAULT(false)) |
| |
| static Sys_var_bit | Sys_buffer_results ("sql_buffer_result", "sql_buffer_result", HINT_UPDATEABLE SESSION_VAR(option_bits), NO_CMD_LINE, OPTION_BUFFER_RESULT, DEFAULT(false)) |
| |
| static Sys_var_bit | Sys_quote_show_create ("sql_quote_show_create", "sql_quote_show_create", SESSION_VAR(option_bits), NO_CMD_LINE, OPTION_QUOTE_SHOW_CREATE, DEFAULT(true)) |
| |
| static Sys_var_bit | Sys_foreign_key_checks ("foreign_key_checks", "foreign_key_checks", HINT_UPDATEABLE SESSION_VAR(option_bits), NO_CMD_LINE, REVERSE(OPTION_NO_FOREIGN_KEY_CHECKS), DEFAULT(true), NO_MUTEX_GUARD, IN_BINLOG) |
| |
| static Sys_var_bit | Sys_unique_checks ("unique_checks", "unique_checks", HINT_UPDATEABLE SESSION_VAR(option_bits), NO_CMD_LINE, REVERSE(OPTION_RELAXED_UNIQUE_CHECKS), DEFAULT(true), NO_MUTEX_GUARD, IN_BINLOG) |
| |
| static Sys_var_bit | Sys_profiling ("profiling", "profiling", SESSION_VAR(option_bits), NO_CMD_LINE, OPTION_PROFILING, DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), PRE_UPDATE(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_ulong | Sys_profiling_history_size ("profiling_history_size", "Limit of query profiling memory", SESSION_VAR(profiling_history_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 100), DEFAULT(15), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_harows | Sys_select_limit ("sql_select_limit", "The maximum number of rows to return from SELECT statements", HINT_UPDATEABLE SESSION_VAR(select_limit), NO_CMD_LINE, VALID_RANGE(0, HA_POS_ERROR), DEFAULT(HA_POS_ERROR), BLOCK_SIZE(1)) |
| |
| static Sys_var_session_special_double | Sys_timestamp ("timestamp", "Set the time for this client", HINT_UPDATEABLE sys_var::ONLY_SESSION, NO_CMD_LINE, VALID_RANGE(0, 0), BLOCK_SIZE(1), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_timestamp), ON_UPDATE(update_timestamp), ON_READ(read_timestamp)) |
| |
| static Sys_var_session_special | Sys_last_insert_id ("last_insert_id", "The value to be returned from LAST_INSERT_ID()", sys_var::ONLY_SESSION, NO_CMD_LINE, VALID_RANGE(0, ULLONG_MAX), BLOCK_SIZE(1), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_last_insert_id), ON_READ(read_last_insert_id)) |
| |
| static Sys_var_session_special | Sys_identity ("identity", "Synonym for the last_insert_id variable", sys_var::ONLY_SESSION, NO_CMD_LINE, VALID_RANGE(0, ULLONG_MAX), BLOCK_SIZE(1), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_last_insert_id), ON_READ(read_last_insert_id)) |
| |
| static Sys_var_session_special | Sys_insert_id ("insert_id", "The value to be used by the following INSERT " "or ALTER TABLE statement when inserting an AUTO_INCREMENT value", HINT_UPDATEABLE sys_var::ONLY_SESSION, NO_CMD_LINE, VALID_RANGE(0, ULLONG_MAX), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_insert_id), ON_READ(read_insert_id)) |
| |
| static Sys_var_session_special | Sys_rand_seed1 ("rand_seed1", "Sets the internal state of the RAND() " "generator for replication purposes", sys_var::ONLY_SESSION, NO_CMD_LINE, VALID_RANGE(0, ULONG_MAX), BLOCK_SIZE(1), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_rand_seed1), ON_READ(read_rand_seed)) |
| |
| static Sys_var_session_special | Sys_rand_seed2 ("rand_seed2", "Sets the internal state of the RAND() " "generator for replication purposes", sys_var::ONLY_SESSION, NO_CMD_LINE, VALID_RANGE(0, ULONG_MAX), BLOCK_SIZE(1), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_rand_seed2), ON_READ(read_rand_seed)) |
| |
| static Sys_var_session_special | Sys_error_count ("error_count", "The number of errors that resulted from the " "last statement that generated messages", READ_ONLY sys_var::ONLY_SESSION, NO_CMD_LINE, VALID_RANGE(0, ULLONG_MAX), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), ON_READ(read_error_count)) |
| |
| static Sys_var_session_special | Sys_warning_count ("warning_count", "The number of errors, warnings, and notes " "that resulted from the last statement that generated messages", READ_ONLY sys_var::ONLY_SESSION, NO_CMD_LINE, VALID_RANGE(0, ULLONG_MAX), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), ON_READ(read_warning_count)) |
| |
| static Sys_var_ulong | Sys_default_week_format ("default_week_format", "The default week format used by WEEK() functions", SESSION_VAR(default_week_format), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 7), DEFAULT(0), BLOCK_SIZE(1)) |
| |
| static Sys_var_ulong | Sys_group_concat_max_len ("group_concat_max_len", "The maximum length of the result of function GROUP_CONCAT()", HINT_UPDATEABLE SESSION_VAR(group_concat_max_len), CMD_LINE(REQUIRED_ARG), VALID_RANGE(4, ULONG_MAX), DEFAULT(1024), BLOCK_SIZE(1)) |
| |
| static char * | glob_hostname_ptr |
| |
| static Sys_var_charptr | Sys_hostname ("hostname", "Server host name", READ_ONLY NON_PERSIST GLOBAL_VAR(glob_hostname_ptr), NO_CMD_LINE, IN_FS_CHARSET, DEFAULT(glob_hostname)) |
| |
| static Sys_var_charptr | Sys_repl_report_host ("report_host", "Hostname or IP that this replica will report to the source while " "initiating the replication connection. Will appear in the output of " "SHOW REPLICAS. Leave this unset if you do not want the replica to " "register itself with the source. Note that it is not sufficient for " "the source to simply read the IP of the replica off the socket once the " "replica connects: in the presence of NAT other routing features, that IP " "may not be valid for connecting to the replica from the source or other " "hosts.", READ_ONLY GLOBAL_VAR(report_host), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_charptr | Sys_repl_report_user ("report_user", "The account user name that this replica will report to the source " "while initiating the replication connection.", READ_ONLY GLOBAL_VAR(report_user), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_charptr | Sys_repl_report_password ("report_password", "The account password that this replica will report to the source " "while initiating the replication connection.", READ_ONLY GLOBAL_VAR(report_password), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_uint | Sys_repl_report_port ("report_port", "The port for connecting to the replica, which this replica will report " "to the source while initiating the replication connection. " "Set it only if the replica is listening on a non-default " "port or if you have a special tunnel from the source or other clients " "to this replica. If not sure, leave this option unset.", READ_ONLY GLOBAL_VAR(report_port), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 65535), DEFAULT(0), BLOCK_SIZE(1)) |
| |
| static Sys_var_bool | Sys_keep_files_on_create ("keep_files_on_create", "Don't overwrite stale .MYD and .MYI even if no directory is specified", SESSION_VAR(keep_files_on_create), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static char * | license |
| |
| static Sys_var_charptr | Sys_license ("license", "The type of license the server has", READ_ONLY NON_PERSIST GLOBAL_VAR(license), NO_CMD_LINE, IN_SYSTEM_CHARSET, DEFAULT(STRINGIFY_ARG(LICENSE))) |
| |
| static Sys_var_charptr | Sys_general_log_path ("general_log_file", "Log connections and queries to given file", GLOBAL_VAR(opt_general_logname), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(nullptr), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_log_path), ON_UPDATE(fix_general_log_file)) |
| |
| static Sys_var_charptr | Sys_slow_log_path ("slow_query_log_file", "Log slow queries to given log file. " "Defaults logging to hostname-slow.log. Must be enabled to activate " "other slow log options", GLOBAL_VAR(opt_slow_logname), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(nullptr), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_log_path), ON_UPDATE(fix_slow_log_file)) |
| |
| static Sys_var_have | Sys_have_compress ("have_compress", "have_compress", READ_ONLY NON_PERSIST GLOBAL_VAR(have_compress), NO_CMD_LINE) |
| |
| static Sys_var_have | Sys_have_dlopen ("have_dynamic_loading", "have_dynamic_loading", READ_ONLY NON_PERSIST GLOBAL_VAR(have_dlopen), NO_CMD_LINE) |
| |
| static Sys_var_have | Sys_have_geometry ("have_geometry", "have_geometry", READ_ONLY NON_PERSIST GLOBAL_VAR(have_geometry), NO_CMD_LINE) |
| |
| enum SHOW_COMP_OPTION | Sys_var_have_func |
| |
| static Sys_var_have | Sys_have_profiling ("have_profiling", "have_profiling", READ_ONLY NON_PERSIST GLOBAL_VAR(have_profiling), NO_CMD_LINE, NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_have | Sys_have_query_cache ("have_query_cache", "have_query_cache. " "This variable is deprecated and will be removed in a future release.", READ_ONLY NON_PERSIST GLOBAL_VAR(have_query_cache), NO_CMD_LINE, NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_have | Sys_have_rtree_keys ("have_rtree_keys", "have_rtree_keys", READ_ONLY NON_PERSIST GLOBAL_VAR(have_rtree_keys), NO_CMD_LINE) |
| |
| static Sys_var_have | Sys_have_symlink ("have_symlink", "have_symlink", READ_ONLY NON_PERSIST GLOBAL_VAR(have_symlink), NO_CMD_LINE) |
| |
| static Sys_var_have | Sys_have_statement_timeout ("have_statement_timeout", "have_statement_timeout", READ_ONLY NON_PERSIST GLOBAL_VAR(have_statement_timeout), NO_CMD_LINE) |
| |
| static Sys_var_bool | Sys_general_log ("general_log", "Log connections and queries to a table or log file. " "Defaults to logging to a file hostname.log, " "or if --log-output=TABLE is used, to a table mysql.general_log.", GLOBAL_VAR(opt_general_log), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_general_log_state)) |
| |
| static Sys_var_bool | Sys_log_raw ("log_raw", "Log to general log before any rewriting of the query. For use in " "debugging, not production as sensitive information may be logged.", GLOBAL_VAR(opt_general_log_raw), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG) |
| |
| static Sys_var_bool | Sys_slow_query_log ("slow_query_log", "Log slow queries to a table or log file. Defaults logging to a file " "hostname-slow.log or a table mysql.slow_log if --log-output=TABLE is " "used. Must be enabled to activate other slow log options", GLOBAL_VAR(opt_slow_log), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_slow_log_state)) |
| |
| static Sys_var_bool | Sys_slow_log_extra ("log_slow_extra", "Print more attributes to the slow query log file. Has no effect on " "logging to table.", GLOBAL_VAR(opt_log_slow_extra), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_slow_log_extra), ON_UPDATE(nullptr)) |
| |
| static const char * | log_output_names [] = {"NONE", "FILE", "TABLE", nullptr} |
| |
| static Sys_var_set | Sys_log_output ("log_output", "Syntax: log-output=value[,value...], " "where \"value\" could be TABLE, FILE or NONE", GLOBAL_VAR(log_output_options), CMD_LINE(REQUIRED_ARG), log_output_names, DEFAULT(LOG_FILE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_not_empty_set), ON_UPDATE(fix_log_output)) |
| |
| static Sys_var_bool | Sys_log_replica_updates ("log_replica_updates", "If enabled, the replication applier threads will write to this server's " "binary log.", READ_ONLY GLOBAL_VAR(opt_log_replica_updates), CMD_LINE(OPT_ARG, OPT_LOG_REPLICA_UPDATES), DEFAULT(1)) |
| |
| static Sys_var_deprecated_alias | Sys_log_slave_updates ("log_slave_updates", Sys_log_replica_updates) |
| |
| static Sys_var_charptr | Sys_relay_log ("relay_log", "The location and name to use for relay logs", READ_ONLY NON_PERSIST GLOBAL_VAR(opt_relay_logname), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_charptr | Sys_relay_log_index ("relay_log_index", "The location and name to use for the file " "that keeps a list of the last relay logs", READ_ONLY NON_PERSIST GLOBAL_VAR(relay_log_index), NO_CMD_LINE, IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_charptr | Sys_binlog_index ("log_bin_index", "File that holds the names for last binary log files.", READ_ONLY NON_PERSIST GLOBAL_VAR(log_bin_index), NO_CMD_LINE, IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_charptr | Sys_relay_log_basename ("relay_log_basename", "The full path of the relay log file names, excluding the extension.", READ_ONLY NON_PERSIST GLOBAL_VAR(relay_log_basename), NO_CMD_LINE, IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_charptr | Sys_log_bin_basename ("log_bin_basename", "The full path of the binary log file names, excluding the extension.", READ_ONLY NON_PERSIST GLOBAL_VAR(log_bin_basename), NO_CMD_LINE, IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_bool | Sys_relay_log_purge ("relay_log_purge", "if disabled - do not purge relay logs. " "if enabled - purge them as soon as they are no more needed", GLOBAL_VAR(relay_log_purge), CMD_LINE(OPT_ARG), DEFAULT(true)) |
| |
| static Sys_var_bool | Sys_relay_log_recovery ("relay_log_recovery", "If enabled, existing relay logs will be skipped by the " "replication threads. The receiver will start a new relay " "log and the applier will start reading from the beginning of that file. " "The receiver's position relative to the source will be reset to the " "applier's " "position relative to the source; the receiver uses this in case " "SOURCE_AUTO_POSITION=0.", READ_ONLY GLOBAL_VAR(relay_log_recovery), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_ulong | Sys_rpl_read_size ("rpl_read_size", "The size for reads done from the binlog and relay log. " "It must be a multiple of 4kb. Making it larger might help with IO " "stalls while reading these files when they are not in the OS buffer " "cache", GLOBAL_VAR(rpl_read_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(IO_SIZE *2, ULONG_MAX), DEFAULT(IO_SIZE *2), BLOCK_SIZE(IO_SIZE)) |
| |
| static Sys_var_bool | Sys_replica_allow_batching ("replica_allow_batching", "Allow this replica to batch requests when " "using the NDB storage engine.", GLOBAL_VAR(opt_replica_allow_batching), CMD_LINE(OPT_ARG), DEFAULT(true)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_allow_batching ("slave_allow_batching", Sys_replica_allow_batching) |
| |
| static Sys_var_charptr | Sys_replica_load_tmpdir ("replica_load_tmpdir", "The location where this replica will store temporary files when " "replicating a LOAD DATA INFILE command from a source having " "binlog_format=STATEMENT.", READ_ONLY NON_PERSIST GLOBAL_VAR(replica_load_tmpdir), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_load_tmpdir ("slave_load_tmpdir", Sys_replica_load_tmpdir) |
| |
| static PolyLock_mutex PLock_replica_net_timeout & | LOCK_replica_net_timeout |
| |
| static Sys_var_uint | Sys_replica_net_timeout ("replica_net_timeout", "Number of seconds to wait for more data " "from a replication connection before aborting the read.", GLOBAL_VAR(replica_net_timeout), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, LONG_TIMEOUT), DEFAULT(REPLICA_NET_TIMEOUT), BLOCK_SIZE(1), &PLock_replica_net_timeout, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_replica_net_timeout)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_net_timeout ("slave_net_timeout", Sys_replica_net_timeout) |
| |
| static PolyLock_mutex PLock_sql_replica_skip_counter & | LOCK_sql_replica_skip_counter |
| |
| static Sys_var_uint | Sys_sql_replica_skip_counter ("sql_replica_skip_counter", "sql_replica_skip_counter", GLOBAL_VAR(sql_replica_skip_counter), NO_CMD_LINE, VALID_RANGE(0, UINT_MAX), DEFAULT(0), BLOCK_SIZE(1), &PLock_sql_replica_skip_counter, NOT_IN_BINLOG, ON_CHECK(check_slave_skip_counter)) |
| |
| static Sys_var_deprecated_alias | Sys_sql_slave_skip_counter ("sql_slave_skip_counter", Sys_sql_replica_skip_counter) |
| |
| static Sys_var_charptr | Sys_replica_skip_errors ("replica_skip_errors", "Comma-separated list of error numbers. If an applier thread on this " "replica encounters one of these errors while applying a Query_log_event, " "it will ignore the error, rather than stop.", READ_ONLY GLOBAL_VAR(opt_replica_skip_errors), CMD_LINE(REQUIRED_ARG), IN_SYSTEM_CHARSET, DEFAULT(nullptr)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_skip_errors ("slave_skip_errors", Sys_replica_skip_errors) |
| |
| static Sys_var_ulonglong | Sys_relay_log_space_limit ("relay_log_space_limit", "Maximum space to use for all relay logs", READ_ONLY GLOBAL_VAR(relay_log_space_limit), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, ULLONG_MAX), DEFAULT(0), BLOCK_SIZE(1)) |
| |
| static Sys_var_uint | Sys_sync_relaylog_period ("sync_relay_log", "Synchronously flush relay log to disk after " "every #th event. Use 0 to disable synchronous flushing", GLOBAL_VAR(sync_relaylog_period), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, UINT_MAX), DEFAULT(10000), BLOCK_SIZE(1)) |
| |
| static Sys_var_uint | Sys_sync_relayloginfo_period ("sync_relay_log_info", "Synchronously flush relay log info " "to disk after every #th transaction. Use 0 to disable " "synchronous flushing. This variable is deprecated and will be removed in " "a future version.", GLOBAL_VAR(sync_relayloginfo_period), CMD_LINE(REQUIRED_ARG, OPT_SYNC_RELAY_LOG_INFO), VALID_RANGE(0, UINT_MAX), DEFAULT(10000), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_uint | Sys_replica_checkpoint_period ("replica_checkpoint_period", "Applier worker threads progress status is updated periodically. " "This option specifies the maximum number of milliseconds between " "updates.", GLOBAL_VAR(opt_mta_checkpoint_period), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, UINT_MAX), DEFAULT(300), BLOCK_SIZE(1)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_checkpoint_period ("slave_checkpoint_period", Sys_replica_checkpoint_period) |
| |
| static Sys_var_uint | Sys_replica_checkpoint_group ("replica_checkpoint_group", "Applier worker threads progress status is updated periodically. " "This option specifies the maximum number of committed transactions " "between updates.", GLOBAL_VAR(opt_mta_checkpoint_group), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, MTS_MAX_BITS_IN_GROUP), DEFAULT(512), BLOCK_SIZE(1)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_checkpoint_group ("slave_checkpoint_group", Sys_replica_checkpoint_group) |
| |
| static Sys_var_uint | Sys_sync_binlog_period ("sync_binlog", "Synchronously flush binary log to disk after" " every #th write to the file. Use 0 to disable synchronous" " flushing", GLOBAL_VAR(sync_binlog_period), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, UINT_MAX), DEFAULT(1), BLOCK_SIZE(1)) |
| |
| static Sys_var_uint | Sys_sync_source_info ("sync_source_info", "Synchronize replication receiver positions to disk periodically, after " "the specified number of events. Use 0 to disable periodic " "synchronization.", GLOBAL_VAR(sync_masterinfo_period), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, UINT_MAX), DEFAULT(10000), BLOCK_SIZE(1)) |
| |
| static Sys_var_deprecated_alias | Sys_sync_master_info ("sync_master_info", Sys_sync_source_info) |
| |
| static Sys_var_ulonglong | Sys_var_original_commit_timestamp ("original_commit_timestamp", "The time when the current transaction was committed on the originating " "source, measured in microseconds since 1970 (the \"epoch\").", SESSION_ONLY(original_commit_timestamp), NO_CMD_LINE, VALID_RANGE(0, MAX_COMMIT_TIMESTAMP_VALUE), DEFAULT(MAX_COMMIT_TIMESTAMP_VALUE), BLOCK_SIZE(1), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_session_admin_or_replication_applier)) |
| |
| static Sys_var_ulong | Sys_replica_transaction_retries ("replica_transaction_retries", "Number of times the replication applier will retry a transaction in " "case it failed with a deadlock or other transient error, before it gives " "up and stops.", GLOBAL_VAR(slave_trans_retries), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, ULONG_MAX), DEFAULT(10), BLOCK_SIZE(1)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_transaction_retries ("slave_transaction_retries", Sys_replica_transaction_retries) |
| |
| static Sys_var_ulong | Sys_replica_parallel_workers ("replica_parallel_workers", "Number of worker threads applying changes in parallel ", PERSIST_AS_READONLY GLOBAL_VAR(opt_mts_replica_parallel_workers), CMD_LINE(REQUIRED_ARG, OPT_REPLICA_PARALLEL_WORKERS), VALID_RANGE(1, MTS_MAX_WORKERS), DEFAULT(4), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_parallel_workers ("slave_parallel_workers", Sys_replica_parallel_workers) |
| |
| static Sys_var_ulonglong | Sys_replica_pending_jobs_size_max ("replica_pending_jobs_size_max", "Soft limit on the size, in bytes, of per-worker queues of events that " "have not yet been applied. The queue size may exceed this limit in case " "a single event is bigger than the limit.", GLOBAL_VAR(opt_mts_pending_jobs_size_max), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1024,(ulonglong) ~(intptr) 0), DEFAULT(128 *1024 *1024), BLOCK_SIZE(1024), ON_CHECK(nullptr)) |
| |
| static Sys_var_deprecated_alias | Sys_slave_pending_jobs_size_max ("slave_pending_jobs_size_max", Sys_replica_pending_jobs_size_max) |
| |
| static Sys_var_struct< MY_LOCALE, Get_locale_name > | Sys_lc_messages ("lc_messages", "Set the language used for the error messages", SESSION_VAR(lc_messages), NO_CMD_LINE, DEFAULT(&my_default_lc_messages), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_locale)) |
| |
| static Sys_var_struct< MY_LOCALE, Get_locale_name > | Sys_lc_time_names ("lc_time_names", "Set the language used for the month " "names and the days of the week", SESSION_VAR(lc_time_names), NO_CMD_LINE, DEFAULT(&my_default_lc_time_names), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_locale)) |
| |
| static Sys_var_tz | Sys_time_zone ("time_zone", "time_zone", HINT_UPDATEABLE SESSION_VAR(time_zone), NO_CMD_LINE, DEFAULT(&default_tz), NO_MUTEX_GUARD, IN_BINLOG) |
| |
| static Sys_var_uint | Sys_host_cache_size ("host_cache_size", "How many host names should be cached to avoid resolving.", GLOBAL_VAR(host_cache_size), CMD_LINE(REQUIRED_ARG, OPT_HOST_CACHE_SIZE), VALID_RANGE(0, 65536), DEFAULT(HOST_CACHE_SIZE), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(fix_host_cache_size)) |
| |
| const Sys_var_multi_enum::ALIAS | enforce_gtid_consistency_aliases [] |
| |
| static Sys_var_enforce_gtid_consistency | Sys_enforce_gtid_consistency ("enforce_gtid_consistency", "Prevents execution of statements that would be impossible to log " "in a transactionally safe manner. Currently, the disallowed " "statements include CREATE TEMPORARY TABLE inside transactions, " "all updates to non-transactional tables, and CREATE TABLE ... SELECT.", PERSIST_AS_READONLY GLOBAL_VAR(_gtid_consistency_mode), CMD_LINE(OPT_ARG, OPT_ENFORCE_GTID_CONSISTENCY), enforce_gtid_consistency_aliases, 3, DEFAULT(3), DEFAULT(GTID_CONSISTENCY_MODE_ON), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin_outside_trx_outside_sf_outside_sp)) |
| |
| static Sys_var_bool | Sys_binlog_gtid_simple_recovery ("binlog_gtid_simple_recovery", "If this option is enabled, the server does not open more than " "two binary logs when initializing GTID_PURGED and " "GTID_EXECUTED, either during server restart or when binary " "logs are being purged. Enabling this option is useful when " "the server has already generated many binary logs without " "GTID events (e.g., having GTID_MODE = OFF). Note: If this " "option is enabled, GLOBAL.GTID_EXECUTED and " "GLOBAL.GTID_PURGED may be initialized wrongly in two cases: " "(1) All binary logs were generated by MySQL 5.7.5 or older, " "and GTID_MODE was ON for some binary logs but OFF for the " "newest binary log. (2) The oldest existing binary log was " "generated by MySQL 5.7.5 or older, and SET GTID_PURGED was " "issued after the oldest binary log was generated. If a wrong " "set is computed in one of case (1) or case (2), it will " "remain wrong even if the server is later restarted with this " "option disabled.", READ_ONLY GLOBAL_VAR(binlog_gtid_simple_recovery), CMD_LINE(OPT_ARG), DEFAULT(true)) |
| |
| static Sys_var_ulong | Sys_sp_cache_size ("stored_program_cache", "The soft upper limit for number of cached stored routines for " "one connection.", GLOBAL_VAR(stored_program_cache_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(16, 512 *1024), DEFAULT(256), BLOCK_SIZE(1)) |
| |
| static Sys_var_bool | Sys_pseudo_replica_mode ("pseudo_replica_mode", "Internal variable that will be enabled while applying a " "Format_description_log_event encoded in a BINLOG statement printed " "by mysqlbinlog.", SESSION_ONLY(pseudo_replica_mode), NO_CMD_LINE, DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_pseudo_replica_mode)) |
| |
| static Sys_var_deprecated_alias | Sys_pseudo_slave_mode ("pseudo_slave_mode", Sys_pseudo_replica_mode) |
| |
| static Sys_var_gtid_next | Sys_gtid_next ("gtid_next", "Specifies the Global Transaction Identifier for the following " "transaction.", SESSION_ONLY(gtid_next), NO_CMD_LINE, DEFAULT("AUTOMATIC"), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_gtid_next)) |
| |
| export sys_var * | Sys_gtid_next_ptr = &Sys_gtid_next |
| |
| static Sys_var_gtid_executed | Sys_gtid_executed ("gtid_executed", "The global variable contains the set of GTIDs in the " "binary log. The session variable contains the set of GTIDs " "in the current, ongoing transaction.") |
| |
| Gtid_set * | gtid_purged |
| |
| static Sys_var_gtid_purged | Sys_gtid_purged ("gtid_purged", "The set of GTIDs that existed in previous, purged binary logs.", NON_PERSIST GLOBAL_VAR(gtid_purged), NO_CMD_LINE, DEFAULT(nullptr), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_gtid_purged)) |
| |
| export sys_var * | Sys_gtid_purged_ptr = &Sys_gtid_purged |
| |
| static Sys_var_gtid_owned | Sys_gtid_owned ("gtid_owned", "The global variable lists all GTIDs owned by all threads. " "The session variable lists all GTIDs owned by the current thread.") |
| |
| static Sys_var_gtid_mode | Sys_gtid_mode ("gtid_mode", "Controls whether Global Transaction Identifiers (GTIDs) are " "enabled. Can be OFF, OFF_PERMISSIVE, ON_PERMISSIVE, or ON. OFF " "means that no transaction has a GTID. OFF_PERMISSIVE means that " "new transactions (committed in a client session using " "GTID_NEXT='AUTOMATIC') are not assigned any GTID, and " "replicated transactions are allowed to have or not have a " "GTID. ON_PERMISSIVE means that new transactions are assigned a " "GTID, and replicated transactions are allowed to have or not " "have a GTID. ON means that all transactions have a GTID. " "ON is required on a source before any replica can use " "SOURCE_AUTO_POSITION=1. To safely switch from OFF to ON, first " "set all servers to OFF_PERMISSIVE, then set all servers to " "ON_PERMISSIVE, then wait for all transactions without a GTID to " "be replicated and executed on all servers, and finally set all " "servers to GTID_MODE = ON.", PERSIST_AS_READONLY GLOBAL_VAR(Gtid_mode::sysvar_mode), CMD_LINE(REQUIRED_ARG), Gtid_mode::names, DEFAULT(Gtid_mode::DEFAULT), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin_outside_trx_outside_sf_outside_sp)) |
| |
| static Sys_var_uint | Sys_gtid_executed_compression_period ("gtid_executed_compression_period", "Compress the mysql.gtid_executed table whenever this number of " "transactions have been added, by waking up a foreground thread " "(compress_gtid_table). This compression method only operates when " "binary logging is disabled on the replica; if binary logging is " "enabled, the table is compressed every time the binary log is " "rotated, and this value is ignored. Before MySQL 8.0.23, the " "default is 1000, and from MySQL 8.0.23, the default is zero, which " "disables this compression method. This is because in releases from " "MySQL 8.0.17, InnoDB transactions are written to the " "mysql.gtid_executed table by a separate process to non-InnoDB " "transactions. If the server has a mix of InnoDB and non-InnoDB " "transactions, attempting to compress the table with the " "compress_gtid_table thread can slow this process, so from " "MySQL 8.0.17 it is recommended that you set " "gtid_executed_compression_period to 0.", GLOBAL_VAR(gtid_executed_compression_period), CMD_LINE(OPT_ARG), VALID_RANGE(0, UINT_MAX32), DEFAULT(0), BLOCK_SIZE(1)) |
| |
| static Sys_var_bool | Sys_disconnect_on_expired_password ("disconnect_on_expired_password", "Give clients that don't signal password expiration support execution " "time " "error(s) instead of connection error", READ_ONLY GLOBAL_VAR(disconnect_on_expired_password), CMD_LINE(OPT_ARG), DEFAULT(true)) |
| |
| static Sys_var_bool | Sys_validate_user_plugins ("validate_user_plugins", "Turns on additional validation of authentication plugins assigned " "to user accounts. ", READ_ONLY NOT_VISIBLE GLOBAL_VAR(validate_user_plugins), CMD_LINE(OPT_ARG), DEFAULT(true), NO_MUTEX_GUARD, NOT_IN_BINLOG) |
| |
| static Sys_var_enum | Sys_block_encryption_mode ("block_encryption_mode", "mode for AES_ENCRYPT/AES_DECRYPT", SESSION_VAR(my_aes_mode), CMD_LINE(REQUIRED_ARG), my_aes_opmode_names, DEFAULT(my_aes_128_ecb)) |
| |
| static Sys_var_charptr | Sys_track_session_sys_vars ("session_track_system_variables", "Track changes in registered system variables.", SESSION_VAR(track_sysvars_ptr), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT("time_zone,autocommit,character_set_client,character_set_results," "character_set_connection"), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_track_session_sys_vars), ON_UPDATE(update_track_session_sys_vars)) |
| |
| export sys_var * | Sys_track_session_sys_vars_ptr = &Sys_track_session_sys_vars |
| |
| static Sys_var_bool | Sys_session_track_schema ("session_track_schema", "Track changes to the 'default schema'.", SESSION_VAR(session_track_schema), CMD_LINE(OPT_ARG), DEFAULT(true), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_session_track_schema)) |
| |
| static const char * | session_track_transaction_info_names [] |
| |
| static Sys_var_enum | Sys_session_track_transaction_info ("session_track_transaction_info", "Track changes to the transaction attributes. OFF to disable; " "STATE to track just transaction state (Is there an active transaction? " "Does it have any data? etc.); CHARACTERISTICS to track transaction " "state " "and report all statements needed to start a transaction with the same " "characteristics (isolation level, read only/read write, snapshot - " "but not any work done / data modified within the transaction).", SESSION_VAR(session_track_transaction_info), CMD_LINE(REQUIRED_ARG), session_track_transaction_info_names, DEFAULT(TX_TRACK_NONE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_session_track_tx_info)) |
| |
| static Sys_var_bool | Sys_session_track_state_change ("session_track_state_change", "Track changes to the 'session state'.", SESSION_VAR(session_track_state_change), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(update_session_track_state_change)) |
| |
| static Sys_var_bool | Sys_offline_mode ("offline_mode", "Make the server into offline mode", GLOBAL_VAR(offline_mode), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_offline_mode), ON_UPDATE(handle_offline_mode)) |
| |
| static Sys_var_charptr | Sys_disabled_storage_engines ("disabled_storage_engines", "Limit CREATE TABLE for the storage engines listed", READ_ONLY GLOBAL_VAR(opt_disabled_storage_engines), CMD_LINE(REQUIRED_ARG), IN_SYSTEM_CHARSET, DEFAULT("")) |
| |
| static PolyLock_mutex PLock_sys_mandatory_roles & | LOCK_mandatory_roles |
| |
| static Sys_var_lexstring | Sys_mandatory_roles ("mandatory_roles", "All the specified roles are always considered granted to every user and " "they" " can't be revoked. Mandatory roles still require activation unless they " "are made into " "default roles. The granted roles will not be visible in the " "mysql.role_edges" " table.", GLOBAL_VAR(opt_mandatory_roles), CMD_LINE(REQUIRED_ARG), IN_SYSTEM_CHARSET, DEFAULT(""), &PLock_sys_mandatory_roles, NOT_IN_BINLOG, ON_CHECK(sysvar_check_authid_string), ON_UPDATE(sysvar_update_mandatory_roles)) |
| |
| static Sys_var_bool | Sys_always_activate_granted_roles ("activate_all_roles_on_login", "Automatically set all granted roles as active after the user has " "authenticated successfully.", GLOBAL_VAR(opt_always_activate_granted_roles), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static PolyLock_mutex plock_sys_password_history & | LOCK_password_history |
| |
| static Sys_var_uint | Sys_password_history ("password_history", "The number of old passwords to check in the history." " Set to 0 (the default) to turn the checks off", GLOBAL_VAR(global_password_history), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, UINT_MAX32), DEFAULT(0), BLOCK_SIZE(1), &plock_sys_password_history) |
| |
| static PolyLock_mutex plock_sys_password_reuse_interval & | LOCK_password_reuse_interval |
| |
| static Sys_var_uint | Sys_password_reuse_interval ("password_reuse_interval", "The minimum number of days that need to pass before a password can " "be reused. Set to 0 (the default) to turn the checks off", GLOBAL_VAR(global_password_reuse_interval), CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, UINT_MAX32), DEFAULT(0), BLOCK_SIZE(1), &plock_sys_password_reuse_interval) |
| |
| static const char * | resultset_metadata_names [] = {"NONE", "FULL", NullS} |
| |
| static Sys_var_enum | Sys_resultset_metadata ("resultset_metadata", "Controls what meatadata the server will send to the client: " "either FULL (default) for all metadata, NONE for no metadata.", SESSION_ONLY(resultset_metadata), NO_CMD_LINE, resultset_metadata_names, DEFAULT(static_cast< ulong >(RESULTSET_METADATA_FULL)), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_resultset_metadata), ON_UPDATE(nullptr)) |
| |
| const char * | binlog_row_value_options_names [] = {"PARTIAL_JSON", nullptr} |
| |
| static Sys_var_set | Sys_binlog_row_value_options ("binlog_row_value_options", "When set to PARTIAL_JSON, this option enables a space-efficient " "row-based binary log format for UPDATE statements that modify a " "JSON value using only the functions JSON_SET, JSON_REPLACE, and " "JSON_REMOVE. For such updates, only the modified parts of the " "JSON document are included in the binary log, so small changes of " "big documents may need significantly less space.", SESSION_VAR(binlog_row_value_options), CMD_LINE(REQUIRED_ARG), binlog_row_value_options_names, DEFAULT(0), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_binlog_row_value_options)) |
| |
| static PolyLock_mutex PLock_keyring_operations & | LOCK_keyring_operations |
| | This is a mutex used to protect global variable @keyring_operations. More...
|
| |
| static Sys_var_bool | Sys_keyring_operations ("keyring_operations", "This variable provides access to keyring service APIs. When this " "option is disabled calls to keyring_key_generate(), keyring_key_store() " "and keyring_key_remove() will report error until this variable is " "enabled.", NON_PERSIST GLOBAL_VAR(opt_keyring_operations), NO_CMD_LINE, DEFAULT(true), &PLock_keyring_operations, NOT_IN_BINLOG, ON_CHECK(check_keyring_access), ON_UPDATE(nullptr)) |
| | This variable provides access to keyring service APIs. More...
|
| |
| static Sys_var_struct< CHARSET_INFO, Get_name > | Sys_default_collation_for_utf8mb4 ("default_collation_for_utf8mb4", "Controls default collation for utf8mb4 while replicating implicit " "utf8mb4 collations.", SESSION_VAR(default_collation_for_utf8mb4), NO_CMD_LINE, DEFAULT(&my_charset_utf8mb4_0900_ai_ci), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_default_collation_for_utf8mb4), ON_UPDATE(update_deprecated)) |
| |
| static Sys_var_bool | Sys_show_create_table_verbosity ("show_create_table_verbosity", "When this option is enabled, it increases the verbosity of " "'SHOW CREATE TABLE'.", SESSION_VAR(show_create_table_verbosity), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static const char * | use_secondary_engine_values [] |
| |
| static Sys_var_enum | Sys_use_secondary_engine ("use_secondary_engine", "Controls preparation of SELECT statements against secondary storage " "engine. Valid values: OFF/ON/FORCED. OFF = Prepare only against primary " "storage engine. ON = First prepare against secondary storage engine, " "reprepare against primary storage engine if error. FORCED = Prepare all " "SELECT statements referencing one or more base tables only against " "secondary storage engine.", HINT_UPDATEABLE SESSION_ONLY(use_secondary_engine), NO_CMD_LINE, use_secondary_engine_values, DEFAULT(SECONDARY_ENGINE_ON), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static Sys_var_bool | Sys_enable_secondary_engine_statistics ("enable_secondary_engine_statistics", "When this option is enabled, the hypergraph query optimizer may fetch" "statistics from the secondary engine, if available", HINT_UPDATEABLE SESSION_VAR(enable_secondary_engine_statistics), CMD_LINE(OPT_ARG), DEFAULT(true), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static Sys_var_session_special | Sys_statement_id ("statement_id", "statement_id: represents the id of the query " "When this option is enabled it returns the statement id to the client, " "the client can find more data about this query from the performance schema" "(such as: events_statements_history table, rpd_query_stats table etc) by " "searching for a specific statement_id value.", READ_ONLY sys_var::ONLY_SESSION, NO_CMD_LINE, VALID_RANGE(0, INT_MAX64), BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), ON_READ(read_statement_id)) |
| |
| static Sys_var_double | Sys_secondary_engine_cost_threshold ("secondary_engine_cost_threshold", "Controls which statements to consider for execution in a secondary " "storage engine. Only statements that have a cost estimate higher than " "this value will be attempted executed in a secondary storage engine.", HINT_UPDATEABLE SESSION_VAR(secondary_engine_cost_threshold), CMD_LINE(OPT_ARG), VALID_RANGE(0, DBL_MAX), DEFAULT(100000), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| | Cost threshold for executing queries in a secondary storage engine. More...
|
| |
| static Sys_var_bool | Sys_sql_require_primary_key |
| |
| static Sys_var_bool | Sys_sql_generate_invisible_primary_key ("sql_generate_invisible_primary_key", "When set, if a table is created without a primary key then server " "generates invisible auto-increment column as a primary key for the table.", SESSION_VAR(sql_generate_invisible_primary_key), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_session_admin), ON_UPDATE(nullptr)) |
| |
| static Sys_var_bool | Sys_show_gipk_in_create_table_and_information_schema ("show_gipk_in_create_table_and_information_schema", "When set, if a primary key is generated for a table then SHOW commands " "and INFORMATION_SCHEMA tables shows generated invisible primary key " "definition.", SESSION_VAR(show_gipk_in_create_table_and_information_schema), CMD_LINE(OPT_ARG), DEFAULT(true), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static Sys_var_charptr | Sys_sys_variables_admin_subject (PERSIST_ONLY_ADMIN_X509_SUBJECT, "The client peer certificate name required to enable setting all " "system variables via SET PERSIST[_ONLY]", READ_ONLY NON_PERSIST GLOBAL_VAR(sys_var_persist_only_admin_x509_subject), CMD_LINE(OPT_ARG), IN_SYSTEM_CHARSET, DEFAULT("")) |
| |
| static Sys_var_ulong | Sys_binlog_row_event_max_size ("binlog_row_event_max_size", "The maximum size of a row-based binary log event in bytes. Rows will be " "grouped into events smaller than this size if possible. " "The value has to be a multiple of 256.", READ_ONLY GLOBAL_VAR(binlog_row_event_max_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(256, ULONG_MAX), DEFAULT(8192), BLOCK_SIZE(256)) |
| |
| static const char * | group_replication_consistency_names [] |
| |
| static Sys_var_enum | Sys_group_replication_consistency ("group_replication_consistency", "Transaction consistency guarantee, possible values: EVENTUAL, " "BEFORE_ON_PRIMARY_FAILOVER, BEFORE, AFTER, BEFORE_AND_AFTER", SESSION_VAR(group_replication_consistency), CMD_LINE(OPT_ARG), group_replication_consistency_names, DEFAULT(GROUP_REPLICATION_CONSISTENCY_BEFORE_ON_PRIMARY_FAILOVER), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_group_replication_consistency), ON_UPDATE(nullptr)) |
| |
| static Sys_var_binlog_encryption | Sys_binlog_encryption ("binlog_encryption", "Enable/disable binary and relay logs encryption.", GLOBAL_VAR(rpl_encryption.get_enabled_var()), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_binlog_encryption_admin)) |
| |
| static Sys_var_bool | Sys_binlog_rotate_encryption_master_key_at_startup ("binlog_rotate_encryption_master_key_at_startup", "Force binlog encryption master key rotation at startup", READ_ONLY GLOBAL_VAR(rpl_encryption.get_master_key_rotation_at_startup_var()), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG) |
| |
| static Sys_var_uint | Sys_original_server_version ("original_server_version", "The version of the server where the transaction was originally executed", SESSION_ONLY(original_server_version), NO_CMD_LINE, VALID_RANGE(0, UNDEFINED_SERVER_VERSION), DEFAULT(UNDEFINED_SERVER_VERSION), BLOCK_SIZE(1), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_session_admin_or_replication_applier)) |
| |
| static Sys_var_uint | Sys_immediate_server_version ("immediate_server_version", "The server version of the immediate server in the replication topology", SESSION_ONLY(immediate_server_version), NO_CMD_LINE, VALID_RANGE(0, UNDEFINED_SERVER_VERSION), DEFAULT(UNDEFINED_SERVER_VERSION), BLOCK_SIZE(1), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_session_admin_or_replication_applier)) |
| |
| static Sys_var_bool | Sys_default_table_encryption ("default_table_encryption", "Database and tablespace are created with this default encryption property " "unless the user specifies an explicit encryption property.", HINT_UPDATEABLE SESSION_VAR(default_table_encryption), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_set_default_table_encryption_access), ON_UPDATE(nullptr)) |
| |
| static Sys_var_bool | Sys_table_encryption_privilege_check ("table_encryption_privilege_check", "Indicates if server enables privilege check when user tries to use " "non-default value for CREATE DATABASE or CREATE TABLESPACE or when " "user tries to do CREATE TABLE with ENCRYPTION option which deviates " "from per-database default.", GLOBAL_VAR(opt_table_encryption_privilege_check), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_set_table_encryption_privilege_access), ON_UPDATE(nullptr)) |
| |
| static Sys_var_bool | Sys_var_print_identified_with_as_hex ("print_identified_with_as_hex", "SHOW CREATE USER will print the AS clause as HEX if it contains " "non-prinable characters", SESSION_VAR(print_identified_with_as_hex), CMD_LINE(OPT_ARG), DEFAULT(false)) |
| |
| static Sys_var_bool | Sys_var_show_create_table_skip_secondary_engine ("show_create_table_skip_secondary_engine", "SHOW CREATE TABLE will skip SECONDARY_ENGINE when printing the table " "definition", SESSION_ONLY(show_create_table_skip_secondary_engine), NO_CMD_LINE, DEFAULT(false)) |
| | Session only flag to skip printing secondary engine in SHOW CREATE TABLE. More...
|
| |
| static Sys_var_uint | Sys_generated_random_password_length ("generated_random_password_length", "Determines the length randomly generated passwords in CREATE USER-," "SET PASSWORD- or ALTER USER statements", SESSION_VAR(generated_random_password_length), CMD_LINE(REQUIRED_ARG), VALID_RANGE(5, 255), DEFAULT(20), BLOCK_SIZE(1), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(nullptr)) |
| |
| static Sys_var_charptr | Sys_protocol_compression_algorithms ("protocol_compression_algorithms", "List of compression algorithms supported by server. Supported values " "are any combination of zlib, zstd, uncompressed. Command line clients " "may use the --compression-algorithms flag to specify a set of algorithms, " "and the connection will use an algorithm supported by both client and " "server. It picks zlib if both client and server support it; otherwise it " "picks zstd if both support it; otherwise it picks uncompressed if both " "support it; otherwise it fails.", GLOBAL_VAR(opt_protocol_compression_algorithms), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(const_cast< char * >(PROTOCOL_COMPRESSION_DEFAULT_VALUE)), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_set_protocol_compression_algorithms), ON_UPDATE(nullptr)) |
| |
| static Sys_var_bool | Sys_var_require_row_format ("require_row_format", "Limit the application of queries to row based events " "and DDLs with the exception of temporary table creation/deletion.", SESSION_ONLY(require_row_format), NO_CMD_LINE, DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_set_require_row_format)) |
| | Session only flag to limit the application of queries to row based events and DDLs with the exception of temporary table creation/deletion. More...
|
| |
| static Sys_var_bool | Sys_replication_optimize_for_static_plugin_config ("replication_optimize_for_static_plugin_config", "Optional flag that blocks plugin install/uninstall and allows skipping " "the acquisition of the lock to read from the plugin list and the usage " "of read-optimized spin-locks. Use only when plugin hook callback needs " "optimization (a lot of semi-sync replicas, for instance).", GLOBAL_VAR(opt_replication_optimize_for_static_plugin_config), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(handle_plugin_lock_type_change)) |
| |
| static Sys_var_bool | Sys_replication_sender_observe_commit_only ("replication_sender_observe_commit_only", "Optional flag that allows for only calling back observer hooks at " "commit.", GLOBAL_VAR(opt_replication_sender_observe_commit_only), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static Sys_var_bool | Sys_skip_replica_start ("skip_replica_start", "Do not start replication threads automatically " "when the server starts.", READ_ONLY GLOBAL_VAR(opt_skip_replica_start), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static PolyLock_mutex PLock_authentication_policy & | LOCK_authentication_policy |
| | This is a mutex used to protect @global.authentication_policy variable. More...
|
| |
| static Sys_var_charptr | Sys_authentication_policy ("authentication_policy", "Defines policies around how user account can be configured with Multi " "Factor authentication methods during CREATE/ALTER USER statement. " "This variable accepts at-most 3 comma separated list of authentication " "factor descriptions. Allowed factor descriptions are: " "(empty) - factor is optional, any authentication method is allowed. " "* - factor is mandatory, any authentication method is allowed. " "<plugin> - <plugin> is mandatory authentication method. " "*:<plugin> - factor is mandatory, <plugin> is default authentication " "method. The first factor cannot be optional and if neither mandatory nor " "default method is specified, caching_sha2_password is assumed as default.", GLOBAL_VAR(opt_authentication_policy), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT("*,,"), &PLock_authentication_policy, NOT_IN_BINLOG, ON_CHECK(check_authentication_policy), ON_UPDATE(fix_authentication_policy)) |
| |
| static Sys_var_deprecated_alias | Sys_skip_slave_start ("skip_slave_start", Sys_skip_replica_start) |
| |
| static const char * | terminology_use_previous_names [] |
| |
| static Sys_var_enum | Sys_terminology_use_previous ("terminology_use_previous", "Make monitoring tables and statements use the identifiers that were " "in use before they were changed in a given release. That includes names " "for mutexes, read/write locks, condition variables, memory allocations, " "thread names, thread stages, and thread commands. When the session " "option is set to BEFORE_8_0_26, the session uses the names that were in " "use until 8.0.25, when it selects from performance_schema tables, or " "selects from INFORMATION_SCHEMA.PROCESSLIST, or issues SHOW PROCESSLIST " "or SHOW REPLICA STATUS. When the global option is set to BEFORE_8_0_26, " "new sessions use BEFORE_8_0_26 as default for the session option, and in " "addition the thread commands that were in use until 8.0.25 are written " "to the slow query log. If set to BEFORE_8_2_0 or less the command SHOW " "CREATE EVENT will show how the event would have been created in a server " "of a version lower than 8.2.0. SHOW EVENTS and queries into " "information_schema.events will also output the old terminology for the " "event status field.", SESSION_VAR(terminology_use_previous), CMD_LINE(REQUIRED_ARG), terminology_use_previous_names, DEFAULT(terminology_use_previous::NONE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), DEPRECATED_VAR("")) |
| |
| static Sys_var_bool | Sys_xa_detatch_on_prepare ("xa_detach_on_prepare", "When set, XA transactions will be detached (AKA dissociated or " "disconnected) from connection as part of XA PREPARE. This means that " "the XA transaction can be committed/rolled back by any connection, " "even if the starting connection has not terminated, and the starting " "connection can start new transactions. As a side effect, temporary " "tables cannot be used inside XA transactions. " "When disabled, XA transactions are associated with the same connection " "until the session disconnects. ON is the only safe choice for " "replication.", HINT_UPDATEABLE SESSION_VAR(xa_detach_on_prepare), CMD_LINE(OPT_ARG), DEFAULT(true), NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_session_admin_outside_trx_outside_sf)) |
| |
| static Sys_var_charptr | Sys_debug_sensitive_session_string ("debug_sensitive_session_string", "Debug variable to test sensitive session string variable.", SENSITIVE SESSION_VAR(debug_sensitive_session_str), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT("")) |
| |
| static Sys_var_bool | Sys_persist_sensitive_variables_in_plaintext ("persist_sensitive_variables_in_plaintext", "If set to FALSE, server will refuse to persist SENSITIVE variables in " "plaintext and refuse to start if encrypted part of persited file cannot " "be processed.", READ_ONLY NON_PERSIST GLOBAL_VAR(opt_persist_sensitive_variables_in_plaintext), CMD_LINE(OPT_ARG), DEFAULT(true), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr), nullptr, sys_var::PARSE_EARLY) |
| |
| static const char * | explain_format_names [] |
| |
| static Sys_var_enum | Sys_explain_format ("explain_format", "The default format in which the EXPLAIN statement displays information. " "Valid values are TRADITIONAL (default), TREE, JSON and TRADITIONAL_STRICT." " TRADITIONAL_STRICT is only used internally by the mtr test suite, and is " "not meant to be used anywhere else.", SESSION_VAR(explain_format), CMD_LINE(OPT_ARG), explain_format_names, DEFAULT(static_cast< ulong >(Explain_format_type::TRADITIONAL)), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static Sys_var_uint | Sys_explain_json_format_version ("explain_json_format_version", "The JSON format version for EXPLAIN FORMAT=JSON queries with the old " "(non-hypergraph) join optimizer. " "Valid values are 1 and 2.", SESSION_VAR(explain_json_format_version), CMD_LINE(REQUIRED_ARG), VALID_RANGE(1, 2), DEFAULT(1), BLOCK_SIZE(1)) |
| |
| static Sys_var_bool | Sys_tls_certificates_enforced_validation ("tls_certificates_enforced_validation", "If set to TRUE, server stops execution at the start up in case of invalid " "certificates " "When ALTER INSTANCE RELOAD TLS executed, new certficates will not be used " "if validation fails. ", READ_ONLY NON_PERSIST GLOBAL_VAR(opt_tls_certificates_enforced_validation), CMD_LINE(OPT_ARG), DEFAULT(false), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| static Sys_var_ulonglong | Sys_set_operations_buffer_size ("set_operations_buffer_size", "The maximum size of the buffer used for hash based set operations ", HINT_UPDATEABLE SESSION_VAR(set_operations_buffer_size), CMD_LINE(REQUIRED_ARG), VALID_RANGE(16384, max_mem_sz), DEFAULT(256ULL *1024), BLOCK_SIZE(128)) |
| |
| static Sys_var_charptr | Sys_debug_set_operations_secondary_overflow_at ("debug_set_operations_secondary_overflow_at", "Error injection", HINT_UPDATEABLE SESSION_VAR(debug_set_operations_secondary_overflow_at), CMD_LINE(REQUIRED_ARG), IN_FS_CHARSET, DEFAULT(""), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(nullptr), ON_UPDATE(nullptr)) |
| |
| Sys_var_bool | anonymous_namespace{sys_vars.cc}::Sys_restrict_fk_on_non_standard_key ("restrict_fk_on_non_standard_key", "Disallow the creation of foreign keys referencing non-unique key " "or partial key", NON_PERSIST SESSION_VAR(restrict_fk_on_non_standard_key), CMD_LINE(OPT_ARG), DEFAULT(true), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(restrict_fk_on_non_standard_key_check), ON_UPDATE(nullptr)) |
| |
1.9.2