~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

 */

/**

  @file Handling of MySQL SQL variables

  @details

  To add a new variable, one has to do the following:

  - Use one of the 'sys_var... classes from set_var.h or write a specific

    one for the variable type.

  - Define it in the 'variable definition list' in this file.

  - If the variable is thread specific, add it to 'system_variables' struct.

    If not, add it to mysqld.cc and an declaration in 'mysql_priv.h'

  - If the variable should be changed from the command line, add a definition

    of it in the my_option structure list in mysqld.cc

  - Don't forget to initialize new fields in global_system_variables and

    max_system_variables!

  @todo

    Add full support for the variable character_set (for 4.1)

  @note

    Be careful with var->save_result: sys_var::check() only updates

    uint64_t_value; so other members of the union are garbage then; to use

    them you must first assign a value to them (in specific ::check() for

    example).

*/

#include <drizzled/server_includes.h>

#include <mysys/my_getopt.h>

#include <plugin/myisam/myisam.h>

#include <drizzled/error.h>

#include <drizzled/gettext.h>

#include <drizzled/tztime.h>

#include <drizzled/data_home.h>

#include <drizzled/set_var.h>

#include <drizzled/session.h>

#include <drizzled/sql_base.h>

#include <drizzled/lock.h>

#include <drizzled/item/uint.h>

#include <drizzled/item/null.h>

#include <drizzled/item/float.h>

#include <drizzled/sql_plugin.h>

#include "drizzled/registry.h"

#include <map>

#include <algorithm>

using namespace std;

extern const CHARSET_INFO *character_set_filesystem;

extern size_t my_thread_stack_size;

class sys_var_pluginvar;

static DYNAMIC_ARRAY fixed_show_vars;

static drizzled::Registry<sys_var *> system_variable_hash;

extern char *opt_drizzle_tmpdir;

const char *bool_type_names[]= { "OFF", "ON", NULL };

TYPELIB bool_typelib=

{

  array_elements(bool_type_names)-1, "", bool_type_names, NULL

};

static bool set_option_bit(Session *session, set_var *var);

static bool set_option_autocommit(Session *session, set_var *var);

static int  check_pseudo_thread_id(Session *session, set_var *var);

static int check_tx_isolation(Session *session, set_var *var);

static void fix_tx_isolation(Session *session, enum_var_type type);

static int check_completion_type(Session *session, set_var *var);

static void fix_completion_type(Session *session, enum_var_type type);

static void fix_max_join_size(Session *session, enum_var_type type);

static void fix_session_mem_root(Session *session, enum_var_type type);

static void fix_trans_mem_root(Session *session, enum_var_type type);

static void fix_server_id(Session *session, enum_var_type type);

static uint64_t fix_unsigned(Session *, uint64_t, const struct my_option *);

static bool get_unsigned32(Session *session, set_var *var);

static bool get_unsigned64(Session *session, set_var *var);

bool throw_bounds_warning(Session *session, bool fixed, bool unsignd,

                          const std::string &name, int64_t val);

static unsigned char *get_error_count(Session *session);

static unsigned char *get_warning_count(Session *session);

static unsigned char *get_tmpdir(Session *session);

/*

  Variable definition list

  These are variables that can be set from the command line, in

  alphabetic order.

  The variables are linked into the list. A variable is added to

  it in the constructor (see sys_var class for details).

*/

static sys_var_chain vars = { NULL, NULL };

static sys_var_session_uint64_t

sys_auto_increment_increment(&vars, "auto_increment_increment",

                             &SV::auto_increment_increment);

static sys_var_session_uint64_t

sys_auto_increment_offset(&vars, "auto_increment_offset",

                          &SV::auto_increment_offset);

static sys_var_const_str       sys_basedir(&vars, "basedir", drizzle_home);

static sys_var_session_uint64_t	sys_bulk_insert_buff_size(&vars, "bulk_insert_buffer_size",

                                                          &SV::bulk_insert_buff_size);

