WL#4738 streamline/simplify @@variable creation process

Bug#16565 mysqld --help --verbose does not order variablesBug#20413 sql_slave_skip_counter is not shown in show variables
Bug#20415 Output of mysqld --help --verbose is incomplete
Bug#25430 variable not found in SELECT @@global.ft_max_word_len;
Bug#32902 plugin variables don't know their names
Bug#34599 MySQLD Option and Variable Reference need to be consistent in formatting!
Bug#34829 No default value for variable and setting default does not raise error
Bug#34834 ? Is accepted as a valid sql mode
Bug#34878 Few variables have default value according to documentation but error occurs  
Bug#34883 ft_boolean_syntax cant be assigned from user variable to global var.
Bug#37187 `INFORMATION_SCHEMA`.`GLOBAL_VARIABLES`: inconsistent status
Bug#40988 log_output_basic.test succeeded though syntactically false.
Bug#41010 enum-style command-line options are not honoured (maria.maria-recover fails)
Bug#42103 Setting key_buffer_size to a negative value may lead to very large allocations 
Bug#44691 Some plugins configured as MYSQL_PLUGIN_MANDATORY in can be disabled
Bug#44797 plugins w/o command-line options have no disabling option in --help
Bug#46314 string system variables don't support expressions
Bug#46470 sys_vars.max_binlog_cache_size_basic_32 is broken
Bug#46586 When using the plugin interface the type "set" for options caused a crash.
Bug#47212 Crash in DBUG_PRINT in mysqltest.cc when trying to print octal number
Bug#48758 mysqltest crashes on sys_vars.collation_server_basic in gcov builds
Bug#49417 some complaints about mysqld --help --verbose output
Bug#49540 DEFAULT value of binlog_format isn't the default value
Bug#49640 ambiguous option '--skip-skip-myisam' (double skip prefix)
Bug#49644 init_connect and \0
Bug#49645 init_slave and multi-byte characters
Bug#49646 mysql --show-warnings crashes when server dies


CMakeLists.txt:
  Bug#44691 Some plugins configured as MYSQL_PLUGIN_MANDATORY in can be disabled
client/mysql.cc:
  don't crash with --show-warnings when mysqld dies
config/ac-macros/plugins.m4:
  Bug#44691 Some plugins configured as MYSQL_PLUGIN_MANDATORY in can be disabled
include/my_getopt.h:
  comments
include/my_pthread.h:
  fix double #define
mysql-test/mysql-test-run.pl:
  run sys_vars suite by default
  properly recognize envirinment variables (e.g. MTR_MAX_SAVE_CORE) set to 0
  escape gdb command line arguments
mysql-test/suite/sys_vars/r/rpl_init_slave_func.result:
  init_slave+utf8 bug
mysql-test/suite/sys_vars/t/rpl_init_slave_func.test:
  init_slave+utf8 bug
mysys/my_getopt.c:
  Bug#34599 MySQLD Option and Variable Reference need to be consistent in formatting!
  Bug#46586 When using the plugin interface the type "set" for options caused a crash.
  Bug#49640 ambiguous option '--skip-skip-myisam' (double skip prefix)
mysys/typelib.c:
  support for flagset
sql/ha_ndbcluster.cc:
  backport from telco tree
sql/item_func.cc:
  Bug#49644 init_connect and \0
  Bug#49645 init_slave and multi-byte characters
sql/sql_builtin.cc.in:
  Bug#44691 Some plugins configured as MYSQL_PLUGIN_MANDATORY in can be disabled
sql/sql_plugin.cc:
  Bug#44691 Some plugins configured as MYSQL_PLUGIN_MANDATORY in can be disabled
  Bug#32902 plugin variables don't know their names
  Bug#44797 plugins w/o command-line options have no disabling option in --help
sql/sys_vars.cc:
  all server variables are defined here
storage/myisam/ft_parser.c:
  remove unnecessary updates of param->quot
storage/myisam/ha_myisam.cc:
  myisam_* variables belong here
strings/my_vsnprintf.c:
  %o and %llx
