~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

 */

/**

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

*/

#include <config.h>

#include <drizzled/option.h>

#include <drizzled/error.h>

#include <drizzled/gettext.h>

#include <drizzled/data_home.h>

#include <drizzled/set_var.h>

#include <drizzled/session.h>

#include <drizzled/session/times.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/item/string.h>

#include <drizzled/plugin.h>

#include <drizzled/version.h>

#include <drizzled/internal/m_string.h>

#include <drizzled/pthread_globals.h>

#include <drizzled/charset.h>

#include <drizzled/transaction_services.h>

#include <drizzled/constrained_value.h>

#include <drizzled/visibility.h>

#include <drizzled/typelib.h>

#include <drizzled/plugin/storage_engine.h>

#include <drizzled/system_variables.h>

#include <drizzled/catalog/instance.h>

#include <cstdio>

#include <map>

#include <vector>

#include <algorithm>

using namespace std;

namespace drizzled {

namespace internal

{

	extern bool timed_mutexes;

}

extern plugin::StorageEngine *myisam_engine;

extern bool timed_mutexes;

extern struct option my_long_options[];

extern const charset_info_st *character_set_filesystem;

extern size_t my_thread_stack_size;

typedef map<string, sys_var *> SystemVariableMap;

static SystemVariableMap system_variable_map;

extern char *opt_drizzle_tmpdir;

extern TYPELIB tx_isolation_typelib;

namespace

{

  static size_t revno= DRIZZLE7_VC_REVNO;

