~drizzle-trunk/drizzle/development

/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-

 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:

 *

 *  Copyright (C) 2008 Sun Microsystems

 *

 *  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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#ifndef DRIZZLED_SET_VAR_H

#define DRIZZLED_SET_VAR_H

#include <string>

#include "drizzled/function/func.h"

#include "drizzled/function/set_user_var.h"

#include "drizzled/item/string.h"

#include "drizzled/item/field.h"

/* Classes to support the SET command */

/****************************************************************************

  Variables that are changable runtime are declared using the

  following classes

****************************************************************************/

class sys_var;

class set_var;

class sys_var_pluginvar; /* opaque */

class Time_zone;

typedef struct system_variables SV;

typedef struct my_locale_st MY_LOCALE;

extern TYPELIB bool_typelib;

extern TYPELIB optimizer_switch_typelib;

typedef int (*sys_check_func)(Session *,  set_var *);

typedef bool (*sys_update_func)(Session *, set_var *);

typedef void (*sys_after_update_func)(Session *,enum_var_type);

typedef void (*sys_set_default_func)(Session *, enum_var_type);

typedef unsigned char *(*sys_value_ptr_func)(Session *session);

static const std::vector<std::string> empty_aliases;

struct sys_var_chain

{

  sys_var *first;

  sys_var *last;

};

/**

 * A class which represents a variable, either global or 

 * session-local.

 */

class sys_var

{

protected:

  const std::string name; /**< The name of the variable */

  sys_after_update_func after_update; /**< Function pointer triggered after the variable's value is updated */

  struct my_option *option_limits; /**< Updated by by set_var_init() */

  bool m_allow_empty_value; /**< Does variable allow an empty value? */

  sys_var *next;

public:

  sys_var(const std::string name_arg, sys_after_update_func func= NULL)

    :

    name(name_arg),

    after_update(func),

    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;

  }

  /** 

   * Returns the name of the variable.

   *

   * @note 

   *

   * So that we can exist in a Registry. We really need to formalize that 

   */

  inline const std::string &getName() const

  {

    return name;

  }

  /**

   * Returns a vector of strings representing aliases

   * for this variable's name.

   */

  const std::vector<std::string>& getAliases() const

  {

    return empty_aliases;

  }

  /**

   * Returns a pointer to the next sys_var, or NULL if none.

   */

  inline sys_var *getNext() const

  {

    return next;

  }

  /**

   * Sets the pointer to the next sys_var.

   *

   * @param Pointer to the next sys_var, or NULL if you set the tail...

   */

  inline void setNext(sys_var *in_next)

  {

    next= in_next;

  }

  /**

   * Returns a pointer to the variable's option limits

   */

  inline struct my_option *getOptionLimits() const

  {

    return option_limits;

  }

  /**

   * Sets the pointer to the variable's option limits

   *

   * @param Pointer to the option limits my_option variable

   */

  inline void setOptionLimits(struct my_option *in_option_limits)

  {

    option_limits= in_option_limits;

  }

  /** 

   * Returns the function pointer for after update trigger, or NULL if none.

   */

  inline sys_after_update_func getAfterUpdateTrigger() const

  {

    return after_update;

  }

  virtual bool check(Session *session, set_var *var);

  bool check_enum(Session *session, set_var *var, const TYPELIB *enum_names);

  bool check_set(Session *session, set_var *var, TYPELIB *enum_names);

  virtual bool update(Session *session, set_var *var)=0;

  virtual void set_default(Session *, enum_var_type)

  {}

  virtual SHOW_TYPE show_type()

  {

    return SHOW_UNDEF;

  }

  virtual unsigned char *value_ptr(Session *, enum_var_type, const LEX_STRING *)

  {

    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)

  {

    return option_limits == 0;

  }

  Item *item(Session *session, enum_var_type type, const LEX_STRING *base);

  virtual bool is_readonly() const

  {

    return 0;

  }

  virtual sys_var_pluginvar *cast_pluginvar()

  {

    return 0;

  }

};