unittest/mysys/my_vsnprintf-t.c:
  %o and %llx tests
vio/viosocket.c:
  bugfix: fix @@wait_timeout to work with socket timeouts (vs. alarm thread)

1 files changed, 148 insertions, 1351 deletions

diff --git a/sql/set_var.h b/sql/set_var.h
index 120388415f5..d878e85cec0 100644
--- a/sql/set_var.h
+++ b/sql/set_var.h
@@ -1,7 +1,6 @@
 #ifndef SET_VAR_INCLUDED
 #define SET_VAR_INCLUDED
-
-/* Copyright (C) 2002-2006 MySQL AB
+/* Copyright 2000-2008 MySQL AB, 2009 Sun Microsystems, Inc.
 
    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
@@ -16,31 +15,23 @@
    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 */
+/**
+  @file
+  "public" interface to sys_var - server configuration variables.
+*/
 
 #ifdef USE_PRAGMA_INTERFACE
-#pragma interface			/* gcc class implementation */
+#pragma interface                       /* gcc class implementation */
 #endif
 
-/****************************************************************************
-  Variables that are changable runtime are declared using the
-  following classes
-****************************************************************************/
+#include <my_getopt.h>
 
 class sys_var;
 class set_var;
-class sys_var_pluginvar; /* opaque */
-typedef struct system_variables SV;
-typedef struct my_locale_st MY_LOCALE;
+class sys_var_pluginvar;
+class PolyLock;
 
-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);
+extern TYPELIB bool_typelib;
 
 struct sys_var_chain
 {
@@ -48,1297 +39,165 @@ struct sys_var_chain
   sys_var *last;
 };
 
+int mysql_add_sys_var_chain(sys_var *chain);
+int mysql_del_sys_var_chain(sys_var *chain);
+
+/**
+  A class representing one system variable - that is something
+  that can be accessed as @@global.variable_name or @@session.variable_name,
+  visible in SHOW xxx VARIABLES and in INFORMATION_SCHEMA.xxx_VARIABLES,
+  optionally it can be assigned to, optionally it can have a command-line
+  counterpart with the same name.
+*/
 class sys_var
 {
 public:
+  sys_var *next;
+  LEX_CSTRING name;
+  enum flag_enum { GLOBAL, SESSION, ONLY_SESSION, SCOPE_MASK=1023,
+                   READONLY=1024, ALLOCATED=2048 };
+  /**
+    Enumeration type to indicate for a system variable whether
+    it will be written to the binlog or not.
+  */    
+  enum binlog_status_enum { VARIABLE_NOT_IN_BINLOG,
+                            SESSION_VARIABLE_IN_BINLOG } binlog_status;
 
+protected:
+  typedef bool (*on_check_function)(sys_var *self, THD *thd, set_var *var);
+  typedef bool (*on_update_function)(sys_var *self, THD *thd, enum_var_type type);
+
+  int flags;            ///< or'ed flag_enum values
+  const SHOW_TYPE show_val_type; ///< what value_ptr() returns for sql_show.cc
+  my_option option;     ///< min, max, default values are stored here
+  PolyLock *guard;      ///< *second* lock that protects the variable
+  ptrdiff_t offset;     ///< offset to the value from global_system_variables
+  on_check_function on_check;
+  on_update_function on_update;
+  struct { uint version; const char *substitute; } deprecated;
+  bool is_os_charset; ///< true if the value is in character_set_filesystem
+
+public:
+  sys_var(sys_var_chain *chain, const char *name_arg, const char *comment,
+          int flag_args, ptrdiff_t off, int getopt_id,
+          enum get_opt_arg_type getopt_arg_type, SHOW_TYPE show_val_type_arg,
+          longlong def_val, PolyLock *lock, enum binlog_status_enum binlog_status_arg,
+          on_check_function on_check_func, on_update_function on_update_func,
+          uint deprecated_version, const char *substitute);
   /**
-    Enumeration type to indicate for a system variable whether it will be written to the binlog or not.
+    The instance should only be destroyed on shutdown, as it doesn't unlink
+    itself from the chain.
   */
-  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);
+  /**
+    downcast for sys_var_pluginvar. Returns this if it's an instance
+    of sys_var_pluginvar, and 0 otherwise.
+  */
   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; }
