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

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

#define DRIZZLED_SYS_VAR_H

#include <string>

#include <boost/filesystem.hpp>

#include "drizzled/constrained_value.h"

#include "drizzled/set_var.h"

#include "drizzled/show_type.h"

#include "drizzled/typelib.h"

#include "drizzled/item_result.h"

#include "drizzled/base.h"

#include "drizzled/global_charset_info.h"

#include "drizzled/lex_string.h"

namespace drizzled

{

class sys_var;

class Time_zone;

typedef struct my_locale_st MY_LOCALE;

extern TYPELIB bool_typelib;

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

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

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

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

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

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

extern struct drizzle_system_variables max_system_variables;

extern size_t table_def_size;

extern std::string drizzle_tmpdir;

extern const char *first_keyword;

extern const char *in_left_expr_name;

extern const char *in_additional_cond;

extern const char *in_having_cond;

extern char glob_hostname[FN_REFLEN];

extern boost::filesystem::path basedir;

extern boost::filesystem::path pid_file;

extern boost::filesystem::path secure_file_priv;

extern char system_time_zone[30];

extern char *opt_tc_log_file;

extern uint64_t session_startup_options;

extern uint32_t global_thread_id;

extern uint64_t table_cache_size;

extern uint64_t max_connect_errors;

extern back_log_constraints back_log;

extern uint32_t ha_open_options;

extern char *drizzled_bind_host;

extern uint32_t dropping_tables;

extern bool opt_endinfo;

extern uint32_t volatile thread_running;

extern uint32_t volatile global_read_lock;

extern bool opt_readonly;

extern char *default_tz_name;

extern const char *opt_scheduler;

uint64_t fix_unsigned(Session *, uint64_t, const struct option *);

int sys_var_init();

/**

 * A class which represents a variable, either global or 

 * session-local.

 */

class sys_var

{

protected:

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

  sys_check_func check_func;

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

  struct option *option_limits; /**< Updated by by sys_var_init() */

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

public:

  sys_var(const std::string &name_arg,

          sys_after_update_func func= NULL,

          sys_check_func check_func_arg= NULL)

    :

    name(name_arg),

    check_func(check_func_arg),

    after_update(func),

    option_limits(NULL),

    m_allow_empty_value(true)

  {}

  virtual ~sys_var() {}

  void setName(const std::string &name_in)

  {

    name= name_in;

  }

  /** 

   * 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 variable's option limits

   */

  inline struct option *getOptionLimits() const

  {

    return option_limits;

  }

  /**

   * Sets the pointer to the variable's option limits

   *

   * @param Pointer to the option limits option variable

   */

  inline void setOptionLimits(struct 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);

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

  virtual void set_default(Session *, sql_var_t)

  {}

  virtual SHOW_TYPE show_type()

  {

    return SHOW_UNDEF;

  }

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

  {

    return 0;

  }