/**

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

  {}

};

class sys_var_uint32_t_ptr :public sys_var

{

  uint32_t *value;

public:

  sys_var_uint32_t_ptr(sys_var_chain *chain, const char *name_arg,

                       uint32_t *value_ptr_arg)

    :sys_var(name_arg),value(value_ptr_arg)

  { chain_sys_var(chain); }

  sys_var_uint32_t_ptr(sys_var_chain *chain, const char *name_arg,

                       uint32_t *value_ptr_arg,

                       sys_after_update_func func)

    :sys_var(name_arg,func), value(value_ptr_arg)

  { chain_sys_var(chain); }

  bool check(Session *session, set_var *var);

  bool update(Session *session, set_var *var);

  void set_default(Session *session, enum_var_type type);

  SHOW_TYPE show_type() { return SHOW_INT; }

  unsigned char *value_ptr(Session *, enum_var_type, const LEX_STRING *)

  { return (unsigned char*) value; }

};

class sys_var_uint64_t_ptr :public sys_var

{

  uint64_t *value;

public:

  sys_var_uint64_t_ptr(sys_var_chain *chain, const char *name_arg, uint64_t *value_ptr_arg)

    :sys_var(name_arg),value(value_ptr_arg)

  { chain_sys_var(chain); }

  sys_var_uint64_t_ptr(sys_var_chain *chain, const char *name_arg, uint64_t *value_ptr_arg,

		       sys_after_update_func func)

    :sys_var(name_arg,func), value(value_ptr_arg)

  { chain_sys_var(chain); }

  bool update(Session *session, set_var *var);

  void set_default(Session *session, enum_var_type type);

  SHOW_TYPE show_type() { return SHOW_LONGLONG; }

  unsigned char *value_ptr(Session *, enum_var_type,

                           const LEX_STRING *)

  { return (unsigned char*) value; }

};

class sys_var_size_t_ptr :public sys_var

{

  size_t *value;

public:

  sys_var_size_t_ptr(sys_var_chain *chain, const char *name_arg, size_t *value_ptr_arg)

    :sys_var(name_arg),value(value_ptr_arg)

  { chain_sys_var(chain); }

  sys_var_size_t_ptr(sys_var_chain *chain, const char *name_arg, size_t *value_ptr_arg,

                     sys_after_update_func func)

    :sys_var(name_arg,func), value(value_ptr_arg)

  { chain_sys_var(chain); }

  bool update(Session *session, set_var *var);

  void set_default(Session *session, enum_var_type type);

  SHOW_TYPE show_type() { return SHOW_SIZE; }

  unsigned char *value_ptr(Session *, enum_var_type, const LEX_STRING *)

  { return (unsigned char*) value; }

};

class sys_var_bool_ptr :public sys_var

{

public:

  bool *value;

  sys_var_bool_ptr(sys_var_chain *chain, const char *name_arg, bool *value_arg)

    :sys_var(name_arg),value(value_arg)

  { chain_sys_var(chain); }

  bool check(Session *session, set_var *var)

  {

    return check_enum(session, var, &bool_typelib);

  }

  bool update(Session *session, set_var *var);

  void set_default(Session *session, enum_var_type type);

  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }

  unsigned char *value_ptr(Session *, enum_var_type, const LEX_STRING *)

  { return (unsigned char*) value; }

  bool check_update_type(Item_result)

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

                            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

  uint32_t 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(Session *session, set_var *var);

  bool update(Session *session, set_var *var)

  {

    return (*update_func)(session, var);

  }

  void set_default(Session *session, enum_var_type type)

  {

    (*set_default_func)(session, type);

  }

  SHOW_TYPE show_type() { return SHOW_CHAR; }

  unsigned char *value_ptr(Session *, enum_var_type, const LEX_STRING *)

  { return (unsigned char*) value; }

  bool check_update_type(Item_result type)

  {

    return type != STRING_RESULT;		/* Only accept strings */

  }

  bool check_default(enum_var_type)

  { return 0; }

};

class sys_var_const_str :public sys_var

{

  char *value;					// Pointer to const value

public:

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

  inline void set (char *new_value)

  {

    value= new_value;

  }

  bool check(Session *, set_var *)

  {

    return 1;

  }

  bool update(Session *, set_var *)

  {

    return 1;

  }

  SHOW_TYPE show_type() { return SHOW_CHAR; }