  static size_t release_id= DRIZZLE7_RELEASE_ID;

}

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

static bool set_option_autocommit(Session*, set_var*);

static int  check_pseudo_thread_id(Session*, set_var*);

static int check_tx_isolation(Session*, set_var*);

static void fix_tx_isolation(Session*, sql_var_t);

static int check_completion_type(Session*, set_var*);

static void fix_max_join_size(Session*, sql_var_t);

static void fix_session_mem_root(Session*, sql_var_t);

void throw_bounds_warning(Session*, bool fixed, bool unsignd, const std::string &name, int64_t);

static unsigned char *get_error_count(Session*);

static unsigned char *get_warning_count(Session*);

static unsigned char *get_tmpdir(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_session_uint64_t

sys_auto_increment_increment("auto_increment_increment", &drizzle_system_variables::auto_increment_increment);

static sys_var_session_uint64_t

sys_auto_increment_offset("auto_increment_offset", &drizzle_system_variables::auto_increment_offset);

static sys_var_fs_path sys_basedir("basedir", basedir);

static sys_var_fs_path sys_pid_file("pid_file", pid_file);

static sys_var_fs_path sys_plugin_dir("plugin_dir", plugin_dir);

static sys_var_size_t_ptr sys_thread_stack_size("thread_stack", &my_thread_stack_size);

static sys_var_constrained_value_readonly<uint32_t> sys_back_log("back_log", back_log);

static sys_var_session_uint64_t	sys_bulk_insert_buff_size("bulk_insert_buffer_size", &drizzle_system_variables::bulk_insert_buff_size);

static sys_var_session_uint32_t	sys_completion_type("completion_type", &drizzle_system_variables::completion_type, check_completion_type);

static sys_var_collation_sv

sys_collation_server("collation_server", &drizzle_system_variables::collation_server, &default_charset_info);

static sys_var_fs_path sys_datadir("datadir", getDataHome());

static sys_var_session_uint64_t	sys_join_buffer_size("join_buffer_size", &drizzle_system_variables::join_buff_size);

static sys_var_session_uint32_t	sys_max_allowed_packet("max_allowed_packet", &drizzle_system_variables::max_allowed_packet);

static sys_var_session_uint64_t	sys_max_error_count("max_error_count", &drizzle_system_variables::max_error_count);

static sys_var_session_uint64_t	sys_max_heap_table_size("max_heap_table_size", &drizzle_system_variables::max_heap_table_size);

static sys_var_session_uint64_t sys_pseudo_thread_id("pseudo_thread_id", &drizzle_system_variables::pseudo_thread_id, 0, check_pseudo_thread_id);

static sys_var_session_ha_rows	sys_max_join_size("max_join_size", &drizzle_system_variables::max_join_size, fix_max_join_size);

static sys_var_session_uint64_t	sys_max_seeks_for_key("max_seeks_for_key", &drizzle_system_variables::max_seeks_for_key);

static sys_var_session_uint64_t sys_max_length_for_sort_data("max_length_for_sort_data", &drizzle_system_variables::max_length_for_sort_data);

static sys_var_session_size_t	sys_max_sort_length("max_sort_length", &drizzle_system_variables::max_sort_length);

static sys_var_uint64_t_ptr	sys_max_write_lock_count("max_write_lock_count", &max_write_lock_count);

static sys_var_session_uint64_t sys_min_examined_row_limit("min_examined_row_limit", &drizzle_system_variables::min_examined_row_limit);

static sys_var_session_bool sys_optimizer_prune_level("optimizer_prune_level", &drizzle_system_variables::optimizer_prune_level);

static sys_var_session_uint32_t sys_optimizer_search_depth("optimizer_search_depth", &drizzle_system_variables::optimizer_search_depth);

static sys_var_session_uint64_t sys_preload_buff_size("preload_buffer_size", &drizzle_system_variables::preload_buff_size);

static sys_var_session_uint32_t sys_read_buff_size("read_buffer_size", &drizzle_system_variables::read_buff_size);

static sys_var_session_uint32_t	sys_read_rnd_buff_size("read_rnd_buffer_size", &drizzle_system_variables::read_rnd_buff_size);

static sys_var_session_uint32_t	sys_div_precincrement("div_precision_increment", &drizzle_system_variables::div_precincrement);

static sys_var_session_size_t	sys_range_alloc_block_size("range_alloc_block_size", &drizzle_system_variables::range_alloc_block_size);

static sys_var_session_bool sys_replicate_query("replicate_query", &drizzle_system_variables::replicate_query);

static sys_var_session_uint32_t	sys_query_alloc_block_size("query_alloc_block_size", &drizzle_system_variables::query_alloc_block_size, NULL, fix_session_mem_root);

static sys_var_session_uint32_t	sys_query_prealloc_size("query_prealloc_size", &drizzle_system_variables::query_prealloc_size, NULL, fix_session_mem_root);

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

static sys_var_fs_path sys_secure_file_priv("secure_file_priv", secure_file_priv);

static sys_var_const_str_ptr sys_scheduler("scheduler", (char**)&opt_scheduler);

static sys_var_uint32_t_ptr  sys_server_id("server_id", &server_id);

static sys_var_const_string sys_server_uuid("server_uuid", server_uuid);

static sys_var_session_size_t	sys_sort_buffer("sort_buffer_size", &drizzle_system_variables::sortbuff_size);

static sys_var_size_t_ptr_readonly sys_transaction_message_threshold("transaction_message_threshold", &transaction_message_threshold);

static sys_var_session_storage_engine sys_storage_engine("storage_engine", &drizzle_system_variables::storage_engine);

static sys_var_size_t_ptr	sys_table_def_size("table_definition_cache", &table_def_size);

static sys_var_uint64_t_ptr	sys_table_cache_size("table_open_cache", &table_cache_size);

static sys_var_uint64_t_ptr	sys_table_lock_wait_timeout("table_lock_wait_timeout", &table_lock_wait_timeout);

static sys_var_session_enum	sys_tx_isolation("tx_isolation",

                                             &drizzle_system_variables::tx_isolation,

                                             &tx_isolation_typelib,

                                             fix_tx_isolation,

                                             check_tx_isolation);

static sys_var_session_uint64_t	sys_tmp_table_size("tmp_table_size",

					   &drizzle_system_variables::tmp_table_size);

static sys_var_bool_ptr  sys_timed_mutexes("timed_mutexes", &internal::timed_mutexes);

static sys_var_const_str  sys_version("version", version().c_str());

static sys_var_const_str sys_version_comment("version_comment", COMPILATION_COMMENT);

static sys_var_const_str sys_version_compile_machine("version_compile_machine", HOST_CPU);

static sys_var_const_str sys_version_compile_os("version_compile_os", HOST_OS);

static sys_var_const_str sys_version_compile_vendor("version_compile_vendor", HOST_VENDOR);

/* Variables that are bits in Session */

sys_var_session_bit sys_autocommit("autocommit", 0, set_option_autocommit, OPTION_NOT_AUTOCOMMIT, 1);

static sys_var_session_bit sys_big_selects("sql_big_selects", 0, set_option_bit, OPTION_BIG_SELECTS);

static sys_var_session_bit sys_sql_warnings("sql_warnings", 0, set_option_bit, OPTION_WARNINGS);

static sys_var_session_bit sys_sql_notes("sql_notes", 0, set_option_bit, OPTION_SQL_NOTES);

static sys_var_session_bit sys_buffer_results("sql_buffer_result", 0, set_option_bit, OPTION_BUFFER_RESULT);

static sys_var_session_bit sys_foreign_key_checks("foreign_key_checks", 0, set_option_bit, OPTION_NO_FOREIGN_KEY_CHECKS, 1);

static sys_var_session_bit sys_unique_checks("unique_checks", 0, set_option_bit, OPTION_RELAXED_UNIQUE_CHECKS, 1);

/* Local state variables */

static sys_var_session_ha_rows	sys_select_limit("sql_select_limit", &drizzle_system_variables::select_limit);

static sys_var_timestamp sys_timestamp("timestamp");

static sys_var_last_insert_id

sys_last_insert_id("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("identity");

static sys_var_session_lc_time_names sys_lc_time_names("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("error_count", OPT_SESSION, SHOW_INT, get_error_count);

static sys_var_readonly sys_warning_count("warning_count", OPT_SESSION, SHOW_INT, get_warning_count);

sys_var_session_uint64_t sys_group_concat_max_len("group_concat_max_len", &drizzle_system_variables::group_concat_max_len);

/* Global read-only variable containing hostname */

static sys_var_const_string sys_hostname("hostname", getServerHostname());

static sys_var_const_str sys_revid("vc_revid", DRIZZLE7_VC_REVID);

static sys_var_const_str sys_branch("vc_branch", DRIZZLE7_VC_BRANCH);

static sys_var_size_t_ptr_readonly sys_revno("vc_revno", &revno);

static sys_var_size_t_ptr_readonly sys_release_id("vc_release_id", &release_id);

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

{

  if (check_func)

  {

    int res= (*check_func)(session, var);

    if (res < 0)

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

    return res;

  }

  var->updateValue();

  return 0;

}

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

{

  if (not check_func)

    return 0;

  int res= (*check_func)(session, var);

  if (res < 0)

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

  return res;

}

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

{

  if (not check_func)

    return false;

  if ((*check_func)(session, var))

  {

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

    return true;

  }

  return false;

}

/*

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

{

  if (type == OPT_SESSION)

    session->session_tx_isolation= (enum_tx_isolation) session->variables.tx_isolation;

}

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(), internal::llstr(val, buf));

    return 1;

  }

  return 0;

}

static void fix_session_mem_root(Session *session, sql_var_t type)

{

  if (type != OPT_GLOBAL)

    session->mem.reset_defaults(session->variables.query_alloc_block_size, session->variables.query_prealloc_size);

}

void throw_bounds_warning(Session *session, bool fixed, bool unsignd, const std::string &name, int64_t val)

{

  if (not fixed)

    return;

  char buf[DECIMAL_LONGLONG_DIGITS];

  if (unsignd)

    internal::ullstr((uint64_t) val, buf);

  else

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

}

uint64_t fix_unsigned(Session *session, uint64_t num, const 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 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;

}

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

{

  var->updateValue();

  return 0;

}

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

{

  uint64_t tmp= var->getInteger();

  boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());

  if (option_limits)

  {

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

    if (static_cast<uint64_t>(newvalue) == tmp)

      *value= newvalue;

  }

  else

  {

    *value= static_cast<uint32_t>(tmp);

  }

  return 0;

}

void sys_var_uint32_t_ptr::set_default(Session *session, sql_var_t)

{

  bool not_used;

  boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());

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

}

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

{

  uint64_t tmp= var->getInteger();

  boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());

  if (option_limits)

  {

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

    if (newvalue==tmp)

      *value= newvalue;

  }

  else

  {

    *value= tmp;

  }

  return 0;

}

void sys_var_uint64_t_ptr::set_default(Session *session, sql_var_t)

{

  if (have_default_value)

  {

    *value= default_value;

  }

  else

  {

    bool not_used;

    boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());

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

  }

}

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

{

  size_t tmp= size_t(var->getInteger());

  boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());

  if (option_limits)

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

  else

    *value= tmp;

  return 0;

}

void sys_var_size_t_ptr::set_default(Session *session, sql_var_t)

{

  bool not_used;

  boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());

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

}

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

{

  return check_enum(session, var, &bool_typelib);

}

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

{

  *value= bool(var->getInteger());

  return 0;

}

void sys_var_bool_ptr::set_default(Session *, sql_var_t)

{

  *value= default_value;

}

/*

  32 bit types for session variables

*/

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

{

  var->updateValue();

  return (check_func && (*check_func)(session, var));

}

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

{

  uint64_t tmp= var->getInteger();

  /* Don't use bigger value than given with --maximum-variable-name=.. */

  if ((uint32_t) tmp > max_system_variables.*offset)

  {

    throw_bounds_warning(session, true, true, getName(), (int64_t) tmp);

    tmp= max_system_variables.*offset;

  }

  if (option_limits)

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

  else if (tmp > UINT32_MAX)

  {

    tmp= UINT32_MAX;

    throw_bounds_warning(session, true, true, getName(), int64_t(var->getInteger()));

  }

  if (var->type == OPT_GLOBAL)

     global_system_variables.*offset= (uint32_t) tmp;

   else

     session->variables.*offset= (uint32_t) tmp;

   return 0;

 }

 void sys_var_session_uint32_t::set_default(Session *session, sql_var_t type)

 {

   if (type == OPT_GLOBAL)

   {

     bool not_used;

     /* We will not come here if option_limits is not set */

     global_system_variables.*offset=

       (uint32_t) getopt_ull_limit_value((uint32_t) option_limits->def_value, *option_limits, &not_used);

   }

   else

     session->variables.*offset= global_system_variables.*offset;

 }

unsigned char *sys_var_session_uint32_t::value_ptr(Session *session, sql_var_t type)

{

  return type == OPT_GLOBAL

    ? (unsigned char*) &(global_system_variables.*offset)

    : (unsigned char*) &(session->variables.*offset);

}

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

{

  uint64_t tmp= var->getInteger();

  /* Don't use bigger value than given with --maximum-variable-name=.. */

  if ((ha_rows) tmp > max_system_variables.*offset)

    tmp= max_system_variables.*offset;

  if (option_limits)

    tmp= (ha_rows) fix_unsigned(session, tmp, *option_limits);

  if (var->type == OPT_GLOBAL)

  {

    /* Lock is needed to make things safe on 32 bit systems */

    boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());

    global_system_variables.*offset= (ha_rows) tmp;

  }

  else

  {

    session->variables.*offset= (ha_rows) tmp;

  }

  return 0;

}

void sys_var_session_ha_rows::set_default(Session *session, sql_var_t type)

{

  if (type == OPT_GLOBAL)

  {

    bool not_used;

    /* We will not come here if option_limits is not set */

    boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());

    global_system_variables.*offset=

      (ha_rows) getopt_ull_limit_value((ha_rows) option_limits->def_value, *option_limits, &not_used);

  }

  else

  {

    session->variables.*offset= global_system_variables.*offset;

  }

}

unsigned char *sys_var_session_ha_rows::value_ptr(Session *session, sql_var_t type)

{

  return type == OPT_GLOBAL

    ? (unsigned char*) &(global_system_variables.*offset)

    : (unsigned char*) &(session->variables.*offset);

}

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

{

  var->updateValue();

  return (check_func && (*check_func)(session, var));

}

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

{

  uint64_t tmp= var->getInteger();

  if (tmp > max_system_variables.*offset)

  {

    throw_bounds_warning(session, true, true, getName(), (int64_t) tmp);

    tmp= max_system_variables.*offset;

  }

  if (option_limits)