mirror of
https://github.com/MariaDB/server.git
synced 2025-01-16 12:02:42 +01:00
0eb26fdfa8
Apart strict-aliasing warnings, fix the remaining warnings generated by GCC 4.4.4 -Wall and -Wextra flags. One major source of warnings was the in-house function my_bcmp which (unconventionally) took pointers to unsigned characters as the byte sequences to be compared. Since my_bcmp and bcmp are deprecated functions whose only difference with memcmp is the return value, every use of the function is replaced with memcmp as the special return value wasn't actually being used by any caller. There were also various other warnings, mostly due to type mismatches, missing return values, missing prototypes, dead code (unreachable) and ignored return values. BUILD/SETUP.sh: Remove flags that are implied by -Wall and -Wextra. Do not warn about unused parameters in C++. BUILD/check-cpu: Print only the compiler version instead of verbose banner. Although the option is gcc specific, the check was only being used for GCC specific checks anyway. client/mysql.cc: bcmp is no longer defined. client/mysqltest.cc: Pass a string to function expecting a format string. Replace use of bcmp with memcmp. cmd-line-utils/readline/Makefile.am: Always define _GNU_SOURCE when compiling GNU readline. Required to make certain prototypes visible. cmd-line-utils/readline/input.c: Condition for the code to be meaningful. configure.in: Remove check for bcmp. extra/comp_err.c: Use appropriate type. extra/replace.c: Replace use of bcmp with memcmp. extra/yassl/src/crypto_wrapper.cpp: Do not ignore the return value of fgets. Retrieve the file position if fgets succeed -- if it fails, the function will bail out and return a error. extra/yassl/taocrypt/include/blowfish.hpp: Use a single array instead of accessing positions of the sbox_ through a subscript to pbox_. extra/yassl/taocrypt/include/runtime.hpp: One definition of such functions is enough. extra/yassl/taocrypt/src/aes.cpp: Avoid potentially ambiguous conditions. extra/yassl/taocrypt/src/algebra.cpp: Rename arguments to avoid shadowing related warnings. extra/yassl/taocrypt/src/blowfish.cpp: Avoid potentially ambiguous conditions. extra/yassl/taocrypt/src/integer.cpp: Do not define type within a anonymous union. Use a variable to return a value instead of leaving the result in a register -- compiler does not know the logic inside the asm. extra/yassl/taocrypt/src/misc.cpp: Define handler for pure virtual functions. Remove unused code. extra/yassl/taocrypt/src/twofish.cpp: Avoid potentially ambiguous conditions. extra/yassl/testsuite/test.hpp: Function must have C language linkage. include/m_string.h: Remove check which relied on bcmp being defined -- they weren't being used as bcmp is only visible when _BSD_SOURCE is defined. include/my_bitmap.h: Remove bogus helpers which were used only in a few files and were causing warnings about dead code. include/my_global.h: Due to G++ bug, always silence false-positive uninitialized variables warnings when compiling C++ code with G++. Remove bogus helper. libmysql/Makefile.shared: Remove built-in implementation of bcmp. mysql-test/lib/My/SafeProcess/safe_process.cc: Cast pid to largest possible type for a process identifier. mysys/mf_loadpath.c: Leave space of the ending nul. mysys/mf_pack.c: Replace bcmp with memcmp. mysys/my_bitmap.c: Dead code removal. mysys/my_gethwaddr.c: Remove unused variable. mysys/my_getopt.c: Silence bogus uninitialized variable warning. Do not cast away the constant qualifier. mysys/safemalloc.c: Cast to expected type. mysys/thr_lock.c: Silence bogus uninitialized variable warning. sql/field.cc: Replace bogus helper with a more appropriate logic which is used throughout the code. sql/item.cc: Remove bogus logical condition which always evaluates to TRUE. sql/item_create.cc: Simplify code to avoid signedness related warnings. sql/log_event.cc: Replace use of bcmp with memcmp. No need to use helpers for simple bit operations. sql/log_event_old.cc: Replace bmove_align with memcpy. sql/mysqld.cc: Move use declaration of variable to the ifdef block where it is used. Remove now-unnecessary casts and arguments. sql/set_var.cc: Replace bogus helpers with simple and classic bit operations. sql/slave.cc: Cast to expected type and silence bogus warning. sql/sql_class.h: Don't use enum values as bit flags, the supposed type safety is bogus as the combined bit flags are not a value in the enumeration. sql/udf_example.c: Only declare variable when necessary. sql/unireg.h: Replace use of bmove_align with memcpy. storage/innobase/os/os0file.c: Silence bogus warning. storage/myisam/mi_open.c: Remove bogus cast, DBUG_DUMP expects a pointer to unsigned char. storage/myisam/mi_page.c: Remove bogus cast, DBUG_DUMP expects a pointer to unsigned char. strings/bcmp.c: Remove built-in bcmp. strings/ctype-ucs2.c: Silence bogus warning. tests/mysql_client_test.c: Use a appropriate type as expected by simple_command().
1468 lines
45 KiB
C++
1468 lines
45 KiB
C++
/* Copyright (C) 2002-2006 MySQL AB
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
|
|
|
/* Classes to support the SET command */
|
|
|
|
#ifdef USE_PRAGMA_INTERFACE
|
|
#pragma interface /* gcc class implementation */
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
Variables that are changable runtime are declared using the
|
|
following classes
|
|
****************************************************************************/
|
|
|
|
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,
|
|
optimizer_switch_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 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;
|
|
/*
|
|
true if the value is in character_set_filesystem,
|
|
false otherwise.
|
|
Note that we can't use a pointer to the charset as the system var is
|
|
instantiated in global scope and the charset pointers are initialized
|
|
later.
|
|
*/
|
|
bool is_os_charset;
|
|
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, 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 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 */
|
|
virtual bool check_update_type(Item_result type)
|
|
{ return type != INT_RESULT; } /* Assume INT */
|
|
virtual bool check_default(enum_var_type type)
|
|
{ return option_limits == 0; }
|
|
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;
|
|
};
|
|
|
|
|
|
/*
|
|
A base class for all variables that require its access to
|
|
be guarded with a mutex.
|
|
*/
|
|
|
|
class sys_var_global: public sys_var
|
|
{
|
|
protected:
|
|
pthread_mutex_t *guard;
|
|
public:
|
|
sys_var_global(const char *name_arg, sys_after_update_func after_update_arg,
|
|
pthread_mutex_t *guard_arg)
|
|
:sys_var(name_arg, after_update_arg), guard(guard_arg) {}
|
|
};
|
|
|
|
|
|
/*
|
|
A global-only ulong variable that requires its access to be
|
|
protected with a mutex.
|
|
*/
|
|
|
|
class sys_var_long_ptr_global: public sys_var_global
|
|
{
|
|
public:
|
|
ulong *value;
|
|
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; }
|
|
uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
|
|
{ return (uchar*) value; }
|
|
};
|
|
|
|
|
|
/*
|
|
A global ulong variable that is protected by LOCK_global_system_variables
|
|
*/
|
|
|
|
class sys_var_long_ptr :public sys_var_long_ptr_global
|
|
{
|
|
public:
|
|
sys_var_long_ptr(sys_var_chain *chain, const char *name_arg, ulong *value_ptr,
|
|
sys_after_update_func after_update_arg= NULL);
|
|
};
|
|
|
|
|
|
class sys_var_ulonglong_ptr :public sys_var
|
|
{
|
|
public:
|
|
ulonglong *value;
|
|
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)
|
|
{ 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; }
|
|
uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
|
|
{ return (uchar*) value; }
|
|
};
|
|
|
|
|
|
class sys_var_bool_ptr :public sys_var
|
|
{
|
|
public:
|
|
my_bool *value;
|
|
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);
|
|
}
|
|
bool update(THD *thd, set_var *var);
|
|
void set_default(THD *thd, enum_var_type type);
|
|
SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
|
|
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_ptr_readonly :public sys_var_bool_ptr
|
|
{
|
|
public:
|
|
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 is_readonly() const { return 1; }
|
|
};
|
|
|
|
|
|
class sys_var_str :public sys_var
|
|
{
|
|
public:
|
|
char *value; // Pointer to allocated string
|
|
uint value_length;
|
|
sys_check_func check_func;
|
|
sys_update_func update_func;
|
|
sys_set_default_func set_default_func;
|
|
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)
|
|
{
|
|
return (*update_func)(thd, var);
|
|
}
|
|
void set_default(THD *thd, enum_var_type type)
|
|
{
|
|
(*set_default_func)(thd, type);
|
|
}
|
|
SHOW_TYPE show_type() { return SHOW_CHAR; }
|
|
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 */
|
|
}
|
|
bool check_default(enum_var_type type) { return 0; }
|
|
};
|
|
|
|
|
|
class sys_var_const_str :public sys_var
|
|
{
|
|
public:
|
|
char *value; // Pointer to const value
|
|
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;
|
|
}
|
|
bool update(THD *thd, set_var *var)
|
|
{
|
|
return 1;
|
|
}
|
|
SHOW_TYPE show_type() { return SHOW_CHAR; }
|
|
uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
|
|
{
|
|
return (uchar*) value;
|
|
}
|
|
bool check_update_type(Item_result type)
|
|
{
|
|
return 1;
|
|
}
|
|
bool check_default(enum_var_type type) { return 1; }
|
|
bool is_readonly() const { return 1; }
|
|
};
|
|
|
|
|
|
class sys_var_const_os_str: public sys_var_const_str
|
|
{
|
|
public:
|
|
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;
|
|
}
|
|
};
|
|
|
|
|
|
class sys_var_const_str_ptr :public sys_var
|
|
{
|
|
public:
|
|
char **value; // Pointer to const value
|
|
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;
|
|
}
|
|
bool update(THD *thd, set_var *var)
|
|
{
|
|
return 1;
|
|
}
|
|
SHOW_TYPE show_type() { return SHOW_CHAR; }
|
|
uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
|
|
{
|
|
return (uchar*) *value;
|
|
}
|
|
bool check_update_type(Item_result type)
|
|
{
|
|
return 1;
|
|
}
|
|
bool check_default(enum_var_type type) { return 1; }
|
|
bool is_readonly() const { return 1; }
|
|
};
|
|
|
|
|
|
class sys_var_const_os_str_ptr :public sys_var_const_str_ptr
|
|
{
|
|
public:
|
|
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;
|
|
}
|
|
};
|
|
|
|
|
|
class sys_var_enum :public sys_var
|
|
{
|
|
uint *value;
|
|
TYPELIB *enum_names;
|
|
public:
|
|
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; }
|
|
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,
|
|
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)
|
|
{
|
|
return type == OPT_GLOBAL && !option_limits;
|
|
}
|
|
};
|
|
|
|
|
|
class sys_var_thd_ulong :public sys_var_thd
|
|
{
|
|
sys_check_func check_func;
|
|
public:
|
|
ulong SV::*offset;
|
|
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; }
|
|
uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
|
|
};
|
|
|
|
|
|
class sys_var_thd_ha_rows :public sys_var_thd
|
|
{
|
|
public:
|
|
ha_rows SV::*offset;
|
|
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)
|
|
{ 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; }
|
|
uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
|
|
};
|
|
|
|
|
|
class sys_var_thd_ulonglong :public sys_var_thd
|
|
{
|
|
public:
|
|
ulonglong SV::*offset;
|
|
bool only_global;
|
|
sys_var_thd_ulonglong(sys_var_chain *chain, const char *name_arg,
|
|
ulonglong SV::*offset_arg)
|
|
:sys_var_thd(name_arg), offset(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; }
|
|
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)
|
|
{
|
|
return type == OPT_GLOBAL && !option_limits;
|
|
}
|
|
bool check_type(enum_var_type type)
|
|
{
|
|
return (only_global && type != OPT_GLOBAL);
|
|
}
|
|
};
|
|
|
|
|
|
class sys_var_thd_bool :public sys_var_thd
|
|
{
|
|
public:
|
|
my_bool SV::*offset;
|
|
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)
|
|
{ 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; }
|
|
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);
|
|
}
|
|
bool check_update_type(Item_result type) { return 0; }
|
|
};
|
|
|
|
|
|
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(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)
|
|
{
|
|
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; }
|
|
uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
|
|
bool check_update_type(Item_result type) { return 0; }
|
|
};
|
|
|
|
|
|
class sys_var_thd_optimizer_switch :public sys_var_thd_enum
|
|
{
|
|
public:
|
|
sys_var_thd_optimizer_switch(sys_var_chain *chain, const char *name_arg,
|
|
ulong SV::*offset_arg)
|
|
:sys_var_thd_enum(chain, name_arg, offset_arg, &optimizer_switch_typelib)
|
|
{}
|
|
bool check(THD *thd, set_var *var);
|
|
void set_default(THD *thd, enum_var_type type);
|
|
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);
|
|
};
|
|
|
|
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(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);
|
|
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:
|
|
plugin_ref SV::*offset;
|
|
public:
|
|
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)
|
|
{
|
|
return type != STRING_RESULT; /* Only accept strings */
|
|
}
|
|
void set_default(THD *thd, enum_var_type type);
|
|
bool update(THD *thd, set_var *var);
|
|
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(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);
|
|
bool update(THD *thd, set_var *var);
|
|
};
|
|
|
|
class sys_var_thd_bit :public sys_var_thd
|
|
{
|
|
sys_check_func check_func;
|
|
sys_update_func update_func;
|
|
public:
|
|
ulonglong bit_flag;
|
|
bool reverse;
|
|
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,
|
|
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; }
|
|
uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
|
|
};
|
|
|
|
#ifndef DBUG_OFF
|
|
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);
|
|
};
|
|
#endif /* DBUG_OFF */
|
|
|
|
#if defined(ENABLED_DEBUG_SYNC)
|
|
/* Debug Sync Facility. Implemented in debug_sync.cc. */
|
|
class sys_var_debug_sync :public sys_var_thd
|
|
{
|
|
public:
|
|
sys_var_debug_sync(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);
|
|
SHOW_TYPE show_type() { return SHOW_CHAR; }
|
|
bool check_update_type(Item_result type) { return type != STRING_RESULT; }
|
|
uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
|
|
};
|
|
#endif /* defined(ENABLED_DEBUG_SYNC) */
|
|
|
|
/* some variables that require special handling */
|
|
|
|
class sys_var_timestamp :public sys_var
|
|
{
|
|
public:
|
|
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 check(THD *thd, set_var *var);
|
|
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; }
|
|
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(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; }
|
|
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(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; }
|
|
uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
|
|
};
|
|
|
|
|
|
class sys_var_rand_seed1 :public sys_var
|
|
{
|
|
public:
|
|
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; }
|
|
};
|
|
|
|
class sys_var_rand_seed2 :public sys_var
|
|
{
|
|
public:
|
|
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; }
|
|
};
|
|
|
|
|
|
class sys_var_collation :public sys_var_thd
|
|
{
|
|
public:
|
|
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)
|
|
{
|
|
return ((type != STRING_RESULT) && (type != INT_RESULT));
|
|
}
|
|
bool check_default(enum_var_type type) { return 0; }
|
|
virtual void set_default(THD *thd, enum_var_type type)= 0;
|
|
};
|
|
|
|
class sys_var_character_set :public sys_var_thd
|
|
{
|
|
public:
|
|
bool nullable;
|
|
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)
|
|
{
|
|
/*
|
|
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.
|
|
*/
|
|
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)
|
|
{
|
|
return ((type != STRING_RESULT) && (type != INT_RESULT));
|
|
}
|
|
bool check_default(enum_var_type type) { return 0; }
|
|
bool update(THD *thd, set_var *var);
|
|
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_sv :public sys_var_character_set
|
|
{
|
|
CHARSET_INFO *SV::*offset;
|
|
CHARSET_INFO **global_default;
|
|
public:
|
|
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_sv
|
|
{
|
|
public:
|
|
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_database :public sys_var_character_set
|
|
{
|
|
public:
|
|
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_collation_sv :public sys_var_collation
|
|
{
|
|
CHARSET_INFO *SV::*offset;
|
|
CHARSET_INFO **global_default;
|
|
public:
|
|
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);
|
|
uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
|
|
};
|
|
|
|
|
|
class sys_var_key_cache_param :public sys_var
|
|
{
|
|
protected:
|
|
size_t offset;
|
|
public:
|
|
sys_var_key_cache_param(sys_var_chain *chain, const char *name_arg,
|
|
size_t offset_arg)
|
|
:sys_var(name_arg), offset(offset_arg)
|
|
{ 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; }
|
|
};
|
|
|
|
|
|
class sys_var_key_buffer_size :public sys_var_key_cache_param
|
|
{
|
|
public:
|
|
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; }
|
|
};
|
|
|
|
|
|
class sys_var_key_cache_long :public sys_var_key_cache_param
|
|
{
|
|
public:
|
|
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; }
|
|
};
|
|
|
|
|
|
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(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)
|
|
{
|
|
return type != STRING_RESULT; /* Only accept strings */
|
|
}
|
|
bool check_default(enum_var_type type) { return 0; }
|
|
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);
|
|
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
|
|
{
|
|
public:
|
|
enum_var_type var_type;
|
|
SHOW_TYPE show_type_value;
|
|
sys_value_ptr_func value_ptr_func;
|
|
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; }
|
|
uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
|
|
{
|
|
return (*value_ptr_func)(thd);
|
|
}
|
|
SHOW_TYPE show_type() { return show_type_value; }
|
|
bool is_readonly() const { return 1; }
|
|
};
|
|
|
|
|
|
class sys_var_readonly_os: public sys_var_readonly
|
|
{
|
|
public:
|
|
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(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(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; }
|
|
bool check_update_type(Item_result type)
|
|
{
|
|
return type != STRING_RESULT; /* Only accept strings */
|
|
}
|
|
bool check_default(enum_var_type type) { return 0; }
|
|
bool update(THD *thd, set_var *var);
|
|
uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
|
|
virtual void set_default(THD *thd, enum_var_type type);
|
|
};
|
|
|
|
|
|
class sys_var_max_user_conn : public sys_var_thd
|
|
{
|
|
public:
|
|
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)
|
|
{
|
|
return type != OPT_GLOBAL || !option_limits;
|
|
}
|
|
void set_default(THD *thd, enum_var_type type);
|
|
SHOW_TYPE show_type() { return SHOW_INT; }
|
|
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(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(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; }
|
|
bool check_update_type(Item_result type)
|
|
{
|
|
return ((type != STRING_RESULT) && (type != INT_RESULT));
|
|
}
|
|
bool check_default(enum_var_type type) { return 0; }
|
|
bool update(THD *thd, set_var *var);
|
|
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
|
|
****************************************************************************/
|
|
|
|
class set_var_base :public Sql_alloc
|
|
{
|
|
public:
|
|
set_var_base() {}
|
|
virtual ~set_var_base() {}
|
|
virtual int check(THD *thd)=0; /* To check privileges etc. */
|
|
virtual int update(THD *thd)=0; /* To set the value */
|
|
/* light check for PS */
|
|
virtual int light_check(THD *thd) { return check(thd); }
|
|
virtual bool no_support_one_shot() { return 1; }
|
|
};
|
|
|
|
|
|
/* MySQL internal variables, like query_cache_size */
|
|
|
|
class set_var :public set_var_base
|
|
{
|
|
public:
|
|
sys_var *var;
|
|
Item *value;
|
|
enum_var_type type;
|
|
union
|
|
{
|
|
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;
|
|
} save_result;
|
|
LEX_STRING base; /* for structs */
|
|
|
|
set_var(enum_var_type type_arg, sys_var *var_arg,
|
|
const LEX_STRING *base_name_arg, Item *value_arg)
|
|
:var(var_arg), type(type_arg), base(*base_name_arg)
|
|
{
|
|
/*
|
|
If the set value is a field, change it to a string to allow things like
|
|
SET table_type=MYISAM;
|
|
*/
|
|
if (value_arg && value_arg->type() == Item::FIELD_ITEM)
|
|
{
|
|
Item_field *item= (Item_field*) value_arg;
|
|
if (!(value=new Item_string(item->field_name,
|
|
(uint) strlen(item->field_name),
|
|
item->collation.collation)))
|
|
value=value_arg; /* Give error message later */
|
|
}
|
|
else
|
|
value=value_arg;
|
|
}
|
|
int check(THD *thd);
|
|
int update(THD *thd);
|
|
int light_check(THD *thd);
|
|
bool no_support_one_shot() { return var->no_support_one_shot; }
|
|
};
|
|
|
|
|
|
/* User variables like @my_own_variable */
|
|
|
|
class set_var_user: public set_var_base
|
|
{
|
|
Item_func_set_user_var *user_var_item;
|
|
public:
|
|
set_var_user(Item_func_set_user_var *item)
|
|
:user_var_item(item)
|
|
{}
|
|
int check(THD *thd);
|
|
int update(THD *thd);
|
|
int light_check(THD *thd);
|
|
};
|
|
|
|
/* For SET PASSWORD */
|
|
|
|
class set_var_password: public set_var_base
|
|
{
|
|
LEX_USER *user;
|
|
char *password;
|
|
public:
|
|
set_var_password(LEX_USER *user_arg,char *password_arg)
|
|
:user(user_arg), password(password_arg)
|
|
{}
|
|
int check(THD *thd);
|
|
int update(THD *thd);
|
|
};
|
|
|
|
|
|
/* For SET NAMES and SET CHARACTER SET */
|
|
|
|
class set_var_collation_client: public set_var_base
|
|
{
|
|
CHARSET_INFO *character_set_client;
|
|
CHARSET_INFO *character_set_results;
|
|
CHARSET_INFO *collation_connection;
|
|
public:
|
|
set_var_collation_client(CHARSET_INFO *client_coll_arg,
|
|
CHARSET_INFO *connection_coll_arg,
|
|
CHARSET_INFO *result_coll_arg)
|
|
:character_set_client(client_coll_arg),
|
|
character_set_results(result_coll_arg),
|
|
collation_connection(connection_coll_arg)
|
|
{}
|
|
int check(THD *thd);
|
|
int update(THD *thd);
|
|
};
|
|
|
|
|
|
extern "C"
|
|
{
|
|
typedef int (*process_key_cache_t) (const char *, KEY_CACHE *);
|
|
}
|
|
|
|
/* Named lists (used for keycaches) */
|
|
|
|
class NAMED_LIST :public ilink
|
|
{
|
|
const char *name;
|
|
uint name_length;
|
|
public:
|
|
uchar* data;
|
|
|
|
NAMED_LIST(I_List<NAMED_LIST> *links, const char *name_arg,
|
|
uint name_length_arg, uchar* data_arg)
|
|
:name_length(name_length_arg), data(data_arg)
|
|
{
|
|
name= my_strndup(name_arg, name_length, MYF(MY_WME));
|
|
links->push_back(this);
|
|
}
|
|
inline bool cmp(const char *name_cmp, uint length)
|
|
{
|
|
return length == name_length && !memcmp(name, name_cmp, length);
|
|
}
|
|
~NAMED_LIST()
|
|
{
|
|
my_free((uchar*) name, MYF(0));
|
|
}
|
|
friend bool process_key_caches(process_key_cache_t func);
|
|
friend void delete_elements(I_List<NAMED_LIST> *list,
|
|
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;
|
|
|
|
/* For sql_yacc */
|
|
struct sys_var_with_base
|
|
{
|
|
sys_var *var;
|
|
LEX_STRING base_name;
|
|
};
|
|
|
|
/*
|
|
Prototypes for helper functions
|
|
*/
|
|
|
|
int set_var_init();
|
|
void set_var_free();
|
|
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(void);
|
|
ulong fix_sql_mode(ulong sql_mode);
|
|
extern sys_var_const_str sys_charset_system;
|
|
extern sys_var_str sys_init_connect;
|
|
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);
|
|
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(process_key_cache_t func);
|
|
void delete_elements(I_List<NAMED_LIST> *list,
|
|
void (*free_element)(const char*, uchar*));
|