-};
-
-/**
-   Unsigned int system variable class
- */
-class sys_var_uint_ptr :public sys_var
-{
-public:
-  sys_var_uint_ptr(sys_var_chain *chain, const char *name_arg, 
-                  uint *value_ptr_arg,
-                  sys_after_update_func after_update_arg= NULL)
-    :sys_var(name_arg, after_update_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_INT; }
-  uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
-  { return (uchar*) value; }
-private:
-  uint *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 set_default(THD *thd, enum_var_type type);
   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;
-  }
+  SHOW_TYPE show_type() { return show_val_type; }
+  int scope() const { return flags & SCOPE_MASK; }
+  CHARSET_INFO *charset(THD *thd);
+  bool is_readonly() const { return flags & READONLY; }
+  /**
+    the following is only true for keycache variables,
+    that support the syntax @@keycache_name.variable_name
+  */
+  bool is_struct() { return option.var_type & GET_ASK_ADDR; }
+  bool is_written_to_binlog(enum_var_type type)
+  { return type != OPT_GLOBAL && binlog_status == SESSION_VARIABLE_IN_BINLOG; }
+  virtual bool check_update_type(Item_result type) = 0;
   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)
-  {
-    /*
-      check_enum fails if the character representation supplied was wrong
-      or that the integer value was wrong or missing.
-    */
-    if (check_enum(thd, var, enum_names))
-      return TRUE;
-    else if ((check_func && (*check_func)(thd, var)))
-      return TRUE;
-    else
-      return FALSE;
-  }
-  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_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 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;
+    switch (scope())
+    {
+    case GLOBAL:       return type != OPT_GLOBAL;
+    case SESSION:      return false; // always ok
+    case ONLY_SESSION: return type == OPT_GLOBAL;
+    }
+    return true; // keep gcc happy
   }
-};
+  bool register_option(DYNAMIC_ARRAY *array)
+  { return option.id != -1 && insert_dynamic(array, (uchar*)&option); }
 
-
-class sys_var_have_option: public sys_var
-{
+private:
+  virtual bool do_check(THD *thd, set_var *var) = 0;
+  /**
+    save the session default value of the variable in var
+  */
+  virtual void session_save_default(THD *thd, set_var *var) = 0;
+  /**
+    save the global default value of the variable in var
+  */
+  virtual void global_save_default(THD *thd, set_var *var) = 0;
+  virtual bool session_update(THD *thd, set_var *var) = 0;
+  virtual bool global_update(THD *thd, set_var *var) = 0;
+  void do_deprecated_warning(THD *thd);
 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);
-};
-
-
-/**
-  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: public sys_var_thd
-{
-public:
-  sys_var_thd_lc(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; }
-};
-
-
-class sys_var_thd_lc_time_names :public sys_var_thd_lc
-{
-public:
-  sys_var_thd_lc_time_names(sys_var_chain *chain_arg, const char *name_arg,
-                            Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
-    : sys_var_thd_lc(chain_arg, name_arg, binlog_status_arg)
-  {}
-  bool update(THD *thd, set_var *var);
-  uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
-  void set_default(THD *thd, enum_var_type type);
-};
-
-
-class sys_var_thd_lc_messages :public sys_var_thd_lc
-{
-public:
-  sys_var_thd_lc_messages(sys_var_chain *chain_arg, const char *name_arg,
-                          Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
-    : sys_var_thd_lc(chain_arg, name_arg, binlog_status_arg)
-  {}
-  bool update(THD *thd, set_var *var);
-  uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
-  void set_default(THD *thd, enum_var_type type);
-};
+  /**
+    A pointer to a value of the variable for SHOW.
+    It must be of show_val_type type (bool for SHOW_BOOL, int for SHOW_INT,
+    longlong for SHOW_LONGLONG, etc).
+  */
+  virtual uchar *session_value_ptr(THD *thd, LEX_STRING *base);
+  virtual uchar *global_value_ptr(THD *thd, LEX_STRING *base);
 