  unsigned char *value_ptr(Session *, enum_var_type, const LEX_STRING *)

  {

    return (unsigned char*) value;

  }

  bool check_update_type(Item_result)

  {

    return 1;

  }

  bool check_default(enum_var_type)

  { return 1; }

  bool is_readonly() const { return 1; }

};

class sys_var_const_str_ptr :public sys_var

{

  char **value;					// Pointer to const value

public:

  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(Session *, set_var *)

  {

    return 1;

  }

  bool update(Session *, set_var *)

  {

    return 1;

  }

  SHOW_TYPE show_type() { return SHOW_CHAR; }

  unsigned char *value_ptr(Session *, enum_var_type, const LEX_STRING *)

  {

    return (unsigned char*) *value;

  }

  bool check_update_type(Item_result)

  {

    return 1;

  }

  bool check_default(enum_var_type)

  { return 1; }

  bool is_readonly(void) const { return 1; }

};

class sys_var_enum :public sys_var

{

  uint32_t *value;

  TYPELIB *enum_names;

public:

  sys_var_enum(sys_var_chain *chain, const char *name_arg, uint32_t *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(Session *session, set_var *var)

  {

    return check_enum(session, var, enum_names);

  }

  bool update(Session *session, set_var *var);

  SHOW_TYPE show_type() { return SHOW_CHAR; }

  unsigned char *value_ptr(Session *session, enum_var_type type,

                           const LEX_STRING *base);

  bool check_update_type(Item_result)

  { return 0; }

};

class sys_var_enum_const :public sys_var

{

  uint32_t SV::*offset;

  TYPELIB *enum_names;

public:

  sys_var_enum_const(sys_var_chain *chain, const char *name_arg, uint32_t 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(Session *, set_var *)

  { return 1; }

  bool update(Session *, set_var *)

  { return 1; }

  SHOW_TYPE show_type() { return SHOW_CHAR; }

  bool check_update_type(Item_result)

  { return 1; }

  bool is_readonly() const { return 1; }

  unsigned char *value_ptr(Session *session, enum_var_type type,

                           const LEX_STRING *base);

};

class sys_var_session :public sys_var

{

public:

  sys_var_session(const char *name_arg,

              sys_after_update_func func= NULL)

    :sys_var(name_arg, func)

  {}

  bool check_type(enum_var_type)

  { return 0; }

  bool check_default(enum_var_type type)

  {

    return type == OPT_GLOBAL && !option_limits;

  }

};

class sys_var_session_uint32_t :public sys_var_session

{

  sys_check_func check_func;

public:

  uint32_t SV::*offset;

  sys_var_session_uint32_t(sys_var_chain *chain, const char *name_arg,

                           uint32_t SV::*offset_arg,

                           sys_check_func c_func= NULL,

                           sys_after_update_func au_func= NULL)

    :sys_var_session(name_arg, au_func), check_func(c_func),

    offset(offset_arg)

  { chain_sys_var(chain); }

  bool check(Session *session, set_var *var);

  bool update(Session *session, set_var *var);

  void set_default(Session *session, enum_var_type type);

  SHOW_TYPE show_type() { return SHOW_INT; }

  unsigned char *value_ptr(Session *session, enum_var_type type,

                           const LEX_STRING *base);

};

class sys_var_session_ha_rows :public sys_var_session

{

public:

  ha_rows SV::*offset;

  sys_var_session_ha_rows(sys_var_chain *chain, const char *name_arg,

                      ha_rows SV::*offset_arg)

    :sys_var_session(name_arg), offset(offset_arg)

  { chain_sys_var(chain); }

  sys_var_session_ha_rows(sys_var_chain *chain, const char *name_arg,

                      ha_rows SV::*offset_arg,

		      sys_after_update_func func)

    :sys_var_session(name_arg,func), offset(offset_arg)

  { chain_sys_var(chain); }

  bool update(Session *session, set_var *var);

  void set_default(Session *session, enum_var_type type);

  SHOW_TYPE show_type() { return SHOW_HA_ROWS; }

  unsigned char *value_ptr(Session *session, enum_var_type type,

                           const LEX_STRING *base);

};

class sys_var_session_uint64_t :public sys_var_session

{

