~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_ITEM_SET_H

#define DRIZZLED_ITEM_SET_H

#include <drizzled/functions/func.h>

#include <drizzled/functions/set_user_var.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, delay_key_write_typelib, sql_mode_typelib,

       optimizer_switch_typelib, slave_exec_mode_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);

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

  uint32_t 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(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 *session_arg __attribute__((unused)),

                           enum_var_type type __attribute__((unused)))

  {}

  virtual SHOW_TYPE show_type() { return SHOW_UNDEF; }

  virtual unsigned char *value_ptr(Session *session __attribute__((unused)),

                           enum_var_type type __attribute__((unused)),

                           LEX_STRING *base __attribute__((unused)))

  { 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 __attribute__((unused)))

  { return option_limits == 0; }

  Item *item(Session *session, 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 uint64_t variable that requires its access to be

  protected with a mutex.

*/

class sys_var_long_ptr_global: public sys_var_global

{

  uint64_t *value;

public:

  sys_var_long_ptr_global(sys_var_chain *chain, const char *name_arg,

                          uint64_t *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(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_LONG; }

  unsigned char *value_ptr(Session *session __attribute__((unused)),

                   enum_var_type type __attribute__((unused)),

                   LEX_STRING *base __attribute__((unused)))

  { return (unsigned char*) value; }

};

/*

  A global uint64_t 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, uint64_t *value_ptr,

                   sys_after_update_func after_update_arg= NULL);

};

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

  void set_default(Session *session, enum_var_type type);

  SHOW_TYPE show_type() { return SHOW_LONG; }

  unsigned char *value_ptr(Session *session __attribute__((unused)),

                   enum_var_type type __attribute__((unused)),

                   LEX_STRING *base __attribute__((unused)))

  { 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 *session __attribute__((unused)),

                   enum_var_type type __attribute__((unused)),

                   LEX_STRING *base __attribute__((unused)))

  { 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 *session __attribute__((unused)),

                   enum_var_type type __attribute__((unused)),

                   LEX_STRING *base __attribute__((unused)))

  { return (unsigned char*) value; }

  bool check_update_type(Item_result type __attribute__((unused)))

  { 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 *session __attribute__((unused)),

                   enum_var_type type __attribute__((unused)),

                   LEX_STRING *base __attribute__((unused)))

  { return (unsigned char*) value; }

  bool check_update_type(Item_result type)

  {

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

  }

  bool check_default(enum_var_type type __attribute__((unused)))

  { 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 *session __attribute__((unused)),

             set_var *var __attribute__((unused)))

  {

    return 1;

  }

  bool update(Session *session __attribute__((unused)),

              set_var *var __attribute__((unused)))

  {

    return 1;

  }

  SHOW_TYPE show_type() { return SHOW_CHAR; }

  unsigned char *value_ptr(Session *session __attribute__((unused)),

                   enum_var_type type __attribute__((unused)),

                   LEX_STRING *base __attribute__((unused)))

  {

    return (unsigned char*) value;

  }

  bool check_update_type(Item_result type __attribute__((unused)))

  {

    return 1;

  }

  bool check_default(enum_var_type type __attribute__((unused)))

  { 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 *session __attribute__((unused)),

             set_var *var __attribute__((unused)))

  {

    return 1;

  }

  bool update(Session *session __attribute__((unused)),

              set_var *var __attribute__((unused)))

  {

    return 1;

  }

  SHOW_TYPE show_type() { return SHOW_CHAR; }

  unsigned char *value_ptr(Session *session __attribute__((unused)),

                   enum_var_type type __attribute__((unused)),

                   LEX_STRING *base __attribute__((unused)))

  {

    return (unsigned char*) *value;

  }

  bool check_update_type(Item_result type __attribute__((unused)))

  {

    return 1;

  }

  bool check_default(enum_var_type type __attribute__((unused)))

  { 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, LEX_STRING *base);

  bool check_update_type(Item_result type __attribute__((unused)))

  { 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 *session __attribute__((unused)),

             set_var *var __attribute__((unused)))

  { return 1; }

  bool update(Session *session __attribute__((unused)),

              set_var *var __attribute__((unused)))

  { return 1; }

  SHOW_TYPE show_type() { return SHOW_CHAR; }

  bool check_update_type(Item_result type __attribute__((unused)))

  { return 1; }

  bool is_readonly() const { return 1; }

  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);

};

class sys_var_session :public sys_var

{

public:

  sys_var_session(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 __attribute__((unused)))

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

                           Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)

    :sys_var_session(name_arg, au_func, binlog_status_arg), 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_LONG; }

  unsigned char *value_ptr(Session *session, enum_var_type type, 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, 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,

                           Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)

    :sys_var_session(name_arg, au_func, binlog_status_arg),

    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, 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, LEX_STRING *base);

  bool check(Session *session, set_var *var)

  {

    return check_enum(session, var, &bool_typelib);

  }

  bool check_update_type(Item_result type __attribute__((unused)))

  { 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= NULL)

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

    enum_names(typelib), check_func(check)

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

  SHOW_TYPE show_type() { return SHOW_CHAR; }

  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);

  bool check_update_type(Item_result type __attribute__((unused)))

  { return 0; }

};

class sys_var_session_optimizer_switch :public sys_var_session_enum

{

public:

  sys_var_session_optimizer_switch(sys_var_chain *chain, const char *name_arg, 

                                   uint32_t SV::*offset_arg)

    :sys_var_session_enum(chain, name_arg, offset_arg, &optimizer_switch_typelib)

  {}

  bool check(Session *session, set_var *var)

  {

    return check_set(session, var, enum_names);

  }

  void set_default(Session *session, enum_var_type type);

  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);

  static bool symbolic_mode_representation(Session *session, uint32_t sql_mode,

                                           LEX_STRING *rep);

};

class sys_var_session_storage_engine :public sys_var_session

{

protected:

  plugin_ref SV::*offset;

public:

  sys_var_session_storage_engine(sys_var_chain *chain, const char *name_arg, 

                             plugin_ref SV::*offset_arg)

    :sys_var_session(name_arg), offset(offset_arg)

  { chain_sys_var(chain); }

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

  SHOW_TYPE show_type() { return SHOW_CHAR; }

  bool check_update_type(Item_result type)

  {