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

sys_vars changes and cleanups

Browse Source
This commit is contained in:
Sergei Golubchik 2011-07-11 20:33:39 +02:00
parent e44fefc7b3
commit 2005689700
7 changed files with 91 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
sql/mysqld.cc
View File

@ -6180,6 +6180,10 @@ struct my_option my_long_options[]=
option if compiled with valgrind support.
*/
IF_VALGRIND(0,1), 0, 0, 0, 0, 0},
{"sync_sys", 0,
"Enable/disable system sync calls. Should only be turned off when running "
"tests or debugging!!",
&opt_sync, &opt_sync, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
{"sysdate-is-now", 0,
"Non-default option to alias SYSDATE() to NOW() to make it safe-replicable. "
"Since 5.0, SYSDATE() returns a `dynamic' value different for different "
@ -7496,7 +7500,7 @@ static int get_options(int *argc_ptr, char ***argv_ptr)
opt < my_long_options + array_elements(my_long_options) - 1;
opt++)
insert_dynamic(&all_options, (uchar*) opt);
sys_var_add_options(&all_options, sys_var::PARSE_NORMAL);
sys_var_add_options(&all_options, 0);
add_terminator(&all_options);
/* Skip unknown options so that they may be processed later by plugins */

4
sql/scheduler.cc
View File

@ -60,13 +60,13 @@ static void scheduler_wait_lock_end(void) {
static void scheduler_wait_sync_begin(void) {
THD *thd=current_thd;
scheduler_functions *func= thd->scheduler;
scheduler_functions *func= thd ? thd->scheduler : thread_scheduler;
MYSQL_CALLBACK(func, thd_wait_begin, (thd, THD_WAIT_TABLE_LOCK));
}
static void scheduler_wait_sync_end(void) {
THD *thd=current_thd;
scheduler_functions *func= thd->scheduler;
scheduler_functions *func= thd ? thd->scheduler : thread_scheduler;
MYSQL_CALLBACK(func, thd_wait_end, (thd));
}
};

8
sql/set_var.cc
View File

@ -137,7 +137,6 @@ void sys_var_end()
@param deprecated_version if not 0 - when this variable will go away
@param substitute if not 0 - what one should use instead when this
deprecated variable
@param parse_flag either PARSE_EARLY or PARSE_NORMAL
*/
sys_var::sys_var(sys_var_chain *chain, const char *name_arg,
const char *comment, int flags_arg, ptrdiff_t off,
@ -146,11 +145,10 @@ sys_var::sys_var(sys_var_chain *chain, const char *name_arg,
PolyLock *lock, enum binlog_status_enum binlog_status_arg,
on_check_function on_check_func,
on_update_function on_update_func,
uint deprecated_version, const char *substitute,
int parse_flag) :
uint deprecated_version, const char *substitute) :
next(0),
binlog_status(binlog_status_arg),
flags(flags_arg), m_parse_flag(parse_flag), show_val_type(show_val_type_arg),
flags(flags_arg), show_val_type(show_val_type_arg),
guard(lock), offset(off), on_check(on_check_func), on_update(on_update_func),
is_os_charset(FALSE)
{
@ -163,7 +161,7 @@ sys_var::sys_var(sys_var_chain *chain, const char *name_arg,
in the first (PARSE_EARLY) stage.
See handle_options() for details.
*/
DBUG_ASSERT(parse_flag == PARSE_NORMAL || getopt_id <= 0 || getopt_id >= 255);
DBUG_ASSERT(!(flags & PARSE_EARLY) || getopt_id <= 0 || getopt_id >= 255);
name.str= name_arg; // ER_NO_DEFAULT relies on 0-termination of name_arg
name.length= strlen(name_arg); // and so does this.

9
sql/set_var.h
View File

@ -59,9 +59,7 @@ public:
sys_var *next;
LEX_CSTRING name;
enum flag_enum { GLOBAL, SESSION, ONLY_SESSION, SCOPE_MASK=1023,
READONLY=1024, ALLOCATED=2048 };
static const int PARSE_EARLY= 1;
static const int PARSE_NORMAL= 2;
READONLY=1024, ALLOCATED=2048, PARSE_EARLY=4096 };
/**
Enumeration type to indicate for a system variable whether
it will be written to the binlog or not.
@ -74,7 +72,6 @@ protected:
typedef bool (*on_update_function)(sys_var *self, THD *thd, enum_var_type type);
int flags; ///< or'ed flag_enum values
int m_parse_flag; ///< either PARSE_EARLY or PARSE_NORMAL.
const SHOW_TYPE show_val_type; ///< what value_ptr() returns for sql_show.cc
my_option option; ///< min, max, default values are stored here
PolyLock *guard; ///< *second* lock that protects the variable
@ -90,7 +87,7 @@ public:
enum get_opt_arg_type getopt_arg_type, SHOW_TYPE show_val_type_arg,
longlong def_val, PolyLock *lock, enum binlog_status_enum binlog_status_arg,
on_check_function on_check_func, on_update_function on_update_func,
uint deprecated_version, const char *substitute, int parse_flag);
uint deprecated_version, const char *substitute);
virtual ~sys_var() {}
@ -133,7 +130,7 @@ public:
}
bool register_option(DYNAMIC_ARRAY *array, int parse_flags)
{
return (option.id != -1) && (m_parse_flag & parse_flags) &&
return (option.id != -1) && ((flags & PARSE_EARLY) == parse_flags) &&
insert_dynamic(array, (uchar*)&option);
}

2
sql/sql_plugin.cc
View File

@ -243,7 +243,7 @@ public:
(plugin_var_arg->flags & PLUGIN_VAR_THDLOCAL ? SESSION : GLOBAL) |
(plugin_var_arg->flags & PLUGIN_VAR_READONLY ? READONLY : 0),
0, -1, NO_ARG, pluginvar_show_type(plugin_var_arg), 0, 0,
VARIABLE_NOT_IN_BINLOG, 0, 0, 0, 0, PARSE_NORMAL),
VARIABLE_NOT_IN_BINLOG, 0, 0, 0, 0),
plugin_var(plugin_var_arg), orig_pluginvar_name(plugin_var_arg->name)
{ plugin_var->name= name_arg; }
sys_var_pluginvar *cast_pluginvar() { return this; }

124
sql/sys_vars.cc
View File

@ -61,136 +61,117 @@
#ifdef WITH_PERFSCHEMA_STORAGE_ENGINE
#define PFS_TRAILING_PROPERTIES \
NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(NULL), ON_UPDATE(NULL), \
0, NULL, sys_var::PARSE_EARLY
static Sys_var_mybool Sys_pfs_enabled(
"performance_schema",
"Enable the performance schema.",
READ_ONLY GLOBAL_VAR(pfs_param.m_enabled),
CMD_LINE(OPT_ARG), DEFAULT(FALSE),
PFS_TRAILING_PROPERTIES);
PARSED_EARLY READ_ONLY GLOBAL_VAR(pfs_param.m_enabled),
CMD_LINE(OPT_ARG), DEFAULT(FALSE));
static Sys_var_ulong Sys_pfs_events_waits_history_long_size(
"performance_schema_events_waits_history_long_size",
"Number of rows in EVENTS_WAITS_HISTORY_LONG.",
READ_ONLY GLOBAL_VAR(pfs_param.m_events_waits_history_long_sizing),
PARSED_EARLY READ_ONLY
GLOBAL_VAR(pfs_param.m_events_waits_history_long_sizing),
CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024*1024),
DEFAULT(PFS_WAITS_HISTORY_LONG_SIZE),
BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES);
DEFAULT(PFS_WAITS_HISTORY_LONG_SIZE), BLOCK_SIZE(1));
static Sys_var_ulong Sys_pfs_events_waits_history_size(
"performance_schema_events_waits_history_size",
"Number of rows per thread in EVENTS_WAITS_HISTORY.",
READ_ONLY GLOBAL_VAR(pfs_param.m_events_waits_history_sizing),
PARSED_EARLY READ_ONLY GLOBAL_VAR(pfs_param.m_events_waits_history_sizing),
CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024),
DEFAULT(PFS_WAITS_HISTORY_SIZE),
BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES);
DEFAULT(PFS_WAITS_HISTORY_SIZE), BLOCK_SIZE(1));
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),
PARSED_EARLY READ_ONLY GLOBAL_VAR(pfs_param.m_cond_class_sizing),
CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 256),
DEFAULT(PFS_MAX_COND_CLASS),
BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES);
DEFAULT(PFS_MAX_COND_CLASS), BLOCK_SIZE(1));
static Sys_var_ulong Sys_pfs_max_cond_instances(
"performance_schema_max_cond_instances",
"Maximum number of instrumented condition objects.",
READ_ONLY GLOBAL_VAR(pfs_param.m_cond_sizing),
PARSED_EARLY READ_ONLY GLOBAL_VAR(pfs_param.m_cond_sizing),
CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024*1024),
DEFAULT(PFS_MAX_COND),
BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES);
DEFAULT(PFS_MAX_COND), BLOCK_SIZE(1));
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),
PARSED_EARLY READ_ONLY GLOBAL_VAR(pfs_param.m_file_class_sizing),
CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 256),
DEFAULT(PFS_MAX_FILE_CLASS),
BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES);
DEFAULT(PFS_MAX_FILE_CLASS), BLOCK_SIZE(1));
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),
PARSED_EARLY 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);
DEFAULT(PFS_MAX_FILE_HANDLE), BLOCK_SIZE(1));
static Sys_var_ulong Sys_pfs_max_file_instances(
"performance_schema_max_file_instances",
"Maximum number of instrumented files.",
READ_ONLY GLOBAL_VAR(pfs_param.m_file_sizing),
PARSED_EARLY READ_ONLY GLOBAL_VAR(pfs_param.m_file_sizing),
CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024*1024),
DEFAULT(PFS_MAX_FILE),
BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES);
DEFAULT(PFS_MAX_FILE), BLOCK_SIZE(1));
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),
PARSED_EARLY READ_ONLY GLOBAL_VAR(pfs_param.m_mutex_class_sizing),
CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 256),
DEFAULT(PFS_MAX_MUTEX_CLASS),
BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES);
DEFAULT(PFS_MAX_MUTEX_CLASS), BLOCK_SIZE(1));
static Sys_var_ulong Sys_pfs_max_mutex_instances(
"performance_schema_max_mutex_instances",
"Maximum number of instrumented MUTEX objects.",
READ_ONLY GLOBAL_VAR(pfs_param.m_mutex_sizing),
PARSED_EARLY READ_ONLY GLOBAL_VAR(pfs_param.m_mutex_sizing),
CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 100*1024*1024),
DEFAULT(PFS_MAX_MUTEX),
BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES);
DEFAULT(PFS_MAX_MUTEX), BLOCK_SIZE(1));
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),
PARSED_EARLY READ_ONLY GLOBAL_VAR(pfs_param.m_rwlock_class_sizing),
CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 256),
DEFAULT(PFS_MAX_RWLOCK_CLASS),
BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES);
DEFAULT(PFS_MAX_RWLOCK_CLASS), BLOCK_SIZE(1));
static Sys_var_ulong Sys_pfs_max_rwlock_instances(
"performance_schema_max_rwlock_instances",
"Maximum number of instrumented RWLOCK objects.",
READ_ONLY GLOBAL_VAR(pfs_param.m_rwlock_sizing),
PARSED_EARLY READ_ONLY GLOBAL_VAR(pfs_param.m_rwlock_sizing),
CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 100*1024*1024),
DEFAULT(PFS_MAX_RWLOCK),
BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES);
DEFAULT(PFS_MAX_RWLOCK), BLOCK_SIZE(1));
static Sys_var_ulong Sys_pfs_max_table_handles(
"performance_schema_max_table_handles",
"Maximum number of opened instrumented tables.",
READ_ONLY GLOBAL_VAR(pfs_param.m_table_sizing),
PARSED_EARLY READ_ONLY GLOBAL_VAR(pfs_param.m_table_sizing),
CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024*1024),
DEFAULT(PFS_MAX_TABLE),
BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES);
DEFAULT(PFS_MAX_TABLE), BLOCK_SIZE(1));
static Sys_var_ulong Sys_pfs_max_table_instances(
"performance_schema_max_table_instances",
"Maximum number of instrumented tables.",
READ_ONLY GLOBAL_VAR(pfs_param.m_table_share_sizing),
PARSED_EARLY READ_ONLY GLOBAL_VAR(pfs_param.m_table_share_sizing),
CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024*1024),
DEFAULT(PFS_MAX_TABLE_SHARE),
BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES);
DEFAULT(PFS_MAX_TABLE_SHARE), BLOCK_SIZE(1));
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),
PARSED_EARLY READ_ONLY GLOBAL_VAR(pfs_param.m_thread_class_sizing),
CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 256),
DEFAULT(PFS_MAX_THREAD_CLASS),
BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES);
DEFAULT(PFS_MAX_THREAD_CLASS), BLOCK_SIZE(1));
static Sys_var_ulong Sys_pfs_max_thread_instances(
"performance_schema_max_thread_instances",
"Maximum number of instrumented threads.",
READ_ONLY GLOBAL_VAR(pfs_param.m_thread_sizing),
PARSED_EARLY READ_ONLY GLOBAL_VAR(pfs_param.m_thread_sizing),
CMD_LINE(REQUIRED_ARG), VALID_RANGE(0, 1024*1024),
DEFAULT(PFS_MAX_THREAD),
BLOCK_SIZE(1), PFS_TRAILING_PROPERTIES);
DEFAULT(PFS_MAX_THREAD), BLOCK_SIZE(1));
#endif /* WITH_PERFSCHEMA_STORAGE_ENGINE */
@ -1029,8 +1010,7 @@ static bool session_readonly(sys_var *self, THD *thd, set_var *var)
return true;
}
static bool
check_max_allowed_packet(sys_var *self, THD *thd, set_var *var)
static bool check_max_allowed_packet(sys_var *self, THD *thd, set_var *var)
{
longlong val;
if (session_readonly(self, thd, var))
@ -1285,8 +1265,7 @@ static Sys_var_mybool Sys_named_pipe(
#endif
static bool
check_net_buffer_length(sys_var *self, THD *thd, set_var *var)
static bool check_net_buffer_length(sys_var *self, THD *thd, set_var *var)
{
longlong val;
if (session_readonly(self, thd, var))
@ -1894,7 +1873,7 @@ static Sys_var_enum Slave_exec_mode(
"between the master and the slave",
GLOBAL_VAR(slave_exec_mode_options), CMD_LINE(REQUIRED_ARG),
slave_exec_mode_names, DEFAULT(SLAVE_EXEC_MODE_STRICT));
const char *slave_type_conversions_name[]= {"ALL_LOSSY", "ALL_NON_LOSSY", 0};
static const char *slave_type_conversions_name[]= {"ALL_LOSSY", "ALL_NON_LOSSY", 0};
static Sys_var_set Slave_type_conversions(
"slave_type_conversions",
"Set of slave type conversions that are enabled. Legal values are:"
@ -2128,32 +2107,6 @@ static bool check_tx_isolation(sys_var *self, THD *thd, set_var *var)
return FALSE;
}
bool Sys_var_tx_isolation::session_update(THD *thd, set_var *var)
{
if (var->type == OPT_SESSION && Sys_var_enum::session_update(thd, var))
return TRUE;
if (var->type == OPT_DEFAULT || !thd->in_active_multi_stmt_transaction())
{
/*
Update the isolation level of the next transaction.
I.e. if one did:
COMMIT;
SET SESSION ISOLATION LEVEL ...
BEGIN; <-- this transaction has the new isolation
Note, that in case of:
COMMIT;
SET TRANSACTION ISOLATION LEVEL ...
SET SESSION ISOLATION LEVEL ...
BEGIN; <-- the session isolation level is used, not the
result of SET TRANSACTION statement.
*/
thd->tx_isolation= (enum_tx_isolation) var->save_result.ulonglong_value;
}
return FALSE;
}
// NO_CMD_LINE - different name of the option
static Sys_var_tx_isolation Sys_tx_isolation(
"tx_isolation", "Default transaction isolation level",
@ -3324,11 +3277,6 @@ static Sys_var_ulong Sys_mrr_buffer_size(
SESSION_VAR(mrr_buff_size), CMD_LINE(REQUIRED_ARG),
VALID_RANGE(IO_SIZE*2, INT_MAX32), DEFAULT(256*1024), BLOCK_SIZE(1));
/* {"sync_sys", OPT_SYNC,
"Enable/disable system sync calls. Should only be turned off when running "
"tests or debugging!!",
&opt_sync, &opt_sync, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},*/
static Sys_var_ulong Sys_rowid_merge_buff_size(
"rowid_merge_buff_size",
"The size of the buffers used [NOT] IN evaluation via partial matching",

76
sql/sys_vars.h
View File

@ -53,6 +53,7 @@
#define READ_ONLY sys_var::READONLY+
// this means that Sys_var_charptr initial value was malloc()ed
#define PREALLOCATED sys_var::ALLOCATED+
#define PARSED_EARLY sys_var::PARSE_EARLY+
/*
Sys_var_bit meaning is reversed, like in
@@foreign_key_checks <-> OPTION_NO_FOREIGN_KEY_CHECKS
@ -109,12 +110,10 @@ public:
enum binlog_status_enum binlog_status_arg=VARIABLE_NOT_IN_BINLOG,
on_check_function on_check_func=0,
on_update_function on_update_func=0,
uint deprecated_version=0, const char *substitute=0,
int parse_flag= PARSE_NORMAL)
uint deprecated_version=0, const char *substitute=0)
: sys_var(&all_sys_vars, name_arg, comment, flag_args, off, getopt.id,
getopt.arg_type, SHOWT, def_val, lock, binlog_status_arg,
on_check_func, on_update_func, deprecated_version,
substitute, parse_flag)
on_check_func, on_update_func, deprecated_version, substitute)
{
option.var_type= ARGT;
option.min_value= min_val;
@ -197,11 +196,11 @@ public:
ulonglong def_val, PolyLock *lock,
enum binlog_status_enum binlog_status_arg,
on_check_function on_check_func, on_update_function on_update_func,
uint deprecated_version, const char *substitute, int parse_flag= PARSE_NORMAL)
uint deprecated_version, const char *substitute)
: sys_var(&all_sys_vars, name_arg, comment, flag_args, off, getopt.id,
getopt.arg_type, show_val_type_arg, def_val, lock,
binlog_status_arg, on_check_func,
on_update_func, deprecated_version, substitute, parse_flag)
on_update_func, deprecated_version, substitute)
{
for (typelib.count= 0; values[typelib.count]; typelib.count++) /*no-op */;
typelib.name="";
@ -311,12 +310,11 @@ public:
enum binlog_status_enum binlog_status_arg=VARIABLE_NOT_IN_BINLOG,
on_check_function on_check_func=0,
on_update_function on_update_func=0,
uint deprecated_version=0, const char *substitute=0,
int parse_flag= PARSE_NORMAL)
uint deprecated_version=0, const char *substitute=0)
: Sys_var_typelib(name_arg, comment, flag_args, off, getopt,
SHOW_MY_BOOL, bool_values, def_val, lock,
binlog_status_arg, on_check_func, on_update_func,
deprecated_version, substitute, parse_flag)
deprecated_version, substitute)
{
option.var_type= GET_BOOL;
global_var(my_bool)= def_val;
@ -367,12 +365,11 @@ public:
enum binlog_status_enum binlog_status_arg=VARIABLE_NOT_IN_BINLOG,
on_check_function on_check_func=0,
on_update_function on_update_func=0,
uint deprecated_version=0, const char *substitute=0,
int parse_flag= PARSE_NORMAL)
uint deprecated_version=0, const char *substitute=0)
: sys_var(&all_sys_vars, name_arg, comment, flag_args, off, getopt.id,
getopt.arg_type, SHOW_CHAR_PTR, (intptr)def_val,
lock, binlog_status_arg, on_check_func, on_update_func,
deprecated_version, substitute, parse_flag)
deprecated_version, substitute)
{
is_os_charset= is_os_charset_arg == IN_FS_CHARSET;
/*
@ -461,7 +458,7 @@ public:
: sys_var(&all_sys_vars, name_arg, comment,
sys_var::READONLY+sys_var::ONLY_SESSION, 0, -1,
NO_ARG, SHOW_CHAR, 0, NULL, VARIABLE_NOT_IN_BINLOG,
NULL, NULL, 0, NULL, PARSE_NORMAL)
NULL, NULL, 0, NULL)
{
is_os_charset= is_os_charset_arg == IN_FS_CHARSET;
option.var_type= GET_STR;
@ -574,12 +571,11 @@ public:
enum binlog_status_enum binlog_status_arg=VARIABLE_NOT_IN_BINLOG,
on_check_function on_check_func=0,
on_update_function on_update_func=0,
uint deprecated_version=0, const char *substitute=0,
int parse_flag= PARSE_NORMAL)
uint deprecated_version=0, const char *substitute=0)
: sys_var(&all_sys_vars, name_arg, comment, flag_args, 0, getopt.id,
getopt.arg_type, SHOW_CHAR, (intptr)def_val,
lock, binlog_status_arg, on_check_func, on_update_func,
deprecated_version, substitute, parse_flag)
deprecated_version, substitute)
{ option.var_type= GET_NO_ARG; }
bool do_check(THD *thd, set_var *var)
{
@ -819,12 +815,11 @@ public:
enum binlog_status_enum binlog_status_arg=VARIABLE_NOT_IN_BINLOG,
on_check_function on_check_func=0,
on_update_function on_update_func=0,
uint deprecated_version=0, const char *substitute=0,
int parse_flag= PARSE_NORMAL)
uint deprecated_version=0, const char *substitute=0)
: sys_var(&all_sys_vars, name_arg, comment, flag_args, off, getopt.id,
getopt.arg_type, SHOW_DOUBLE, (longlong) double2ulonglong(def_val),
lock, binlog_status_arg, on_check_func, on_update_func,
deprecated_version, substitute, parse_flag)
deprecated_version, substitute)
{
option.var_type= GET_DOUBLE;
option.min_value= (longlong) double2ulonglong(min_val);
@ -1142,12 +1137,11 @@ public:
enum binlog_status_enum binlog_status_arg=VARIABLE_NOT_IN_BINLOG,
on_check_function on_check_func=0,
on_update_function on_update_func=0,
uint deprecated_version=0, const char *substitute=0,
int parse_flag= PARSE_NORMAL)
uint deprecated_version=0, const char *substitute=0)
: sys_var(&all_sys_vars, name_arg, comment, flag_args, off, getopt.id,
getopt.arg_type, SHOW_CHAR, (intptr)def_val,
lock, binlog_status_arg, on_check_func, on_update_func,
deprecated_version, substitute, parse_flag),
deprecated_version, substitute),
plugin_type(plugin_type_arg)
{
option.var_type= GET_STR;
@ -1256,12 +1250,11 @@ public:
enum binlog_status_enum binlog_status_arg=VARIABLE_NOT_IN_BINLOG,
on_check_function on_check_func=0,
on_update_function on_update_func=0,
uint deprecated_version=0, const char *substitute=0,
int parse_flag= PARSE_NORMAL)
uint deprecated_version=0, const char *substitute=0)
: sys_var(&all_sys_vars, name_arg, comment, flag_args, 0, getopt.id,
getopt.arg_type, SHOW_CHAR, (intptr)def_val,
lock, binlog_status_arg, on_check_func, on_update_func,
deprecated_version, substitute, parse_flag)
deprecated_version, substitute)
{
DBUG_ASSERT(scope() == ONLY_SESSION);
option.var_type= GET_NO_ARG;
@ -1475,12 +1468,11 @@ public:
enum binlog_status_enum binlog_status_arg=VARIABLE_NOT_IN_BINLOG,
on_check_function on_check_func=0,
on_update_function on_update_func=0,
uint deprecated_version=0, const char *substitute=0,
int parse_flag= PARSE_NORMAL)
uint deprecated_version=0, const char *substitute=0)
: sys_var(&all_sys_vars, name_arg, comment, flag_args, off, getopt.id,
getopt.arg_type, SHOW_CHAR, 0,
lock, binlog_status_arg, on_check_func, on_update_func,
deprecated_version, substitute, parse_flag)
deprecated_version, substitute)
{
DBUG_ASSERT(scope() == GLOBAL);
DBUG_ASSERT(getopt.id == -1);
@ -1544,12 +1536,11 @@ public:
enum binlog_status_enum binlog_status_arg=VARIABLE_NOT_IN_BINLOG,
on_check_function on_check_func=0,
on_update_function on_update_func=0,
uint deprecated_version=0, const char *substitute=0,
int parse_flag= PARSE_NORMAL)
uint deprecated_version=0, const char *substitute=0)
: sys_var(&all_sys_vars, name_arg, comment, flag_args, off, getopt.id,
getopt.arg_type, SHOW_CHAR, (intptr)def_val,
lock, binlog_status_arg, on_check_func, on_update_func,
deprecated_version, substitute, parse_flag),
deprecated_version, substitute),
name_offset(name_off)
{
option.var_type= GET_STR;
@ -1617,12 +1608,11 @@ public:
enum binlog_status_enum binlog_status_arg=VARIABLE_NOT_IN_BINLOG,
on_check_function on_check_func=0,
on_update_function on_update_func=0,
uint deprecated_version=0, const char *substitute=0,
int parse_flag= PARSE_NORMAL)
uint deprecated_version=0, const char *substitute=0)
: sys_var(&all_sys_vars, name_arg, comment, flag_args, off, getopt.id,
getopt.arg_type, SHOW_CHAR, (intptr)def_val,
lock, binlog_status_arg, on_check_func, on_update_func,
deprecated_version, substitute, parse_flag)
deprecated_version, substitute)
{
DBUG_ASSERT(getopt.id == -1);
DBUG_ASSERT(size == sizeof(Time_zone *));
@ -1684,7 +1674,16 @@ public:
{ return type != STRING_RESULT; }
};
/**
Special implementation for transaction isolation, that
distingushes between
SET GLOBAL TRANSACTION ISOLATION (stored in global_system_variables)
SET SESSION TRANSACTION ISOLATION (stored in thd->variables)
SET TRANSACTION ISOLATION (stored in thd->tx_isolation)
where the last statement sets isolation level for the next transaction only
*/
class Sys_var_tx_isolation: public Sys_var_enum
{
public:
@ -1697,7 +1696,14 @@ public:
:Sys_var_enum(name_arg, comment, flag_args, off, size, getopt,
values, def_val, lock, binlog_status_arg, on_check_func)
{}
virtual bool session_update(THD *thd, set_var *var);
bool session_update(THD *thd, set_var *var)
{
if (var->type == OPT_SESSION && Sys_var_enum::session_update(thd, var))
return TRUE;
if (var->type == OPT_DEFAULT || !thd->in_active_multi_stmt_transaction())
thd->tx_isolation= (enum_tx_isolation) var->save_result.ulonglong_value;
return FALSE;
}
};
/****************************************************************************