diff options
Diffstat (limited to 'sql/set_var.h')
| -rw-r--r-- | sql/set_var.h | 850 |
1 files changed, 599 insertions, 251 deletions
diff --git a/sql/set_var.h b/sql/set_var.h index f43d3b75cee..b6c67d1ab4a 100644 --- a/sql/set_var.h +++ b/sql/set_var.h @@ -26,24 +26,49 @@ class sys_var; class set_var; +class sys_var_pluginvar; /* opaque */ typedef struct system_variables SV; typedef struct my_locale_st MY_LOCALE; -extern TYPELIB bool_typelib, delay_key_write_typelib, sql_mode_typelib; +extern TYPELIB bool_typelib, delay_key_write_typelib, sql_mode_typelib, + slave_exec_mode_typelib; typedef int (*sys_check_func)(THD *, set_var *); typedef bool (*sys_update_func)(THD *, set_var *); typedef void (*sys_after_update_func)(THD *,enum_var_type); typedef void (*sys_set_default_func)(THD *, enum_var_type); -typedef byte *(*sys_value_ptr_func)(THD *thd); +typedef uchar *(*sys_value_ptr_func)(THD *thd); + +struct sys_var_chain +{ + sys_var *first; + sys_var *last; +}; class sys_var { public: + + /** + Enumeration type to indicate for a system variable whether it will be written to the binlog or not. + */ + enum Binlog_status_enum + { + /* The variable value is not in the binlog. */ + NOT_IN_BINLOG, + /* The value of the @@session variable is in the binlog. */ + SESSION_VARIABLE_IN_BINLOG + /* + Currently, no @@global variable is ever in the binlog, so we + don't need an enumeration value for that. + */ + }; + + sys_var *next; struct my_option *option_limits; /* Updated by by set_var_init() */ uint name_length; /* Updated by by set_var_init() */ const char *name; - + sys_after_update_func after_update; bool no_support_one_shot; /* @@ -54,18 +79,34 @@ public: later. */ bool is_os_charset; - sys_var(const char *name_arg, sys_after_update_func func= NULL) - :name(name_arg), after_update(func) - , no_support_one_shot(1), is_os_charset(FALSE) + sys_var(const char *name_arg, sys_after_update_func func= NULL, + Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG) + :name(name_arg), after_update(func), no_support_one_shot(1), + is_os_charset (FALSE), + binlog_status(binlog_status_arg), + m_allow_empty_value(TRUE) {} virtual ~sys_var() {} + void chain_sys_var(sys_var_chain *chain_arg) + { + if (chain_arg->last) + chain_arg->last->next= this; + else + chain_arg->first= this; + chain_arg->last= this; + } virtual bool check(THD *thd, set_var *var); - bool check_enum(THD *thd, set_var *var, TYPELIB *enum_names); + bool check_enum(THD *thd, set_var *var, const TYPELIB *enum_names); bool check_set(THD *thd, set_var *var, TYPELIB *enum_names); + bool is_written_to_binlog(enum_var_type type) + { + return (type == OPT_SESSION || type == OPT_DEFAULT) && + (binlog_status == SESSION_VARIABLE_IN_BINLOG); + } virtual bool update(THD *thd, set_var *var)=0; virtual void set_default(THD *thd_arg, enum_var_type type) {} virtual SHOW_TYPE show_type() { return SHOW_UNDEF; } - virtual byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) + virtual uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) { return 0; } virtual bool check_type(enum_var_type type) { return type != OPT_GLOBAL; } /* Error if not GLOBAL */ @@ -73,10 +114,21 @@ public: { return type != INT_RESULT; } /* Assume INT */ virtual bool check_default(enum_var_type type) { return option_limits == 0; } - Item *item(THD *thd, enum_var_type type, LEX_STRING *base); virtual bool is_struct() { return 0; } virtual bool is_readonly() const { return 0; } CHARSET_INFO *charset(THD *thd); + virtual sys_var_pluginvar *cast_pluginvar() { return 0; } + +protected: + void set_allow_empty_value(bool allow_empty_value) + { + m_allow_empty_value= allow_empty_value; + } + +private: + const Binlog_status_enum binlog_status; + + bool m_allow_empty_value; }; @@ -105,18 +157,19 @@ class sys_var_long_ptr_global: public sys_var_global { public: ulong *value; - sys_var_long_ptr_global(const char *name_arg, ulong *value_ptr_arg, - pthread_mutex_t *guard_arg, - sys_after_update_func after_update_arg= NULL) + sys_var_long_ptr_global(sys_var_chain *chain, const char *name_arg, + ulong *value_ptr_arg, + pthread_mutex_t *guard_arg, + sys_after_update_func after_update_arg= NULL) :sys_var_global(name_arg, after_update_arg, guard_arg), value(value_ptr_arg) - {} + { chain_sys_var(chain); } bool check(THD *thd, set_var *var); bool update(THD *thd, set_var *var); void set_default(THD *thd, enum_var_type type); SHOW_TYPE show_type() { return SHOW_LONG; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) - { return (byte*) value; } + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) + { return (uchar*) value; } }; @@ -127,7 +180,7 @@ public: class sys_var_long_ptr :public sys_var_long_ptr_global { public: - sys_var_long_ptr(const char *name_arg, ulong *value_ptr, + sys_var_long_ptr(sys_var_chain *chain, const char *name_arg, ulong *value_ptr, sys_after_update_func after_update_arg= NULL); }; @@ -136,16 +189,18 @@ class sys_var_ulonglong_ptr :public sys_var { public: ulonglong *value; - sys_var_ulonglong_ptr(const char *name_arg, ulonglong *value_ptr_arg) - :sys_var(name_arg),value(value_ptr_arg) {} - sys_var_ulonglong_ptr(const char *name_arg, ulonglong *value_ptr_arg, + sys_var_ulonglong_ptr(sys_var_chain *chain, const char *name_arg, ulonglong *value_ptr_arg) + :sys_var(name_arg),value(value_ptr_arg) + { chain_sys_var(chain); } + sys_var_ulonglong_ptr(sys_var_chain *chain, const char *name_arg, ulonglong *value_ptr_arg, sys_after_update_func func) - :sys_var(name_arg,func), value(value_ptr_arg) {} + :sys_var(name_arg,func), value(value_ptr_arg) + { chain_sys_var(chain); } bool update(THD *thd, set_var *var); void set_default(THD *thd, enum_var_type type); SHOW_TYPE show_type() { return SHOW_LONGLONG; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) - { return (byte*) value; } + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) + { return (uchar*) value; } }; @@ -153,9 +208,9 @@ class sys_var_bool_ptr :public sys_var { public: my_bool *value; - sys_var_bool_ptr(const char *name_arg, my_bool *value_arg) + sys_var_bool_ptr(sys_var_chain *chain, const char *name_arg, my_bool *value_arg) :sys_var(name_arg),value(value_arg) - {} + { chain_sys_var(chain); } bool check(THD *thd, set_var *var) { return check_enum(thd, var, &bool_typelib); @@ -163,34 +218,23 @@ public: bool update(THD *thd, set_var *var); void set_default(THD *thd, enum_var_type type); SHOW_TYPE show_type() { return SHOW_MY_BOOL; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) - { return (byte*) value; } + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) + { return (uchar*) value; } bool check_update_type(Item_result type) { return 0; } }; -class sys_var_bool_const_ptr : public sys_var +class sys_var_bool_ptr_readonly :public sys_var_bool_ptr { public: - my_bool *value; - sys_var_bool_const_ptr(const char *name_arg, my_bool *value_arg) - :sys_var(name_arg),value(value_arg) + sys_var_bool_ptr_readonly(sys_var_chain *chain, const char *name_arg, + my_bool *value_arg) + :sys_var_bool_ptr(chain, name_arg, value_arg) {} - bool check(THD *thd, set_var *var) - { - return 1; - } - bool update(THD *thd, set_var *var) - { - return 1; - } - SHOW_TYPE show_type() { return SHOW_MY_BOOL; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) - { return (byte*) value; } - bool check_update_type(Item_result type) { return 0; } bool is_readonly() const { return 1; } }; + class sys_var_str :public sys_var { public: @@ -199,14 +243,14 @@ public: sys_check_func check_func; sys_update_func update_func; sys_set_default_func set_default_func; - sys_var_str(const char *name_arg, + sys_var_str(sys_var_chain *chain, const char *name_arg, sys_check_func check_func_arg, sys_update_func update_func_arg, sys_set_default_func set_default_func_arg, char *value_arg) :sys_var(name_arg), value(value_arg), check_func(check_func_arg), update_func(update_func_arg),set_default_func(set_default_func_arg) - {} + { chain_sys_var(chain); } bool check(THD *thd, set_var *var); bool update(THD *thd, set_var *var) { @@ -217,8 +261,8 @@ public: (*set_default_func)(thd, type); } SHOW_TYPE show_type() { return SHOW_CHAR; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) - { return (byte*) value; } + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) + { return (uchar*) value; } bool check_update_type(Item_result type) { return type != STRING_RESULT; /* Only accept strings */ @@ -231,9 +275,10 @@ class sys_var_const_str :public sys_var { public: char *value; // Pointer to const value - sys_var_const_str(const char *name_arg, const char *value_arg) - :sys_var(name_arg),value((char*) value_arg) - {} + sys_var_const_str(sys_var_chain *chain, const char *name_arg, + const char *value_arg) + :sys_var(name_arg), value((char*) value_arg) + { chain_sys_var(chain); } bool check(THD *thd, set_var *var) { return 1; @@ -243,9 +288,9 @@ public: return 1; } SHOW_TYPE show_type() { return SHOW_CHAR; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) { - return (byte*) value; + return (uchar*) value; } bool check_update_type(Item_result type) { @@ -259,8 +304,9 @@ public: class sys_var_const_os_str: public sys_var_const_str { public: - sys_var_const_os_str(const char *name_arg, const char *value_arg) - :sys_var_const_str(name_arg, value_arg) + sys_var_const_os_str(sys_var_chain *chain, const char *name_arg, + const char *value_arg) + :sys_var_const_str(chain, name_arg, value_arg) { is_os_charset= TRUE; } @@ -271,9 +317,9 @@ class sys_var_const_str_ptr :public sys_var { public: char **value; // Pointer to const value - sys_var_const_str_ptr(const char *name_arg, char **value_arg) + sys_var_const_str_ptr(sys_var_chain *chain, const char *name_arg, char **value_arg) :sys_var(name_arg),value(value_arg) - {} + { chain_sys_var(chain); } bool check(THD *thd, set_var *var) { return 1; @@ -283,9 +329,9 @@ public: return 1; } SHOW_TYPE show_type() { return SHOW_CHAR; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) { - return (byte*) *value; + return (uchar*) *value; } bool check_update_type(Item_result type) { @@ -299,8 +345,9 @@ public: class sys_var_const_os_str_ptr :public sys_var_const_str_ptr { public: - sys_var_const_os_str_ptr(const char *name_arg, char **value_arg) - :sys_var_const_str_ptr(name_arg, value_arg) + sys_var_const_os_str_ptr(sys_var_chain *chain, const char *name_arg, + char **value_arg) + :sys_var_const_str_ptr(chain, name_arg, value_arg) { is_os_charset= TRUE; } @@ -309,29 +356,49 @@ public: class sys_var_enum :public sys_var { - uint *value; + uint *value; TYPELIB *enum_names; public: - sys_var_enum(const char *name_arg, uint *value_arg, + sys_var_enum(sys_var_chain *chain, const char *name_arg, uint *value_arg, TYPELIB *typelib, sys_after_update_func func) :sys_var(name_arg,func), value(value_arg), enum_names(typelib) - {} + { chain_sys_var(chain); } bool check(THD *thd, set_var *var) { return check_enum(thd, var, enum_names); } bool update(THD *thd, set_var *var); SHOW_TYPE show_type() { return SHOW_CHAR; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); bool check_update_type(Item_result type) { return 0; } }; +class sys_var_enum_const :public sys_var +{ + ulong SV::*offset; + TYPELIB *enum_names; +public: + sys_var_enum_const(sys_var_chain *chain, const char *name_arg, ulong SV::*offset_arg, + TYPELIB *typelib, sys_after_update_func func) + :sys_var(name_arg,func), offset(offset_arg), enum_names(typelib) + { chain_sys_var(chain); } + bool check(THD *thd, set_var *var) { return 1; } + bool update(THD *thd, set_var *var) { return 1; } + SHOW_TYPE show_type() { return SHOW_CHAR; } + bool check_update_type(Item_result type) { return 1; } + bool is_readonly() const { return 1; } + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); +}; + + class sys_var_thd :public sys_var { public: - sys_var_thd(const char *name_arg, sys_after_update_func func= NULL) - :sys_var(name_arg,func) + sys_var_thd(const char *name_arg, + sys_after_update_func func= NULL, + Binlog_status_enum binlog_status= NOT_IN_BINLOG) + :sys_var(name_arg, func, binlog_status) {} bool check_type(enum_var_type type) { return 0; } bool check_default(enum_var_type type) @@ -346,18 +413,19 @@ class sys_var_thd_ulong :public sys_var_thd sys_check_func check_func; public: ulong SV::*offset; - sys_var_thd_ulong(const char *name_arg, ulong SV::*offset_arg) - :sys_var_thd(name_arg), check_func(0), offset(offset_arg) - {} - sys_var_thd_ulong(const char *name_arg, ulong SV::*offset_arg, - sys_check_func c_func, sys_after_update_func au_func) - :sys_var_thd(name_arg,au_func), check_func(c_func), offset(offset_arg) - {} + sys_var_thd_ulong(sys_var_chain *chain, const char *name_arg, + ulong SV::*offset_arg, + sys_check_func c_func= NULL, + sys_after_update_func au_func= NULL, + Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG) + :sys_var_thd(name_arg, au_func, binlog_status_arg), check_func(c_func), + offset(offset_arg) + { chain_sys_var(chain); } bool check(THD *thd, set_var *var); bool update(THD *thd, set_var *var); void set_default(THD *thd, enum_var_type type); SHOW_TYPE show_type() { return SHOW_LONG; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); }; @@ -365,17 +433,19 @@ class sys_var_thd_ha_rows :public sys_var_thd { public: ha_rows SV::*offset; - sys_var_thd_ha_rows(const char *name_arg, ha_rows SV::*offset_arg) + sys_var_thd_ha_rows(sys_var_chain *chain, const char *name_arg, + ha_rows SV::*offset_arg) :sys_var_thd(name_arg), offset(offset_arg) - {} - sys_var_thd_ha_rows(const char *name_arg, ha_rows SV::*offset_arg, + { chain_sys_var(chain); } + sys_var_thd_ha_rows(sys_var_chain *chain, const char *name_arg, + ha_rows SV::*offset_arg, sys_after_update_func func) :sys_var_thd(name_arg,func), offset(offset_arg) - {} + { chain_sys_var(chain); } bool update(THD *thd, set_var *var); void set_default(THD *thd, enum_var_type type); SHOW_TYPE show_type() { return SHOW_HA_ROWS; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); }; @@ -384,18 +454,20 @@ class sys_var_thd_ulonglong :public sys_var_thd public: ulonglong SV::*offset; bool only_global; - sys_var_thd_ulonglong(const char *name_arg, ulonglong SV::*offset_arg) + sys_var_thd_ulonglong(sys_var_chain *chain, const char *name_arg, + ulonglong SV::*offset_arg) :sys_var_thd(name_arg), offset(offset_arg) - {} - sys_var_thd_ulonglong(const char *name_arg, ulonglong SV::*offset_arg, + { chain_sys_var(chain); } + sys_var_thd_ulonglong(sys_var_chain *chain, const char *name_arg, + ulonglong SV::*offset_arg, sys_after_update_func func, bool only_global_arg) :sys_var_thd(name_arg, func), offset(offset_arg), only_global(only_global_arg) - {} + { chain_sys_var(chain); } bool update(THD *thd, set_var *var); void set_default(THD *thd, enum_var_type type); SHOW_TYPE show_type() { return SHOW_LONGLONG; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); bool check(THD *thd, set_var *var); bool check_default(enum_var_type type) { @@ -412,17 +484,17 @@ class sys_var_thd_bool :public sys_var_thd { public: my_bool SV::*offset; - sys_var_thd_bool(const char *name_arg, my_bool SV::*offset_arg) + sys_var_thd_bool(sys_var_chain *chain, const char *name_arg, my_bool SV::*offset_arg) :sys_var_thd(name_arg), offset(offset_arg) - {} - sys_var_thd_bool(const char *name_arg, my_bool SV::*offset_arg, + { chain_sys_var(chain); } + sys_var_thd_bool(sys_var_chain *chain, const char *name_arg, my_bool SV::*offset_arg, sys_after_update_func func) :sys_var_thd(name_arg,func), offset(offset_arg) - {} + { chain_sys_var(chain); } bool update(THD *thd, set_var *var); void set_default(THD *thd, enum_var_type type); SHOW_TYPE show_type() { return SHOW_MY_BOOL; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); bool check(THD *thd, set_var *var) { return check_enum(thd, var, &bool_typelib); @@ -436,24 +508,26 @@ class sys_var_thd_enum :public sys_var_thd protected: ulong SV::*offset; TYPELIB *enum_names; + sys_check_func check_func; public: - sys_var_thd_enum(const char *name_arg, ulong SV::*offset_arg, - TYPELIB *typelib) - :sys_var_thd(name_arg), offset(offset_arg), enum_names(typelib) - {} - sys_var_thd_enum(const char *name_arg, ulong SV::*offset_arg, - TYPELIB *typelib, - sys_after_update_func func) - :sys_var_thd(name_arg,func), offset(offset_arg), enum_names(typelib) - {} + sys_var_thd_enum(sys_var_chain *chain, const char *name_arg, + ulong SV::*offset_arg, TYPELIB *typelib, + sys_after_update_func func= NULL, + sys_check_func check= NULL) + :sys_var_thd(name_arg, func), offset(offset_arg), + enum_names(typelib), check_func(check) + { chain_sys_var(chain); } bool check(THD *thd, set_var *var) { - return check_enum(thd, var, enum_names); + int ret= 0; + if (check_func) + ret= (*check_func)(thd, var); + return ret ? ret : check_enum(thd, var, enum_names); } bool update(THD *thd, set_var *var); void set_default(THD *thd, enum_var_type type); SHOW_TYPE show_type() { return SHOW_CHAR; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); bool check_update_type(Item_result type) { return 0; } }; @@ -463,29 +537,31 @@ extern void fix_sql_mode_var(THD *thd, enum_var_type type); class sys_var_thd_sql_mode :public sys_var_thd_enum { public: - sys_var_thd_sql_mode(const char *name_arg, ulong SV::*offset_arg) - :sys_var_thd_enum(name_arg, offset_arg, &sql_mode_typelib, - fix_sql_mode_var) + sys_var_thd_sql_mode(sys_var_chain *chain, const char *name_arg, + ulong SV::*offset_arg) + :sys_var_thd_enum(chain, name_arg, offset_arg, &sql_mode_typelib, + fix_sql_mode_var) {} bool check(THD *thd, set_var *var) { return check_set(thd, var, enum_names); } void set_default(THD *thd, enum_var_type type); - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); - static byte *symbolic_mode_representation(THD *thd, ulong sql_mode, - ulong *length); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + static bool symbolic_mode_representation(THD *thd, ulonglong sql_mode, + LEX_STRING *rep); }; class sys_var_thd_storage_engine :public sys_var_thd { protected: - ulong SV::*offset; + plugin_ref SV::*offset; public: - sys_var_thd_storage_engine(const char *name_arg, ulong SV::*offset_arg) + sys_var_thd_storage_engine(sys_var_chain *chain, const char *name_arg, + plugin_ref SV::*offset_arg) :sys_var_thd(name_arg), offset(offset_arg) - {} + { chain_sys_var(chain); } bool check(THD *thd, set_var *var); SHOW_TYPE show_type() { return SHOW_CHAR; } bool check_update_type(Item_result type) @@ -494,14 +570,15 @@ public: } void set_default(THD *thd, enum_var_type type); bool update(THD *thd, set_var *var); - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); }; class sys_var_thd_table_type :public sys_var_thd_storage_engine { public: - sys_var_thd_table_type(const char *name_arg, ulong SV::*offset_arg) - :sys_var_thd_storage_engine(name_arg, offset_arg) + sys_var_thd_table_type(sys_var_chain *chain, const char *name_arg, + plugin_ref SV::*offset_arg) + :sys_var_thd_storage_engine(chain, name_arg, offset_arg) {} void warn_deprecated(THD *thd); void set_default(THD *thd, enum_var_type type); @@ -515,85 +592,89 @@ class sys_var_thd_bit :public sys_var_thd public: ulonglong bit_flag; bool reverse; - sys_var_thd_bit(const char *name_arg, + sys_var_thd_bit(sys_var_chain *chain, const char *name_arg, sys_check_func c_func, sys_update_func u_func, - ulonglong bit, bool reverse_arg=0) - :sys_var_thd(name_arg), check_func(c_func), update_func(u_func), - bit_flag(bit), reverse(reverse_arg) - {} + ulonglong bit, bool reverse_arg=0, + Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG) + :sys_var_thd(name_arg, NULL, binlog_status_arg), check_func(c_func), + update_func(u_func), bit_flag(bit), reverse(reverse_arg) + { chain_sys_var(chain); } bool check(THD *thd, set_var *var); bool update(THD *thd, set_var *var); bool check_update_type(Item_result type) { return 0; } bool check_type(enum_var_type type) { return type == OPT_GLOBAL; } SHOW_TYPE show_type() { return SHOW_MY_BOOL; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); }; +class sys_var_thd_dbug :public sys_var_thd +{ +public: + sys_var_thd_dbug(sys_var_chain *chain, const char *name_arg) + :sys_var_thd(name_arg) + { chain_sys_var(chain); } + bool check_update_type(Item_result type) { return type != STRING_RESULT; } + bool check(THD *thd, set_var *var); + SHOW_TYPE show_type() { return SHOW_CHAR; } + bool update(THD *thd, set_var *var); + void set_default(THD *thd, enum_var_type type) { DBUG_POP(); } + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *b); +}; + + /* some variables that require special handling */ class sys_var_timestamp :public sys_var { public: - sys_var_timestamp(const char *name_arg) :sys_var(name_arg) {} + sys_var_timestamp(sys_var_chain *chain, const char *name_arg, + Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG) + :sys_var(name_arg, NULL, binlog_status_arg) + { chain_sys_var(chain); } bool update(THD *thd, set_var *var); void set_default(THD *thd, enum_var_type type); bool check_type(enum_var_type type) { return type == OPT_GLOBAL; } bool check_default(enum_var_type type) { return 0; } SHOW_TYPE show_type() { return SHOW_LONG; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); }; class sys_var_last_insert_id :public sys_var { public: - sys_var_last_insert_id(const char *name_arg) :sys_var(name_arg) {} + sys_var_last_insert_id(sys_var_chain *chain, const char *name_arg, + Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG) + :sys_var(name_arg, NULL, binlog_status_arg) + { chain_sys_var(chain); } bool update(THD *thd, set_var *var); bool check_type(enum_var_type type) { return type == OPT_GLOBAL; } SHOW_TYPE show_type() { return SHOW_LONGLONG; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); }; class sys_var_insert_id :public sys_var { public: - sys_var_insert_id(const char *name_arg) :sys_var(name_arg) {} + sys_var_insert_id(sys_var_chain *chain, const char *name_arg) + :sys_var(name_arg) + { chain_sys_var(chain); } bool update(THD *thd, set_var *var); bool check_type(enum_var_type type) { return type == OPT_GLOBAL; } SHOW_TYPE show_type() { return SHOW_LONGLONG; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); -}; - - -#ifdef HAVE_REPLICATION -class sys_var_slave_skip_counter :public sys_var -{ -public: - sys_var_slave_skip_counter(const char *name_arg) :sys_var(name_arg) {} - bool check(THD *thd, set_var *var); - bool update(THD *thd, set_var *var); - bool check_type(enum_var_type type) { return type != OPT_GLOBAL; } - /* - We can't retrieve the value of this, so we don't have to define - type() or value_ptr() - */ + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); }; -class sys_var_sync_binlog_period :public sys_var_long_ptr -{ -public: - sys_var_sync_binlog_period(const char *name_arg, ulong *value_ptr_arg) - :sys_var_long_ptr(name_arg,value_ptr_arg) {} - bool update(THD *thd, set_var *var); -}; -#endif class sys_var_rand_seed1 :public sys_var { public: - sys_var_rand_seed1(const char *name_arg) :sys_var(name_arg) {} + sys_var_rand_seed1(sys_var_chain *chain, const char *name_arg, + Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG) + :sys_var(name_arg, NULL, binlog_status_arg) + { chain_sys_var(chain); } bool update(THD *thd, set_var *var); bool check_type(enum_var_type type) { return type == OPT_GLOBAL; } }; @@ -601,7 +682,10 @@ public: class sys_var_rand_seed2 :public sys_var { public: - sys_var_rand_seed2(const char *name_arg) :sys_var(name_arg) {} + sys_var_rand_seed2(sys_var_chain *chain, const char *name_arg, + Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG) + :sys_var(name_arg, NULL, binlog_status_arg) + { chain_sys_var(chain); } bool update(THD *thd, set_var *var); bool check_type(enum_var_type type) { return type == OPT_GLOBAL; } }; @@ -610,10 +694,12 @@ public: class sys_var_collation :public sys_var_thd { public: - sys_var_collation(const char *name_arg) :sys_var_thd(name_arg) - { + sys_var_collation(const char *name_arg, + Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG) + :sys_var_thd(name_arg, NULL, binlog_status_arg) + { no_support_one_shot= 0; - } + } bool check(THD *thd, set_var *var); SHOW_TYPE show_type() { return SHOW_CHAR; } bool check_update_type(Item_result type) @@ -628,10 +714,10 @@ class sys_var_character_set :public sys_var_thd { public: bool nullable; - sys_var_character_set(const char *name_arg) : - sys_var_thd(name_arg) + sys_var_character_set(const char *name_arg, bool is_nullable= 0, + Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG) + :sys_var_thd(name_arg, NULL, binlog_status_arg), nullable(is_nullable) { - nullable= 0; /* In fact only almost all variables derived from sys_var_character_set support ONE_SHOT; character_set_results doesn't. But that's good enough. @@ -646,92 +732,72 @@ public: } bool check_default(enum_var_type type) { return 0; } bool update(THD *thd, set_var *var); - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); virtual void set_default(THD *thd, enum_var_type type)= 0; virtual CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type)= 0; }; -class sys_var_character_set_filesystem :public sys_var_character_set +class sys_var_character_set_sv :public sys_var_character_set { + CHARSET_INFO *SV::*offset; + CHARSET_INFO **global_default; public: - sys_var_character_set_filesystem(const char *name_arg) : - sys_var_character_set(name_arg) {} + sys_var_character_set_sv(sys_var_chain *chain, const char *name_arg, + CHARSET_INFO *SV::*offset_arg, + CHARSET_INFO **global_default_arg, + bool is_nullable= 0, + Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG) + : sys_var_character_set(name_arg, is_nullable, binlog_status_arg), + offset(offset_arg), global_default(global_default_arg) + { chain_sys_var(chain); } void set_default(THD *thd, enum_var_type type); CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type); }; -class sys_var_character_set_client :public sys_var_character_set -{ -public: - sys_var_character_set_client(const char *name_arg) : - sys_var_character_set(name_arg) {} - void set_default(THD *thd, enum_var_type type); - CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type); - bool check(THD *thd, set_var *var); -}; -class sys_var_character_set_results :public sys_var_character_set +class sys_var_character_set_client: public sys_var_character_set_sv { public: - sys_var_character_set_results(const char *name_arg) : - sys_var_character_set(name_arg) - { nullable= 1; } - void set_default(THD *thd, enum_var_type type); - CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type); + sys_var_character_set_client(sys_var_chain *chain, const char *name_arg, + CHARSET_INFO *SV::*offset_arg, + CHARSET_INFO **global_default_arg, + Binlog_status_enum binlog_status_arg) + : sys_var_character_set_sv(chain, name_arg, offset_arg, global_default_arg, + 0, binlog_status_arg) + { } + bool check(THD *thd, set_var *var); }; -class sys_var_character_set_server :public sys_var_character_set -{ -public: - sys_var_character_set_server(const char *name_arg) : - sys_var_character_set(name_arg) {} - void set_default(THD *thd, enum_var_type type); - CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type); -}; class sys_var_character_set_database :public sys_var_character_set { public: - sys_var_character_set_database(const char *name_arg) : - sys_var_character_set(name_arg) {} + sys_var_character_set_database(sys_var_chain *chain, const char *name_arg, + Binlog_status_enum binlog_status_arg= + NOT_IN_BINLOG) + : sys_var_character_set(name_arg, 0, binlog_status_arg) + { chain_sys_var(chain); } void set_default(THD *thd, enum_var_type type); CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type); }; -class sys_var_character_set_connection :public sys_var_character_set -{ -public: - sys_var_character_set_connection(const char *name_arg) : - sys_var_character_set(name_arg) {} - void set_default(THD *thd, enum_var_type type); - CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type); -}; - -class sys_var_collation_connection :public sys_var_collation -{ -public: - sys_var_collation_connection(const char *name_arg) :sys_var_collation(name_arg) {} - bool update(THD *thd, set_var *var); - void set_default(THD *thd, enum_var_type type); - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); -}; - -class sys_var_collation_server :public sys_var_collation +class sys_var_collation_sv :public sys_var_collation { + CHARSET_INFO *SV::*offset; + CHARSET_INFO **global_default; public: - sys_var_collation_server(const char *name_arg) :sys_var_collation(name_arg) {} - bool update(THD *thd, set_var *var); - void set_default(THD *thd, enum_var_type type); - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); -}; - -class sys_var_collation_database :public sys_var_collation -{ -public: - sys_var_collation_database(const char *name_arg) :sys_var_collation(name_arg) {} + sys_var_collation_sv(sys_var_chain *chain, const char *name_arg, + CHARSET_INFO *SV::*offset_arg, + CHARSET_INFO **global_default_arg, + Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG) + :sys_var_collation(name_arg, binlog_status_arg), + offset(offset_arg), global_default(global_default_arg) + { + chain_sys_var(chain); + } bool update(THD *thd, set_var *var); void set_default(THD *thd, enum_var_type type); - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); }; @@ -740,10 +806,11 @@ class sys_var_key_cache_param :public sys_var protected: size_t offset; public: - sys_var_key_cache_param(const char *name_arg, size_t offset_arg) + sys_var_key_cache_param(sys_var_chain *chain, const char *name_arg, + size_t offset_arg) :sys_var(name_arg), offset(offset_arg) - {} - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + { chain_sys_var(chain); } + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); bool check_default(enum_var_type type) { return 1; } bool is_struct() { return 1; } }; @@ -752,8 +819,9 @@ public: class sys_var_key_buffer_size :public sys_var_key_cache_param { public: - sys_var_key_buffer_size(const char *name_arg) - :sys_var_key_cache_param(name_arg, offsetof(KEY_CACHE, param_buff_size)) + sys_var_key_buffer_size(sys_var_chain *chain, const char *name_arg) + :sys_var_key_cache_param(chain, name_arg, + offsetof(KEY_CACHE, param_buff_size)) {} bool update(THD *thd, set_var *var); SHOW_TYPE show_type() { return SHOW_LONGLONG; } @@ -763,8 +831,8 @@ public: class sys_var_key_cache_long :public sys_var_key_cache_param { public: - sys_var_key_cache_long(const char *name_arg, size_t offset_arg) - :sys_var_key_cache_param(name_arg, offset_arg) + sys_var_key_cache_long(sys_var_chain *chain, const char *name_arg, size_t offset_arg) + :sys_var_key_cache_param(chain, name_arg, offset_arg) {} bool update(THD *thd, set_var *var); SHOW_TYPE show_type() { return SHOW_LONG; } @@ -776,12 +844,12 @@ class sys_var_thd_date_time_format :public sys_var_thd DATE_TIME_FORMAT *SV::*offset; timestamp_type date_time_type; public: - sys_var_thd_date_time_format(const char *name_arg, + sys_var_thd_date_time_format(sys_var_chain *chain, const char *name_arg, DATE_TIME_FORMAT *SV::*offset_arg, timestamp_type date_time_type_arg) :sys_var_thd(name_arg), offset(offset_arg), date_time_type(date_time_type_arg) - {} + { chain_sys_var(chain); } SHOW_TYPE show_type() { return SHOW_CHAR; } bool check_update_type(Item_result type) { @@ -791,11 +859,83 @@ public: bool check(THD *thd, set_var *var); bool update(THD *thd, set_var *var); void update2(THD *thd, enum_var_type type, DATE_TIME_FORMAT *new_value); - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); void set_default(THD *thd, enum_var_type type); }; +class sys_var_log_state :public sys_var_bool_ptr +{ + uint log_type; +public: + sys_var_log_state(sys_var_chain *chain, const char *name_arg, my_bool *value_arg, + uint log_type_arg) + :sys_var_bool_ptr(chain, name_arg, value_arg), log_type(log_type_arg) {} + bool update(THD *thd, set_var *var); + void set_default(THD *thd, enum_var_type type); +}; + + +class sys_var_set :public sys_var +{ +protected: + ulong *value; + TYPELIB *enum_names; +public: + sys_var_set(sys_var_chain *chain, const char *name_arg, ulong *value_arg, + TYPELIB *typelib, sys_after_update_func func) + :sys_var(name_arg, func), value(value_arg), enum_names(typelib) + { chain_sys_var(chain); } + virtual bool check(THD *thd, set_var *var) + { + return check_set(thd, var, enum_names); + } + virtual void set_default(THD *thd, enum_var_type type) + { + *value= 0; + } + bool update(THD *thd, set_var *var); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + bool check_update_type(Item_result type) { return 0; } + SHOW_TYPE show_type() { return SHOW_CHAR; } +}; + +class sys_var_set_slave_mode :public sys_var_set +{ +public: + sys_var_set_slave_mode(sys_var_chain *chain, const char *name_arg, + ulong *value_arg, + TYPELIB *typelib, sys_after_update_func func) : + sys_var_set(chain, name_arg, value_arg, typelib, func) {} + void set_default(THD *thd, enum_var_type type); + bool check(THD *thd, set_var *var); + bool update(THD *thd, set_var *var); +}; + +class sys_var_log_output :public sys_var +{ + ulong *value; + TYPELIB *enum_names; +public: + sys_var_log_output(sys_var_chain *chain, const char *name_arg, ulong *value_arg, + TYPELIB *typelib, sys_after_update_func func) + :sys_var(name_arg,func), value(value_arg), enum_names(typelib) + { + chain_sys_var(chain); + set_allow_empty_value(FALSE); + } + virtual bool check(THD *thd, set_var *var) + { + return check_set(thd, var, enum_names); + } + bool update(THD *thd, set_var *var); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + bool check_update_type(Item_result type) { return 0; } + void set_default(THD *thd, enum_var_type type); + SHOW_TYPE show_type() { return SHOW_CHAR; } +}; + + /* Variable that you can only read from */ class sys_var_readonly: public sys_var @@ -804,17 +944,17 @@ public: enum_var_type var_type; SHOW_TYPE show_type_value; sys_value_ptr_func value_ptr_func; - sys_var_readonly(const char *name_arg, enum_var_type type, + sys_var_readonly(sys_var_chain *chain, const char *name_arg, enum_var_type type, SHOW_TYPE show_type_arg, sys_value_ptr_func value_ptr_func_arg) :sys_var(name_arg), var_type(type), show_type_value(show_type_arg), value_ptr_func(value_ptr_func_arg) - {} + { chain_sys_var(chain); } bool update(THD *thd, set_var *var) { return 1; } bool check_default(enum_var_type type) { return 1; } bool check_type(enum_var_type type) { return type != var_type; } bool check_update_type(Item_result type) { return 1; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) { return (*value_ptr_func)(thd); } @@ -826,23 +966,123 @@ public: class sys_var_readonly_os: public sys_var_readonly { public: - sys_var_readonly_os(const char *name_arg, enum_var_type type, + sys_var_readonly_os(sys_var_chain *chain, const char *name_arg, enum_var_type type, SHOW_TYPE show_type_arg, sys_value_ptr_func value_ptr_func_arg) - :sys_var_readonly(name_arg, type, show_type_arg, value_ptr_func_arg) + :sys_var_readonly(chain, name_arg, type, show_type_arg, value_ptr_func_arg) { is_os_charset= TRUE; } }; +/** + Global-only, read-only variable. E.g. command line option. +*/ + +class sys_var_const: public sys_var +{ +public: + enum_var_type var_type; + SHOW_TYPE show_type_value; + uchar *ptr; + sys_var_const(sys_var_chain *chain, const char *name_arg, enum_var_type type, + SHOW_TYPE show_type_arg, uchar *ptr_arg) + :sys_var(name_arg), var_type(type), + show_type_value(show_type_arg), ptr(ptr_arg) + { chain_sys_var(chain); } + bool update(THD *thd, set_var *var) { return 1; } + bool check_default(enum_var_type type) { return 1; } + bool check_type(enum_var_type type) { return type != var_type; } + bool check_update_type(Item_result type) { return 1; } + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) + { + return ptr; + } + SHOW_TYPE show_type() { return show_type_value; } + bool is_readonly() const { return 1; } +}; + + +class sys_var_const_os: public sys_var_const +{ +public: + enum_var_type var_type; + SHOW_TYPE show_type_value; + uchar *ptr; + sys_var_const_os(sys_var_chain *chain, const char *name_arg, + enum_var_type type, + SHOW_TYPE show_type_arg, uchar *ptr_arg) + :sys_var_const(chain, name_arg, type, show_type_arg, ptr_arg) + { + is_os_charset= TRUE; + } +}; + + +class sys_var_have_option: public sys_var +{ +protected: + virtual SHOW_COMP_OPTION get_option() = 0; +public: + sys_var_have_option(sys_var_chain *chain, const char *variable_name): + sys_var(variable_name) + { chain_sys_var(chain); } + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base) + { + return (uchar*) show_comp_option_name[get_option()]; + } + bool update(THD *thd, set_var *var) { return 1; } + bool check_default(enum_var_type type) { return 1; } + bool check_type(enum_var_type type) { return type != OPT_GLOBAL; } + bool check_update_type(Item_result type) { return 1; } + SHOW_TYPE show_type() { return SHOW_CHAR; } + bool is_readonly() const { return 1; } +}; + + +class sys_var_have_variable: public sys_var_have_option +{ + SHOW_COMP_OPTION *have_variable; + +public: + sys_var_have_variable(sys_var_chain *chain, const char *variable_name, + SHOW_COMP_OPTION *have_variable_arg): + sys_var_have_option(chain, variable_name), + have_variable(have_variable_arg) + { } + SHOW_COMP_OPTION get_option() { return *have_variable; } +}; + + +class sys_var_have_plugin: public sys_var_have_option +{ + const char *plugin_name_str; + const uint plugin_name_len; + const int plugin_type; + +public: + sys_var_have_plugin(sys_var_chain *chain, const char *variable_name, + const char *plugin_name_str_arg, uint plugin_name_len_arg, + int plugin_type_arg): + sys_var_have_option(chain, variable_name), + plugin_name_str(plugin_name_str_arg), plugin_name_len(plugin_name_len_arg), + plugin_type(plugin_type_arg) + { } + /* the following method is declared in sql_plugin.cc */ + SHOW_COMP_OPTION get_option(); +}; + + class sys_var_thd_time_zone :public sys_var_thd { public: - sys_var_thd_time_zone(const char *name_arg): - sys_var_thd(name_arg) + sys_var_thd_time_zone(sys_var_chain *chain, const char *name_arg, + Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG) + :sys_var_thd(name_arg, NULL, binlog_status_arg) { no_support_one_shot= 0; + chain_sys_var(chain); } bool check(THD *thd, set_var *var); SHOW_TYPE show_type() { return SHOW_CHAR; } @@ -852,7 +1092,7 @@ public: } bool check_default(enum_var_type type) { return 0; } bool update(THD *thd, set_var *var); - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); virtual void set_default(THD *thd, enum_var_type type); }; @@ -860,8 +1100,9 @@ public: class sys_var_max_user_conn : public sys_var_thd { public: - sys_var_max_user_conn(const char *name_arg): - sys_var_thd(name_arg) {} + sys_var_max_user_conn(sys_var_chain *chain, const char *name_arg): + sys_var_thd(name_arg) + { chain_sys_var(chain); } bool check(THD *thd, set_var *var); bool update(THD *thd, set_var *var); bool check_default(enum_var_type type) @@ -870,30 +1111,92 @@ public: } void set_default(THD *thd, enum_var_type type); SHOW_TYPE show_type() { return SHOW_INT; } - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); +}; + + +/** + * @brief This is a specialization of sys_var_thd_ulong that implements a + read-only session variable. The class overrides check() and check_default() + to achieve the read-only property for the session part of the variable. + */ +class sys_var_thd_ulong_session_readonly : public sys_var_thd_ulong +{ +public: + sys_var_thd_ulong_session_readonly(sys_var_chain *chain_arg, + const char *name_arg, ulong SV::*offset_arg, + sys_check_func c_func= NULL, + sys_after_update_func au_func= NULL, + Binlog_status_enum bl_status_arg= NOT_IN_BINLOG): + sys_var_thd_ulong(chain_arg, name_arg, offset_arg, c_func, au_func, bl_status_arg) + { } + bool check(THD *thd, set_var *var); + bool check_default(enum_var_type type) + { + return type != OPT_GLOBAL || !option_limits; + } +}; + + +class sys_var_microseconds :public sys_var_thd +{ + ulonglong SV::*offset; +public: + sys_var_microseconds(sys_var_chain *chain, const char *name_arg, + ulonglong SV::*offset_arg): + sys_var_thd(name_arg), offset(offset_arg) + { chain_sys_var(chain); } + bool check(THD *thd, set_var *var) {return 0;} + bool update(THD *thd, set_var *var); + void set_default(THD *thd, enum_var_type type); + SHOW_TYPE show_type() { return SHOW_DOUBLE; } + bool check_update_type(Item_result type) + { + return (type != INT_RESULT && type != REAL_RESULT && type != DECIMAL_RESULT); + } + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); }; + class sys_var_trust_routine_creators :public sys_var_bool_ptr { /* We need a derived class only to have a warn_deprecated() */ public: - sys_var_trust_routine_creators(const char *name_arg, my_bool *value_arg) : - sys_var_bool_ptr(name_arg, value_arg) {}; + sys_var_trust_routine_creators(sys_var_chain *chain, + const char *name_arg, my_bool *value_arg) : + sys_var_bool_ptr(chain, name_arg, value_arg) {}; void warn_deprecated(THD *thd); void set_default(THD *thd, enum_var_type type); bool update(THD *thd, set_var *var); }; +/** + Handler for setting the system variable --read-only. +*/ + +class sys_var_opt_readonly :public sys_var_bool_ptr +{ +public: + sys_var_opt_readonly(sys_var_chain *chain, const char *name_arg, + my_bool *value_arg) : + sys_var_bool_ptr(chain, name_arg, value_arg) {}; + ~sys_var_opt_readonly() {}; + bool update(THD *thd, set_var *var); +}; + + class sys_var_thd_lc_time_names :public sys_var_thd { public: - sys_var_thd_lc_time_names(const char *name_arg): - sys_var_thd(name_arg) + sys_var_thd_lc_time_names(sys_var_chain *chain, const char *name_arg, + Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG) + : sys_var_thd(name_arg, NULL, binlog_status_arg) { #if MYSQL_VERSION_ID < 50000 no_support_one_shot= 0; #endif + chain_sys_var(chain); } bool check(THD *thd, set_var *var); SHOW_TYPE show_type() { return SHOW_CHAR; } @@ -903,10 +1206,43 @@ public: } bool check_default(enum_var_type type) { return 0; } bool update(THD *thd, set_var *var); - byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); virtual void set_default(THD *thd, enum_var_type type); }; +#ifdef HAVE_EVENT_SCHEDULER +class sys_var_event_scheduler :public sys_var_long_ptr +{ + /* We need a derived class only to have a warn_deprecated() */ +public: + sys_var_event_scheduler(sys_var_chain *chain, const char *name_arg) : + sys_var_long_ptr(chain, name_arg, NULL, NULL) {}; + bool update(THD *thd, set_var *var); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + SHOW_TYPE show_type() { return SHOW_CHAR; } + bool check(THD *thd, set_var *var); + bool check_update_type(Item_result type) + { + return type != STRING_RESULT && type != INT_RESULT; + } +}; +#endif + +extern void fix_binlog_format_after_update(THD *thd, enum_var_type type); + +class sys_var_thd_binlog_format :public sys_var_thd_enum +{ +public: + sys_var_thd_binlog_format(sys_var_chain *chain, const char *name_arg, + ulong SV::*offset_arg) + :sys_var_thd_enum(chain, name_arg, offset_arg, + &binlog_format_typelib, + fix_binlog_format_after_update) + {}; + bool check(THD *thd, set_var *var); + bool is_readonly() const; +}; + /**************************************************************************** Classes for parsing of the SET command ****************************************************************************/ @@ -937,6 +1273,7 @@ public: CHARSET_INFO *charset; ulong ulong_value; ulonglong ulonglong_value; + plugin_ref plugin; DATE_TIME_FORMAT *date_time_format; Time_zone *time_zone; MY_LOCALE *locale_value; @@ -1018,6 +1355,11 @@ public: }; +extern "C" +{ + typedef int (*process_key_cache_t) (const char *, KEY_CACHE *); +} + /* Named lists (used for keycaches) */ class NAMED_LIST :public ilink @@ -1025,13 +1367,13 @@ class NAMED_LIST :public ilink const char *name; uint name_length; public: - gptr data; + uchar* data; NAMED_LIST(I_List<NAMED_LIST> *links, const char *name_arg, - uint name_length_arg, gptr data_arg) + uint name_length_arg, uchar* data_arg) :name_length(name_length_arg), data(data_arg) { - name= my_strdup_with_length(name_arg, name_length, MYF(MY_WME)); + name= my_strndup(name_arg, name_length, MYF(MY_WME)); links->push_back(this); } inline bool cmp(const char *name_cmp, uint length) @@ -1040,16 +1382,16 @@ public: } ~NAMED_LIST() { - my_free((char*) name, MYF(0)); + my_free((uchar*) name, MYF(0)); } - friend bool process_key_caches(int (* func) (const char *name, - KEY_CACHE *)); + friend bool process_key_caches(process_key_cache_t func); friend void delete_elements(I_List<NAMED_LIST> *list, - void (*free_element)(const char*, gptr)); + void (*free_element)(const char*, uchar*)); }; /* updated in sql_acl.cc */ +extern sys_var_thd_bool sys_old_alter_table; extern sys_var_thd_bool sys_old_passwords; extern LEX_STRING default_key_cache_base; @@ -1064,12 +1406,16 @@ struct sys_var_with_base Prototypes for helper functions */ -void set_var_init(); +int set_var_init(); void set_var_free(); -sys_var *find_sys_var(const char *str, uint length=0); +SHOW_VAR* enumerate_sys_vars(THD *thd, bool sorted); +int mysql_add_sys_var_chain(sys_var *chain, struct my_option *long_options); +int mysql_del_sys_var_chain(sys_var *chain); +sys_var *find_sys_var(THD *thd, const char *str, uint length=0); int sql_set_variables(THD *thd, List<set_var_base> *var_list); bool not_all_support_one_shot(List<set_var_base> *var_list); void fix_delay_key_write(THD *thd, enum_var_type type); +void fix_slave_exec_mode(enum_var_type type); ulong fix_sql_mode(ulong sql_mode); extern sys_var_const_str sys_charset_system; extern sys_var_str sys_init_connect; @@ -1077,13 +1423,15 @@ extern sys_var_str sys_init_slave; extern sys_var_thd_time_zone sys_time_zone; extern sys_var_thd_bit sys_autocommit; CHARSET_INFO *get_old_charset_by_name(const char *old_name); -gptr find_named(I_List<NAMED_LIST> *list, const char *name, uint length, +uchar* find_named(I_List<NAMED_LIST> *list, const char *name, uint length, NAMED_LIST **found); +extern sys_var_str sys_var_general_log_path, sys_var_slow_log_path; + /* key_cache functions */ KEY_CACHE *get_key_cache(LEX_STRING *cache_name); KEY_CACHE *get_or_create_key_cache(const char *name, uint length); void free_key_cache(const char *name, KEY_CACHE *key_cache); -bool process_key_caches(int (* func) (const char *name, KEY_CACHE *)); +bool process_key_caches(process_key_cache_t func); void delete_elements(I_List<NAMED_LIST> *list, - void (*free_element)(const char*, gptr)); + void (*free_element)(const char*, uchar*)); |