static sys_var_session_uint32_t	sys_completion_type(&vars, "completion_type",

                                                    &SV::completion_type,

                                                    check_completion_type,

                                                    fix_completion_type);

static sys_var_collation_sv

sys_collation_server(&vars, "collation_server", &SV::collation_server, &default_charset_info);

static sys_var_const_str       sys_datadir(&vars, "datadir", drizzle_real_data_home);

static sys_var_session_uint64_t	sys_join_buffer_size(&vars, "join_buffer_size",

                                                     &SV::join_buff_size);

static sys_var_key_buffer_size	sys_key_buffer_size(&vars, "key_buffer_size");

static sys_var_key_cache_uint32_t  sys_key_cache_block_size(&vars, "key_cache_block_size",

                                                        offsetof(KEY_CACHE,

                                                                 param_block_size));

static sys_var_key_cache_uint32_t	sys_key_cache_division_limit(&vars, "key_cache_division_limit",

                                                           offsetof(KEY_CACHE,

                                                                    param_division_limit));

static sys_var_key_cache_uint32_t  sys_key_cache_age_threshold(&vars, "key_cache_age_threshold",

                                                           offsetof(KEY_CACHE,

                                                                    param_age_threshold));

static sys_var_session_uint32_t	sys_max_allowed_packet(&vars, "max_allowed_packet",

                                                       &SV::max_allowed_packet);

static sys_var_uint64_t_ptr	sys_max_connect_errors(&vars, "max_connect_errors",

                                               &max_connect_errors);

static sys_var_session_uint64_t	sys_max_error_count(&vars, "max_error_count",

                                                  &SV::max_error_count);

static sys_var_session_uint64_t	sys_max_heap_table_size(&vars, "max_heap_table_size",

                                                        &SV::max_heap_table_size);

static sys_var_session_uint64_t sys_pseudo_thread_id(&vars, "pseudo_thread_id",

                                              &SV::pseudo_thread_id,

                                              0, check_pseudo_thread_id);

static sys_var_session_ha_rows	sys_max_join_size(&vars, "max_join_size",

                                                  &SV::max_join_size,

                                                  fix_max_join_size);

static sys_var_session_uint64_t	sys_max_seeks_for_key(&vars, "max_seeks_for_key",

                                                      &SV::max_seeks_for_key);

static sys_var_session_uint64_t   sys_max_length_for_sort_data(&vars, "max_length_for_sort_data",

                                                               &SV::max_length_for_sort_data);

static sys_var_session_size_t	sys_max_sort_length(&vars, "max_sort_length",

                                                    &SV::max_sort_length);

static sys_var_uint64_t_ptr	sys_max_write_lock_count(&vars, "max_write_lock_count",

                                                 &max_write_lock_count);

static sys_var_session_uint64_t sys_min_examined_row_limit(&vars, "min_examined_row_limit",

                                                           &SV::min_examined_row_limit);

static sys_var_session_uint32_t	sys_net_buffer_length(&vars, "net_buffer_length",

                                                      &SV::net_buffer_length);

/* these two cannot be static */

static sys_var_session_bool sys_optimizer_prune_level(&vars, "optimizer_prune_level",

                                                      &SV::optimizer_prune_level);

static sys_var_session_uint32_t sys_optimizer_search_depth(&vars, "optimizer_search_depth",

                                                           &SV::optimizer_search_depth);

static sys_var_session_uint64_t sys_preload_buff_size(&vars, "preload_buffer_size",

                                                      &SV::preload_buff_size);

static sys_var_session_uint32_t sys_read_buff_size(&vars, "read_buffer_size",

                                                   &SV::read_buff_size);

static sys_var_session_uint32_t	sys_read_rnd_buff_size(&vars, "read_rnd_buffer_size",

                                                       &SV::read_rnd_buff_size);

static sys_var_session_uint32_t	sys_div_precincrement(&vars, "div_precision_increment",

                                                      &SV::div_precincrement);