  virtual bool check_type(sql_var_t 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(sql_var_t)

  {

    return option_limits == 0;

  }

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

  virtual bool is_readonly() const

  {

    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(const char *name_arg,

                       uint32_t *value_ptr_arg)

    :sys_var(name_arg),value(value_ptr_arg)

  {  }

  sys_var_uint32_t_ptr(const char *name_arg,

                       uint32_t *value_ptr_arg,

                       sys_after_update_func func)

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

  {  }

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

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

  void set_default(Session *session, sql_var_t type);

  SHOW_TYPE show_type() { return SHOW_INT; }

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

  { return (unsigned char*) value; }

};

class sys_var_uint32_t_ptr_readonly :

  public sys_var_uint32_t_ptr

{

public:

  sys_var_uint32_t_ptr_readonly(const char *name_arg,

                                uint32_t *value_ptr_arg) :

    sys_var_uint32_t_ptr(name_arg, value_ptr_arg)

  {}

  sys_var_uint32_t_ptr_readonly(const char *name_arg,

                                uint32_t *value_ptr_arg,

                                sys_after_update_func func) :

    sys_var_uint32_t_ptr(name_arg, value_ptr_arg, func)

  {}

  bool is_readonly() const

  {

    return true;

  }

};

class sys_var_uint64_t_ptr :public sys_var

{

  uint64_t *value;

  const uint64_t default_value;

  bool have_default_value;

public:

  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg) :

    sys_var(name_arg),

    value(value_ptr_arg),

    default_value(0),

    have_default_value(false)

  {  }

  sys_var_uint64_t_ptr(const char *name_arg,

                       uint64_t *value_ptr_arg,

                       const uint64_t default_value_in) :

    sys_var(name_arg),

    value(value_ptr_arg),

    default_value(default_value_in),

    have_default_value(true)

  {  }

  sys_var_uint64_t_ptr(const char *name_arg,

                       uint64_t *value_ptr_arg,

                       sys_after_update_func func) :

    sys_var(name_arg,func),

    value(value_ptr_arg),

    default_value(0),

    have_default_value(false)

  {  }

  sys_var_uint64_t_ptr(const char *name_arg,

                       uint64_t *value_ptr_arg,

                       sys_after_update_func func,

                       const uint64_t default_value_in) :

    sys_var(name_arg,func),

    value(value_ptr_arg),

    default_value(default_value_in),

    have_default_value(true)

  {  }

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

  void set_default(Session *session, sql_var_t type);

  virtual bool check_default(sql_var_t)

  {

    return (not have_default_value) && option_limits == 0;

  }

  SHOW_TYPE show_type() { return SHOW_LONGLONG; }

  unsigned char *value_ptr(Session *, sql_var_t,

                           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(const char *name_arg, size_t *value_ptr_arg)

    :sys_var(name_arg),value(value_ptr_arg)

  {  }

  sys_var_size_t_ptr(const char *name_arg, size_t *value_ptr_arg,

                     sys_after_update_func func)

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

  {  }

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

  void set_default(Session *session, sql_var_t type);

  SHOW_TYPE show_type() { return SHOW_SIZE; }

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

  { return (unsigned char*) value; }

};

class sys_var_bool_ptr :public sys_var

{

  bool default_value;

public:

  bool *value;

  sys_var_bool_ptr(const std::string &name_arg, bool *value_arg,

                   sys_after_update_func func= NULL) :

    sys_var(name_arg, func), default_value(*value_arg), value(value_arg)

  { }

  bool check(Session *session, set_var *var)

  {

    return check_enum(session, var, &bool_typelib);

  }

  virtual bool check_default(sql_var_t)

  {

    return false;

  }

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

  void set_default(Session *session, sql_var_t type);

  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }

  unsigned char *value_ptr(Session *, sql_var_t, 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(const char *name_arg,

                            bool *value_arg)

    :sys_var_bool_ptr(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_update_func update_func;

  sys_set_default_func set_default_func;

  sys_var_str(const char *name_arg,

              sys_check_func check_func_arg,

              sys_update_func update_func_arg,

              sys_set_default_func set_default_func_arg,

              char *value_arg) :

    sys_var(name_arg, NULL, check_func_arg),

    value(value_arg),

    update_func(update_func_arg),

    set_default_func(set_default_func_arg)

  {  }

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

  bool update(Session *session, set_var *var)

  {

    return (*update_func)(session, var);

  }

  void set_default(Session *session, sql_var_t type)

  {

    (*set_default_func)(session, type);

  }

  SHOW_TYPE show_type() { return SHOW_CHAR; }

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

  { return (unsigned char*) value; }

  bool check_update_type(Item_result type)

  {

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

  }

  bool check_default(sql_var_t)

  { return 0; }

};

class sys_var_fs_path :

  public sys_var

{

  const boost::filesystem::path &value;

public:

  sys_var_fs_path(const char *name_arg,

                  const boost::filesystem::path& value_arg) :

    sys_var(name_arg),

    value(value_arg)

  { }

  inline void set(char *)

  { }

  bool check(Session *, set_var *)

  {

    return true;

  }

  bool update(Session *, set_var *)

  {

    return true;

  }

  SHOW_TYPE show_type() { return SHOW_CHAR; }

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

  {

    return (unsigned char*)(value.file_string().c_str());

  }

  bool check_update_type(Item_result)

  {

    return true;

  }

  bool check_default(sql_var_t) { return true; }

  bool is_readonly() const { return true; }

};

template<class T>

class sys_var_constrained_value :

  public sys_var

{

  constrained_value<T> &value;

  T basic_value;

  T default_value;

public:

  sys_var_constrained_value(const char *name_arg,

                            constrained_value<T> &value_arg) :

    sys_var(name_arg),

    value(value_arg),

    default_value(value_arg.get())

  { }

  sys_var_constrained_value(const char *name_arg,

                            constrained_value<T> &value_arg,

                            sys_after_update_func after_update_func_arg) :

    sys_var(name_arg, after_update_func_arg),

    value(value_arg),

    default_value(value_arg.get())

  { }

  sys_var_constrained_value(const char *name_arg,

                            constrained_value<T> &value_arg,

                            sys_check_func check_func_arg) :

    sys_var(name_arg, NULL, check_func_arg),

    value(value_arg),

    default_value(value_arg.get())

  { }

public:

  bool is_readonly() const

  {

    return false;

  }

  SHOW_TYPE show_type() { return SHOW_INT; }

  bool update(Session *, set_var *var)

  {

    value= var->save_result.uint32_t_value;

    return false;

  }

  bool check_default(sql_var_t)

  {

    return false;

  }

  void set_default(Session *, sql_var_t)

  {

    value= default_value;

  }

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

  {

    basic_value= value.get();

    return (unsigned char*)&basic_value;

  }

};

template<>

inline SHOW_TYPE sys_var_constrained_value<uint64_t>::show_type()

{

  return SHOW_LONGLONG;

}

template<>

inline SHOW_TYPE sys_var_constrained_value<int64_t>::show_type()

{

  return SHOW_LONGLONG;

}

template<>

inline SHOW_TYPE sys_var_constrained_value<uint32_t>::show_type()

{

  return SHOW_INT;

}

template<>

inline SHOW_TYPE sys_var_constrained_value<int32_t>::show_type()

{

  return SHOW_LONG;

}

template<>

inline bool sys_var_constrained_value<uint64_t>::update(Session *, set_var *var)

{

  value= var->save_result.uint64_t_value;

  return false;

}

template<>

inline bool sys_var_constrained_value<uint32_t>::update(Session *, set_var *var)

{

  value= var->save_result.uint32_t_value;

  return false;

}

template<class T>

class sys_var_constrained_value_readonly :

  public sys_var_constrained_value<T>

{

public:

  sys_var_constrained_value_readonly(const char *name_arg,

                                     constrained_value<T> &value_arg) :

    sys_var_constrained_value<T>(name_arg, value_arg)

  { }

  sys_var_constrained_value_readonly(const char *name_arg,

                                     constrained_value<T> &value_arg,

                                     T default_value_arg) :

    sys_var_constrained_value<T>(name_arg, value_arg, default_value_arg)

  { }

public:

  bool is_readonly() const

  {

    return true;

  }

};

class sys_var_std_string :

  public sys_var

{

  std::string &value;

  sys_check_func check_func;

  sys_update_func update_func;

  sys_set_default_func set_default_func;

public:

  sys_var_std_string(const std::string &name_arg,

                     std::string &value_arg,

                     sys_check_func check_func_arg= NULL,

                     sys_update_func update_func_arg= NULL) :

    sys_var(name_arg),

    value(value_arg),

    check_func(check_func_arg),

    update_func(update_func_arg)

  {  }

  inline void set(char *val_in)

  {

    value= val_in; 

  }

  void set_check_func(sys_check_func check_func_arg= NULL)

  {

    check_func= check_func_arg;

  }

  void set_update_func(sys_update_func update_func_arg= NULL)

  {

    update_func= update_func_arg;

  }

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

  bool update(Session *session, set_var *var)

  {

    if (update_func != NULL)

    {

      return (*update_func)(session, var);

    }

    return false;

  }

  SHOW_TYPE show_type() { return SHOW_CHAR; }

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

  {

    return (unsigned char*)(value.c_str());

  }

  bool check_update_type(Item_result type)

  {

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

  }

  bool check_default(sql_var_t)

  { return true; }

  bool is_readonly() const { return false; }

};

class sys_var_const_string :

  public sys_var

{

  const std::string &value;

public:

  sys_var_const_string(const char *name_arg,

                       const std::string& value_arg) :

    sys_var(name_arg),

    value(value_arg)

  { }

  inline void set(char *)

  { }

  bool check(Session *, set_var *)

  {

    return true;

  }

  bool update(Session *, set_var *)

  {

    return true;

  }

  SHOW_TYPE show_type() { return SHOW_CHAR; }

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

  {

    return (unsigned char*)(value.c_str());

  }

  bool check_update_type(Item_result)

  {

    return true;

  }

  bool check_default(sql_var_t) { return true; }

  bool is_readonly() const { return true; }

};

class sys_var_const_string_val :

  public sys_var

{

  const std::string value;

public:

  sys_var_const_string_val(const char *name_arg,

                           const std::string& value_arg) :

    sys_var(name_arg),

    value(value_arg)

  { }

  inline void set(char *)

  { }

  bool check(Session *, set_var *)

  {

    return true;

  }

  bool update(Session *, set_var *)

  {

    return true;

  }

  SHOW_TYPE show_type() { return SHOW_CHAR; }

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

  {

    return (unsigned char*)(value.c_str());

  }

  bool check_update_type(Item_result)

  {

    return true;

  }

  bool check_default(sql_var_t) { return true; }

  bool is_readonly() const { return true; }

};

class sys_var_const_str :public sys_var

{

  char *value;					// Pointer to const value

public:

  sys_var_const_str(const char *name_arg,

                    const char *value_arg)

    :sys_var(name_arg), value((char*) value_arg)

  {  }

  inline void set (char *new_value)

  {

    value= new_value;

  }

  bool check(Session *, set_var *)

  {

    return 1;

  }

  bool update(Session *, set_var *)

  {

    return 1;