  sys_check_func check_func;

public:

  uint64_t SV::*offset;

  bool only_global;

  sys_var_session_uint64_t(sys_var_chain *chain, 

                           const char *name_arg,

                           uint64_t SV::*offset_arg,

                           sys_after_update_func au_func= NULL,

                           sys_check_func c_func= NULL)

    :sys_var_session(name_arg, au_func),

    check_func(c_func),

    offset(offset_arg)

  { chain_sys_var(chain); }

  sys_var_session_uint64_t(sys_var_chain *chain,

                           const char *name_arg,

                           uint64_t SV::*offset_arg,

                           sys_after_update_func func,

                           bool only_global_arg,

                           sys_check_func cfunc= NULL)

    :sys_var_session(name_arg, func),

    check_func(cfunc),

    offset(offset_arg),

    only_global(only_global_arg)

  { chain_sys_var(chain); }

  bool update(Session *session, set_var *var);

  void set_default(Session *session, enum_var_type type);

  SHOW_TYPE show_type() { return SHOW_LONGLONG; }

  unsigned char *value_ptr(Session *session, enum_var_type type,

                           const LEX_STRING *base);

  bool check(Session *session, 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_session_size_t :public sys_var_session

{

  sys_check_func check_func;

public:

  size_t SV::*offset;

  bool only_global;

  sys_var_session_size_t(sys_var_chain *chain, const char *name_arg,

                         size_t SV::*offset_arg,

                         sys_after_update_func au_func= NULL,

                         sys_check_func c_func= NULL)

    :sys_var_session(name_arg, au_func),

     check_func(c_func),

     offset(offset_arg)

  { chain_sys_var(chain); }

  sys_var_session_size_t(sys_var_chain *chain,

                         const char *name_arg,

                         size_t SV::*offset_arg,

                         sys_after_update_func func,

                         bool only_global_arg,

                         sys_check_func cfunc= NULL)

    :sys_var_session(name_arg, func),

     check_func(cfunc),

     offset(offset_arg),

     only_global(only_global_arg)

  { chain_sys_var(chain); }

  bool update(Session *session, set_var *var);

  void set_default(Session *session, enum_var_type type);

  SHOW_TYPE show_type() { return SHOW_SIZE; }

  unsigned char *value_ptr(Session *session, enum_var_type type,

                           const LEX_STRING *base);

  bool check(Session *session, 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_session_bool :public sys_var_session

{

public:

  bool SV::*offset;

  sys_var_session_bool(sys_var_chain *chain, const char *name_arg, bool SV::*offset_arg)

    :sys_var_session(name_arg), offset(offset_arg)

  { chain_sys_var(chain); }

  sys_var_session_bool(sys_var_chain *chain, const char *name_arg, bool SV::*offset_arg,

		   sys_after_update_func func)

    :sys_var_session(name_arg,func), offset(offset_arg)

  { chain_sys_var(chain); }

  bool update(Session *session, set_var *var);

  void set_default(Session *session, enum_var_type type);

  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }

  unsigned char *value_ptr(Session *session, enum_var_type type,

                           const LEX_STRING *base);

  bool check(Session *session, set_var *var)

  {

    return check_enum(session, var, &bool_typelib);

  }

  bool check_update_type(Item_result)

  { return 0; }

};

class sys_var_session_enum :public sys_var_session

{

protected:

  uint32_t SV::*offset;

  TYPELIB *enum_names;

  sys_check_func check_func;

public:

  sys_var_session_enum(sys_var_chain *chain, const char *name_arg,

                   uint32_t SV::*offset_arg, TYPELIB *typelib,

                   sys_after_update_func func= NULL,

                   sys_check_func check_f= NULL)

    :sys_var_session(name_arg, func), offset(offset_arg),

    enum_names(typelib), check_func(check_f)

  { chain_sys_var(chain); }

  bool check(Session *session, set_var *var)

  {

    int ret= 0;

    if (check_func)

      ret= (*check_func)(session, var);

    return ret ? ret : check_enum(session, var, enum_names);

  }

  bool update(Session *session, set_var *var);

  void set_default(Session *session, enum_var_type type);