static sys_var_session_size_t	sys_range_alloc_block_size(&vars, "range_alloc_block_size",

                                                           &SV::range_alloc_block_size);

static sys_var_session_uint32_t	sys_query_alloc_block_size(&vars, "query_alloc_block_size",

                                                           &SV::query_alloc_block_size,

                                                           false, fix_session_mem_root);

static sys_var_session_uint32_t	sys_query_prealloc_size(&vars, "query_prealloc_size",

                                                        &SV::query_prealloc_size,

                                                        false, fix_session_mem_root);

static sys_var_readonly sys_tmpdir(&vars, "tmpdir", OPT_GLOBAL, SHOW_CHAR, get_tmpdir);

static sys_var_session_uint32_t	sys_trans_alloc_block_size(&vars, "transaction_alloc_block_size",

                                                           &SV::trans_alloc_block_size,

                                                           false, fix_trans_mem_root);

static sys_var_session_uint32_t	sys_trans_prealloc_size(&vars, "transaction_prealloc_size",

                                                        &SV::trans_prealloc_size,

                                                        false, fix_session_mem_root);

static sys_var_const_str_ptr sys_secure_file_priv(&vars, "secure_file_priv",

                                             &opt_secure_file_priv);

static sys_var_uint32_t_ptr  sys_server_id(&vars, "server_id", &server_id,

                                           fix_server_id);

static sys_var_session_size_t	sys_sort_buffer(&vars, "sort_buffer_size",

                                                &SV::sortbuff_size);

static sys_var_session_optimizer_switch   sys_optimizer_switch(&vars, "optimizer_switch",

                                                               &SV::optimizer_switch);

static sys_var_session_storage_engine sys_storage_engine(&vars, "storage_engine",

				       &SV::storage_engine);

static sys_var_const_str	sys_system_time_zone(&vars, "system_time_zone",

                                             system_time_zone);

static sys_var_uint64_t_ptr	sys_table_def_size(&vars, "table_definition_cache",

                                           &table_def_size);

static sys_var_uint64_t_ptr	sys_table_cache_size(&vars, "table_open_cache",

					     &table_cache_size);

static sys_var_uint64_t_ptr	sys_table_lock_wait_timeout(&vars, "table_lock_wait_timeout",

                                                    &table_lock_wait_timeout);

static sys_var_session_enum	sys_tx_isolation(&vars, "tx_isolation",

                                             &SV::tx_isolation,

                                             &tx_isolation_typelib,

                                             fix_tx_isolation,

                                             check_tx_isolation);

static sys_var_session_uint64_t	sys_tmp_table_size(&vars, "tmp_table_size",

					   &SV::tmp_table_size);

static sys_var_bool_ptr  sys_timed_mutexes(&vars, "timed_mutexes", &timed_mutexes);

static sys_var_const_str	sys_version(&vars, "version", VERSION);

static sys_var_const_str	sys_version_comment(&vars, "version_comment",

                                            COMPILATION_COMMENT);

static sys_var_const_str	sys_version_compile_machine(&vars, "version_compile_machine",

                                                      HOST_CPU);

static sys_var_const_str	sys_version_compile_os(&vars, "version_compile_os",

                                                 HOST_OS);

static sys_var_const_str	sys_version_compile_vendor(&vars, "version_compile_vendor",

                                                 HOST_VENDOR);

/* Variables that are bits in Session */

sys_var_session_bit sys_autocommit(&vars, "autocommit", 0,

                               set_option_autocommit,

                               OPTION_NOT_AUTOCOMMIT,

                               1);

static sys_var_session_bit	sys_big_selects(&vars, "sql_big_selects", 0,

					set_option_bit,

					OPTION_BIG_SELECTS);

static sys_var_session_bit	sys_sql_warnings(&vars, "sql_warnings", 0,

					 set_option_bit,

					 OPTION_WARNINGS);

static sys_var_session_bit	sys_sql_notes(&vars, "sql_notes", 0,

					 set_option_bit,

					 OPTION_SQL_NOTES);