+  /**
+    A pointer to a storage area of the variable, to the raw data.
+    Typically it's the same as session_value_ptr(), but it's different,
+    for example, for ENUM, that is printed as a string, but stored as a number.
+  */
+  uchar *session_var_ptr(THD *thd)
+  { return ((uchar*)&(thd->variables)) + offset; }
 
-#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;
+  uchar *global_var_ptr()
+  { return ((uchar*)&global_system_variables) + offset; }
 };
 
 /****************************************************************************
   Classes for parsing of the SET command
 ****************************************************************************/
 
+/**
+  A base class for everything that can be set with SET command.
+  It's similar to Items, an instance of this is created by the parser
+  for every assigmnent in SET (or elsewhere, e.g. in SELECT).
+*/
 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; }
+  virtual int check(THD *thd)=0;           /* To check privileges etc. */
+  virtual int update(THD *thd)=0;                  /* To set the value */
+  virtual int light_check(THD *thd) { return check(thd); }   /* for PS */
 };
 
 
-/* MySQL internal variables, like query_cache_size */
-
+/**
+  set_var_base descendant for assignments to the system variables.
+*/
 class set_var :public set_var_base
 {
 public:
-  sys_var *var;
-  Item *value;
+  sys_var *var; ///< system variable to be updated
+  Item *value;  ///< the expression that provides the new value of the variable
   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;
+  union ///< temp storage to hold a value between sys_var::check and ::update
+  {
+    ulonglong ulonglong_value;          ///< for all integer, set, enum sysvars
+    double double_value;                ///< for Sys_var_double
+    plugin_ref plugin;                  ///< for Sys_var_plugin
+    Time_zone *time_zone;               ///< for Sys_var_tz
+    LEX_STRING string_value;            ///< for Sys_var_charptr and others
+    void *ptr;                          ///< for Sys_var_struct
   } save_result;
-  LEX_STRING base;			/* for structs */
+  LEX_STRING base; /**< for structured variables, like keycache_name.variable_name */
 
   set_var(enum_var_type type_arg, sys_var *var_arg,
           const LEX_STRING *base_name_arg, Item *value_arg)
@@ -1351,10 +210,10 @@ public:
     if (value_arg && value_arg->type() == Item::FIELD_ITEM)
     {
       Item_field *item= (Item_field*) value_arg;
-      if (!(value=new Item_string(item->field_name, 
+      if (!(value=new Item_string(item->field_name,
                                   (uint) strlen(item->field_name),
-				  system_charset_info)))
-	value=value_arg;			/* Give error message later */
+                                  system_charset_info))) // names are utf8
+        value=value_arg;                        /* Give error message later */
     }
     else
       value=value_arg;
@@ -1362,12 +221,10 @@ public:
   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;
@@ -1404,8 +261,8 @@ class set_var_collation_client: public set_var_base
   CHARSET_INFO *collation_connection;
 public:
   set_var_collation_client(CHARSET_INFO *client_coll_arg,
-  			   CHARSET_INFO *connection_coll_arg,
-  			   CHARSET_INFO *result_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)
@@ -1414,86 +271,26 @@ public:
   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);
+SHOW_VAR* enumerate_sys_vars(THD *thd, bool sorted, enum enum_var_type type);
+
 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;
-extern sys_var_str sys_init_slave;
-extern sys_var_thd_time_zone sys_time_zone;
-extern sys_var_thd_bit sys_autocommit;
+
+bool fix_delay_key_write(sys_var *self, THD *thd, enum_var_type type);
+
+ulong expand_sql_mode(ulonglong sql_mode);
+bool sql_mode_string_representation(THD *thd, ulong sql_mode, LEX_STRING *ls);
+
+extern sys_var *Sys_autocommit_ptr;
+
 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;
+int sys_var_init(DYNAMIC_ARRAY *long_options);
+void sys_var_end(void);
 
-/* 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*));
+#endif
 
-#endif /* SET_VAR_INCLUDED */