diff options
Diffstat (limited to 'sql/set_var.h')
| -rw-r--r-- | sql/set_var.h | 419 |
1 files changed, 419 insertions, 0 deletions
diff --git a/sql/set_var.h b/sql/set_var.h new file mode 100644 index 00000000000..607e44d2ef3 --- /dev/null +++ b/sql/set_var.h @@ -0,0 +1,419 @@ +/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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; either version 2 of the License, or + (at your option) any later version. + + 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 __GNUC__ +#pragma interface /* gcc class implementation */ +#endif + +/**************************************************************************** + Variables that are changable runtime are declared using the + following classes +****************************************************************************/ + +class sys_var; +class set_var; +typedef struct system_variables SV; +extern TYPELIB bool_typelib; + +enum enum_var_type +{ + OPT_DEFAULT, OPT_SESSION, OPT_GLOBAL +}; + +typedef bool (*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); + +class sys_var +{ +public: + 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; + sys_var(const char *name_arg) :name(name_arg),after_update(0) + {} + sys_var(const char *name_arg,sys_after_update_func func) + :name(name_arg),after_update(func) + {} + virtual ~sys_var() {} + virtual bool check(THD *thd, set_var *var) { return 0; } + bool check_enum(THD *thd, set_var *var, TYPELIB *enum_names); + virtual bool update(THD *thd, set_var *var)=0; + virtual void set_default(THD *thd, enum_var_type type) {} + virtual SHOW_TYPE type() { return SHOW_UNDEF; } + virtual byte *value_ptr(THD *thd, enum_var_type type) { 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; } + Item *item(THD *thd, enum_var_type type); +}; + + +class sys_var_long_ptr :public sys_var +{ +public: + ulong *value; + sys_var_long_ptr(const char *name_arg, ulong *value_ptr) + :sys_var(name_arg),value(value_ptr) {} + sys_var_long_ptr(const char *name_arg, ulong *value_ptr, + sys_after_update_func func) + :sys_var(name_arg,func), value(value_ptr) {} + bool update(THD *thd, set_var *var); + void set_default(THD *thd, enum_var_type type); + SHOW_TYPE type() { return SHOW_LONG; } + byte *value_ptr(THD *thd, enum_var_type type) { return (byte*) value; } +}; + + +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(name_arg),value(value_arg) + {} + 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 type() { return SHOW_MY_BOOL; } + byte *value_ptr(THD *thd, enum_var_type type) { return (byte*) value; } + bool check_update_type(Item_result type) { return 0; } +}; + + +class sys_var_str :public sys_var +{ +public: + char *value; // Pointer to allocated string + 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_check_func check_func_arg, + sys_update_func update_func_arg, + sys_set_default_func set_default_func_arg) + :sys_var(name_arg), check_func(check_func_arg), + update_func(update_func_arg),set_default_func(set_default_func_arg) + {} + bool check(THD *thd, set_var *var) + { + return check_func ? (*check_func)(thd, var) : 0; + } + bool update(THD *thd, set_var *var) + { + return (*update_func)(thd, var); + } + void set_default(THD *thd, enum_var_type type) + { + return (*set_default_func)(thd, type); + } + SHOW_TYPE type() { return SHOW_CHAR; } + byte *value_ptr(THD *thd, enum_var_type type) { return (byte*) 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_thd :public sys_var +{ +public: + sys_var_thd(const char *name_arg) + :sys_var(name_arg) + {} + sys_var_thd(const char *name_arg, sys_after_update_func func) + :sys_var(name_arg,func) + {} + 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 +{ +public: + ulong SV::*offset; + sys_var_thd_ulong(const char *name_arg, ulong SV::*offset_arg) + :sys_var_thd(name_arg), offset(offset_arg) + {} + sys_var_thd_ulong(const char *name_arg, ulong SV::*offset_arg, + sys_after_update_func func) + :sys_var_thd(name_arg,func), offset(offset_arg) + {} + bool update(THD *thd, set_var *var); + void set_default(THD *thd, enum_var_type type); + SHOW_TYPE type() { return SHOW_LONG; } + byte *value_ptr(THD *thd, enum_var_type type); +}; + + +class sys_var_thd_ulonglong :public sys_var_thd +{ +public: + ulonglong SV::*offset; + sys_var_thd_ulonglong(const char *name_arg, ulonglong SV::*offset_arg) + :sys_var_thd(name_arg), offset(offset_arg) + {} + bool update(THD *thd, set_var *var); + void set_default(THD *thd, enum_var_type type); + SHOW_TYPE type() { return SHOW_LONGLONG; } + byte *value_ptr(THD *thd, enum_var_type type); +}; + + +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(name_arg), offset(offset_arg) + {} + sys_var_thd_bool(const char *name_arg, my_bool SV::*offset_arg, + sys_after_update_func func) + :sys_var_thd(name_arg,func), offset(offset_arg) + {} + bool update(THD *thd, set_var *var); + void set_default(THD *thd, enum_var_type type); + SHOW_TYPE type() { return SHOW_MY_BOOL; } + byte *value_ptr(THD *thd, enum_var_type type); + 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 +{ + ulong SV::*offset; + TYPELIB *enum_names; +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) + {} + bool check(THD *thd, set_var *var) + { + return check_enum(thd, var, enum_names); + } + bool update(THD *thd, set_var *var); + void set_default(THD *thd, enum_var_type type); + SHOW_TYPE type() { return SHOW_CHAR; } + byte *value_ptr(THD *thd, enum_var_type type); + bool check_update_type(Item_result type) { return 0; } +}; + + +class sys_var_thd_bit :public sys_var_thd +{ + sys_update_func update_func; +public: + ulong bit_flag; + bool reverse; + sys_var_thd_bit(const char *name_arg, sys_update_func func, ulong bit, + bool reverse_arg=0) + :sys_var_thd(name_arg), update_func(func), bit_flag(bit), + reverse(reverse_arg) + {} + bool check(THD *thd, set_var *var) + { + return check_enum(thd, var, &bool_typelib); + } + 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 type() { return SHOW_MY_BOOL; } + byte *value_ptr(THD *thd, enum_var_type type); +}; + + +/* 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) {} + 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 type() { return SHOW_LONG; } + byte *value_ptr(THD *thd, enum_var_type type); +}; + + +class sys_var_last_insert_id :public sys_var +{ +public: + sys_var_last_insert_id(const char *name_arg) :sys_var(name_arg) {} + bool update(THD *thd, set_var *var); + bool check_type(enum_var_type type) { return type == OPT_GLOBAL; } + SHOW_TYPE type() { return SHOW_LONGLONG; } + byte *value_ptr(THD *thd, enum_var_type type); +}; + + +class sys_var_insert_id :public sys_var +{ +public: + sys_var_insert_id(const char *name_arg) :sys_var(name_arg) {} + bool update(THD *thd, set_var *var); + bool check_type(enum_var_type type) { return type == OPT_GLOBAL; } + SHOW_TYPE type() { return SHOW_LONGLONG; } + byte *value_ptr(THD *thd, enum_var_type type); +}; + + +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() + */ +}; + + +class sys_var_thd_conv_charset :public sys_var_thd +{ +public: + sys_var_thd_conv_charset(const char *name_arg) + :sys_var_thd(name_arg) + {} + bool check(THD *thd, set_var *var); + bool update(THD *thd, set_var *var); + SHOW_TYPE type() { return SHOW_CHAR; } + byte *value_ptr(THD *thd, enum_var_type type); + bool check_update_type(Item_result type) + { + return type != STRING_RESULT; /* Only accept strings */ + } + bool check_default(enum_var_type type) { return 0; } +}; + + +/**************************************************************************** + Classes for parsing of the SET command +****************************************************************************/ + +class set_var_base :public Sql_alloc +{ +public: + set_var_base() {} + virtual ~set_var_base() {} + virtual bool check(THD *thd)=0; /* To check privileges etc. */ + virtual bool update(THD *thd)=0; /* To set the value */ +}; + + +/* 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 + { + CONVERT *convert; + ulong ulong_value; + } save_result; + + set_var(enum_var_type type_arg, sys_var *var_arg, Item *value_arg) + :var(var_arg), type(type_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, strlen(item->field_name)))) + value=value_arg; /* Give error message later */ + } + else + value=value_arg; + } + bool check(THD *thd); + bool update(THD *thd); +}; + + +/* 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) + {} + bool check(THD *thd); + bool update(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) + {} + bool check(THD *thd); + bool update(THD *thd); +}; + + +/* + Prototypes for helper functions +*/ + +void set_var_init(); +void set_var_free(); +sys_var *find_sys_var(const char *str, uint length=0); +bool sql_set_variables(THD *thd, List<set_var_base> *var_list); + +extern sys_var_str sys_charset; |