static sys_var_session_bit	sys_safe_updates(&vars, "sql_safe_updates", 0,

					 set_option_bit,

					 OPTION_SAFE_UPDATES);

static sys_var_session_bit	sys_buffer_results(&vars, "sql_buffer_result", 0,

					   set_option_bit,

					   OPTION_BUFFER_RESULT);

static sys_var_session_bit	sys_foreign_key_checks(&vars, "foreign_key_checks", 0,

					       set_option_bit,

					       OPTION_NO_FOREIGN_KEY_CHECKS, 1);

static sys_var_session_bit	sys_unique_checks(&vars, "unique_checks", 0,

					  set_option_bit,

					  OPTION_RELAXED_UNIQUE_CHECKS, 1);

/* Local state variables */

static sys_var_session_ha_rows	sys_select_limit(&vars, "sql_select_limit",

						 &SV::select_limit);

static sys_var_timestamp sys_timestamp(&vars, "timestamp");

static sys_var_last_insert_id

sys_last_insert_id(&vars, "last_insert_id");

/*

  identity is an alias for last_insert_id(), so that we are compatible

  with Sybase

*/

static sys_var_last_insert_id sys_identity(&vars, "identity");

static sys_var_session_lc_time_names sys_lc_time_names(&vars, "lc_time_names");

/*

  We want statements referring explicitly to @@session.insert_id to be

  unsafe, because insert_id is modified internally by the slave sql

  thread when NULL values are inserted in an AUTO_INCREMENT column.

  This modification interfers with the value of the

  @@session.insert_id variable if @@session.insert_id is referred

  explicitly by an insert statement (as is seen by executing "SET

  @@session.insert_id=0; CREATE TABLE t (a INT, b INT KEY

  AUTO_INCREMENT); INSERT INTO t(a) VALUES (@@session.insert_id);" in

  statement-based logging mode: t will be different on master and

  slave).

*/

static sys_var_readonly sys_error_count(&vars, "error_count",

                                        OPT_SESSION,

                                        SHOW_INT,

                                        get_error_count);

static sys_var_readonly sys_warning_count(&vars, "warning_count",

                                          OPT_SESSION,

                                          SHOW_INT,

                                          get_warning_count);

sys_var_session_uint64_t sys_group_concat_max_len(&vars, "group_concat_max_len",

                                                  &SV::group_concat_max_len);

sys_var_session_time_zone sys_time_zone(&vars, "time_zone");

/* Global read-only variable containing hostname */

static sys_var_const_str        sys_hostname(&vars, "hostname", glob_hostname);

/* Read only variables */

static sys_var_have_variable sys_have_symlink(&vars, "have_symlink", &have_symlink);

/*

  Additional variables (not derived from sys_var class, not accessible as

  @@varname in SELECT or SET). Sorted in alphabetical order to facilitate

  maintenance - SHOW VARIABLES will sort its output.

  TODO: remove this list completely

*/

#define FIXED_VARS_SIZE (sizeof(fixed_vars) / sizeof(SHOW_VAR))

static SHOW_VAR fixed_vars[]= {

  {"back_log",                (char*) &back_log,                    SHOW_INT},

  {"language",                language,                             SHOW_CHAR},

#ifdef HAVE_MLOCKALL

  {"locked_in_memory",	      (char*) &locked_in_memory,	    SHOW_MY_BOOL},

#endif

  {"pid_file",                (char*) pidfile_name,                 SHOW_CHAR},

  {"plugin_dir",              (char*) opt_plugin_dir,               SHOW_CHAR},

  {"port",                    (char*) &drizzled_tcp_port,           SHOW_INT},

  {"thread_stack",            (char*) &my_thread_stack_size,        SHOW_INT},

};

bool sys_var::check(Session *, set_var *var)

{

  var->save_result.uint64_t_value= var->value->val_int();

  return 0;

}

bool sys_var_str::check(Session *session, set_var *var)

{

  int res;

  if (!check_func)

    return 0;

  if ((res=(*check_func)(session, var)) < 0)

    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), getName().c_str(), var->value->str_value.ptr());

  return res;

}

