~drizzle-trunk/drizzle/development

/* 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;

  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),

    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; }

  Item *item(THD *thd, enum_var_type type, LEX_STRING *base);

  virtual bool is_struct() { return 0; }

  virtual bool is_readonly() const { return 0; }

  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_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_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)

  {

    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);

};

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; }

  SHOW_TYPE show_type() { return SHOW_CHAR; }

  bool update(THD *thd, set_var *var);

  void set_default(THD *thd, enum_var_type type) { DBUG_POP(); }

  uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *b);

};

/* some variables that require special handling */

class sys_var_timestamp :public sys_var

{

public:

  sys_var_timestamp(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); }