/*

  Functions to check and update variables

*/

/**

  Set the OPTION_BIG_SELECTS flag if max_join_size == HA_POS_ERROR.

*/

static void fix_max_join_size(Session *session, enum_var_type type)

{

  if (type != OPT_GLOBAL)

  {

    if (session->variables.max_join_size == HA_POS_ERROR)

      session->options|= OPTION_BIG_SELECTS;

    else

      session->options&= ~OPTION_BIG_SELECTS;

  }

}

/**

  Can't change the 'next' tx_isolation while we are already in

  a transaction

*/

static int check_tx_isolation(Session *session, set_var *var)

{

  if (var->type == OPT_DEFAULT && (session->server_status & SERVER_STATUS_IN_TRANS))

  {

    my_error(ER_CANT_CHANGE_TX_ISOLATION, MYF(0));

    return 1;

  }

  return 0;

}

/*

  If one doesn't use the SESSION modifier, the isolation level

  is only active for the next command.

*/

static void fix_tx_isolation(Session *session, enum_var_type type)

{

  if (type == OPT_SESSION)

    session->session_tx_isolation= ((enum_tx_isolation)

                                    session->variables.tx_isolation);

}

static void fix_completion_type(Session *, enum_var_type) {}

static int check_completion_type(Session *, set_var *var)

{

  int64_t val= var->value->val_int();

  if (val < 0 || val > 2)

  {

    char buf[64];

    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->var->getName().c_str(), llstr(val, buf));

    return 1;

  }

  return 0;

}

static void fix_session_mem_root(Session *session, enum_var_type type)

{

  if (type != OPT_GLOBAL)

    reset_root_defaults(session->mem_root,

                        session->variables.query_alloc_block_size,

                        session->variables.query_prealloc_size);

}

static void fix_trans_mem_root(Session *session, enum_var_type type)

{

  if (type != OPT_GLOBAL)

    reset_root_defaults(&session->transaction.mem_root,

                        session->variables.trans_alloc_block_size,

                        session->variables.trans_prealloc_size);

}

static void fix_server_id(Session *, enum_var_type)

{

}

bool throw_bounds_warning(Session *session, bool fixed, bool unsignd,

                          const std::string &name, int64_t val)

{

  if (fixed)

  {

    char buf[22];

    if (unsignd)

      ullstr((uint64_t) val, buf);

    else

      llstr(val, buf);

    push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,

                        ER_TRUNCATED_WRONG_VALUE,

                        ER(ER_TRUNCATED_WRONG_VALUE), name.c_str(), buf);

  }

  return false;

}

static uint64_t fix_unsigned(Session *session, uint64_t num,

                              const struct my_option *option_limits)

{

  bool fixed= false;

  uint64_t out= getopt_ull_limit_value(num, option_limits, &fixed);

  throw_bounds_warning(session, fixed, true, option_limits->name, (int64_t) num);

  return out;

}

static size_t fix_size_t(Session *session, size_t num,

                           const struct my_option *option_limits)

{

  bool fixed= false;

  size_t out= (size_t)getopt_ull_limit_value(num, option_limits, &fixed);

  throw_bounds_warning(session, fixed, true, option_limits->name, (int64_t) num);

  return out;

}

static bool get_unsigned32(Session *session, set_var *var)

{

  if (var->value->unsigned_flag)

    var->save_result.uint32_t_value= 

      static_cast<uint32_t>(var->value->val_int());

  else

  {

    int64_t v= var->value->val_int();

    if (v > UINT32_MAX)

      throw_bounds_warning(session, true, true,var->var->getName().c_str(), v);

    var->save_result.uint32_t_value= 

      static_cast<uint32_t>((v > UINT32_MAX) ? UINT32_MAX : (v < 0) ? 0 : v);

  }

  return false;

}

static bool get_unsigned64(Session *, set_var *var)

{

  if (var->value->unsigned_flag)

      var->save_result.uint64_t_value=(uint64_t) var->value->val_int();

  else

  {

    int64_t v= var->value->val_int();

      var->save_result.uint64_t_value= (uint64_t) ((v < 0) ? 0 : v);

  }

  return 0;

}

static bool get_size_t(Session *, set_var *var)

{

  if (var->value->unsigned_flag)

    var->save_result.size_t_value= (size_t) var->value->val_int();

  else

  {

    ssize_t v= (ssize_t)var->value->val_int();

    var->save_result.size_t_value= (size_t) ((v < 0) ? 0 : v);

  }

  return 0;

}

bool sys_var_uint32_t_ptr::check(Session *, set_var *var)

{

  var->save_result.uint32_t_value= (uint32_t)var->value->val_int();

  return 0;

}

bool sys_var_uint32_t_ptr::update(Session *session, set_var *var)

{

  uint32_t tmp= var->save_result.uint32_t_value;

  pthread_mutex_lock(&LOCK_global_system_variables);

  if (option_limits)

  {

    uint32_t newvalue= (uint32_t) fix_unsigned(session, tmp, option_limits);

    if(newvalue==tmp)

      *value= newvalue;

  }

  else

    *value= (uint32_t) tmp;

  pthread_mutex_unlock(&LOCK_global_system_variables);

  return 0;

}

void sys_var_uint32_t_ptr::set_default(Session *, enum_var_type)

{

  bool not_used;

  pthread_mutex_lock(&LOCK_global_system_variables);

  *value= (uint32_t)getopt_ull_limit_value((uint32_t) option_limits->def_value,

                                           option_limits, &not_used);

  pthread_mutex_unlock(&LOCK_global_system_variables);

}

bool sys_var_uint64_t_ptr::update(Session *session, set_var *var)

{

  uint64_t tmp= var->save_result.uint64_t_value;

  pthread_mutex_lock(&LOCK_global_system_variables);

  if (option_limits)

  {

    uint64_t newvalue= (uint64_t) fix_unsigned(session, tmp, option_limits);

    if(newvalue==tmp)

      *value= newvalue;

  }

  else

    *value= (uint64_t) tmp;

  pthread_mutex_unlock(&LOCK_global_system_variables);

  return 0;

}

void sys_var_uint64_t_ptr::set_default(Session *, enum_var_type)

{

  bool not_used;

  pthread_mutex_lock(&LOCK_global_system_variables);

  *value= getopt_ull_limit_value((uint64_t) option_limits->def_value,

                                 option_limits, &not_used);

  pthread_mutex_unlock(&LOCK_global_system_variables);

}

bool sys_var_size_t_ptr::update(Session *session, set_var *var)

{

  size_t tmp= var->save_result.size_t_value;

  pthread_mutex_lock(&LOCK_global_system_variables);

  if (option_limits)

    *value= fix_size_t(session, tmp, option_limits);

  else

    *value= tmp;

  pthread_mutex_unlock(&LOCK_global_system_variables);

  return 0;

}

void sys_var_size_t_ptr::set_default(Session *, enum_var_type)

{

  bool not_used;

  pthread_mutex_lock(&LOCK_global_system_variables);

  *value= (size_t)getopt_ull_limit_value((size_t) option_limits->def_value,

                                         option_limits, &not_used);

  pthread_mutex_unlock(&LOCK_global_system_variables);

}

bool sys_var_bool_ptr::update(Session *, set_var *var)

{

  *value= (bool) var->save_result.uint32_t_value;

  return 0;

}

void sys_var_bool_ptr::set_default(Session *, enum_var_type)

{

  *value= (bool) option_limits->def_value;

}

bool sys_var_enum::update(Session *, set_var *var)

{

  *value= (uint32_t) var->save_result.uint32_t_value;

  return 0;

}

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

{

  return (unsigned char*) enum_names->type_names[*value];

}

unsigned char *sys_var_enum_const::value_ptr(Session *, enum_var_type,

                                             const LEX_STRING *)