~drizzle-trunk/drizzle/development

#include <mysys/thr_alarm.h>

#include <storage/myisam/myisam.h>

#include <drizzled/drizzled_error_messages.h>

 

extern const CHARSET_INFO *character_set_filesystem;

 

static DYNAMIC_ARRAY fixed_show_vars;

static HASH system_variable_hash;

 

TYPELIB bool_typelib=

{

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

};

 

TYPELIB delay_key_write_typelib=

{

  array_elements(delay_key_write_type_names)-1, "",

};

 

const char *slave_exec_mode_names[]=

static const unsigned int slave_exec_mode_names_len[]=

{ sizeof("STRICT") - 1, sizeof("IDEMPOTENT") - 1, 0 };

TYPELIB slave_exec_mode_typelib=

static bool set_option_bit(THD *thd, set_var *var);

static bool set_option_autocommit(THD *thd, set_var *var);

static int  check_log_update(THD *thd, set_var *var);

static int  check_pseudo_thread_id(THD *thd, set_var *var);

static void fix_low_priority_updates(THD *thd, enum_var_type type);

static int check_tx_isolation(THD *thd, set_var *var);

static bool get_unsigned(THD *thd, set_var *var);

bool throw_bounds_warning(THD *thd, bool fixed, bool unsignd,

                          const char *name, int64_t val);

 

/*

  Variable definition list

                                            &SV::binlog_format);

static sys_var_thd_ulong        sys_bulk_insert_buff_size(&vars, "bulk_insert_buffer_size",

                                                  &SV::bulk_insert_buff_size);

static sys_var_thd_ulong        sys_completion_type(&vars, "completion_type",

                                         &SV::completion_type,

                                         check_completion_type,

sys_collation_server(&vars, "collation_server", &SV::collation_server,

                     &default_charset_info,

                     sys_var::SESSION_VARIABLE_IN_BINLOG);

static sys_var_long_ptr sys_connect_timeout(&vars, "connect_timeout",

                                            &connect_timeout);

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

                                                              param_age_threshold));

static sys_var_bool_ptr sys_local_infile(&vars, "local_infile",

                                         &opt_local_infile);

static sys_var_thd_bool sys_low_priority_updates(&vars, "low_priority_updates",

                                                 &SV::low_priority_updates,

                                                 fix_low_priority_updates);

                                                 &max_write_lock_count);

static sys_var_thd_ulong       sys_min_examined_row_limit(&vars, "min_examined_row_limit",

                                                          &SV::min_examined_row_limit);

static sys_var_thd_uint64_t     sys_myisam_max_sort_file_size(&vars, "myisam_max_sort_file_size", &SV::myisam_max_sort_file_size, fix_myisam_max_sort_file_size, 1);

static sys_var_thd_ulong       sys_myisam_repair_threads(&vars, "myisam_repair_threads", &SV::myisam_repair_threads);

static sys_var_thd_ulong        sys_myisam_sort_buffer_size(&vars, "myisam_sort_buffer_size", &SV::myisam_sort_buff_size);

static sys_var_thd_ulong        sys_optimizer_search_depth(&vars, "optimizer_search_depth",

                                                   &SV::optimizer_search_depth);

 

TYPELIB optimizer_use_mrr_typelib= {

  array_elements(optimizer_use_mrr_names) - 1, "",

  optimizer_use_mrr_names, NULL

                                               &SV::read_rnd_buff_size);

static sys_var_thd_ulong        sys_div_precincrement(&vars, "div_precision_increment",

                                              &SV::div_precincrement);

 

static sys_var_thd_ulong        sys_range_alloc_block_size(&vars, "range_alloc_block_size",

                                                   &SV::range_alloc_block_size);

                                                &SV::trans_prealloc_size,

                                                0, fix_trans_mem_root);

 

static sys_var_const_str_ptr sys_secure_file_priv(&vars, "secure_file_priv",

                                             &opt_secure_file_priv);

static sys_var_long_ptr sys_server_id(&vars, "server_id", &server_id, fix_server_id);

static sys_var_bool_ptr sys_slave_compressed_protocol(&vars, "slave_compressed_protocol",

                                                      &opt_slave_compressed_protocol);

static sys_var_bool_ptr         sys_slave_allow_batching(&vars, "slave_allow_batching",

                                                         &slave_allow_batching);

static sys_var_set_slave_mode slave_exec_mode(&vars,

                                              &slave_exec_mode_options,

                                              &slave_exec_mode_typelib,

                                              0);

static sys_var_long_ptr sys_slow_launch_time(&vars, "slow_launch_time",

                                             &slow_launch_time);

static sys_var_thd_ulong        sys_sort_buffer(&vars, "sort_buffer_size",

*/

static sys_var_thd_optimizer_switch   sys_optimizer_switch(&vars, "optimizer_switch",

                                     &SV::optimizer_switch);

 

static sys_var_thd_storage_engine sys_storage_engine(&vars, "storage_engine",

                                       &SV::table_plugin);

static sys_var_const_str        sys_system_time_zone(&vars, "system_time_zone",

                                             system_time_zone);

static sys_var_long_ptr sys_table_def_size(&vars, "table_definition_cache",

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

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

static sys_var_const_str        sys_version_comment(&vars, "version_comment",

static sys_var_const_str        sys_version_compile_machine(&vars, "version_compile_machine",

                                                    MACHINE_TYPE);

static sys_var_const_str        sys_version_compile_os(&vars, "version_compile_os",

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

                                        set_option_bit,

                                        OPTION_BIG_SELECTS);

static sys_var_thd_bit  sys_log_binlog(&vars, "sql_log_bin",

                                       check_log_update,

                                       set_option_bit,

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

                                         set_option_bit,

                                         OPTION_SQL_NOTES);

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

                                         set_option_bit,

                                         OPTION_SAFE_UPDATES);

static sys_var_const_str_ptr    sys_repl_report_user(&vars, "report_user", &report_user);

static sys_var_const_str_ptr    sys_repl_report_password(&vars, "report_password", &report_password);

 

{

  thd->sys_var_tmp.long_value= report_port;

}

 

static sys_var_readonly    sys_repl_report_port(&vars, "report_port", OPT_GLOBAL, SHOW_INT, slave_get_report_port);

 

static sys_var_have_variable sys_have_compress(&vars, "have_compress", &have_compress);

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

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

static SHOW_VAR fixed_vars[]= {

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

  {"init_file",               (char*) &opt_init_file,               SHOW_CHAR_PTR},

  {"language",                language,                             SHOW_CHAR},

#ifdef HAVE_MLOCKALL

                        set_var *var)

{

  char *res= 0, *old_value=(char *)(var ? var->value->str_value.ptr() : 0);

  if (!old_value)

    old_value= (char*) "";

  if (!(res= my_strndup(old_value, new_length, MYF(0))))

  var_str->value= res;

  var_str->value_length= new_length;

  rw_unlock(var_mutex);

  return 0;

}

 

  If we are changing the thread variable, we have to copy it to NET too

*/

 

static void fix_net_read_timeout(THD *thd, enum_var_type type)

{

  if (type != OPT_GLOBAL)

  if (type != OPT_GLOBAL)

    thd->net.retry_count=thd->variables.net_retry_count;

}

 

 

extern void fix_delay_key_write(THD *thd __attribute__((unused)),

  return 0;

}

 

                              enum_var_type type __attribute__((unused)),

                              LEX_STRING *base __attribute__((unused)))

{

  char buff[256];

  ulong length;

  ulong val= *value;

 

  tmp.length(0);

  {

    if (val & 1)

    {

 

  if ((length= tmp.length()))

    length--;

}

 

void sys_var_set_slave_mode::set_default(THD *thd __attribute__((unused)),

  if (bit_is_set(slave_exec_mode_options, SLAVE_EXEC_MODE_STRICT) == 1 &&

      bit_is_set(slave_exec_mode_options, SLAVE_EXEC_MODE_IDEMPOTENT) == 1)

  {

    bit_do_clear(slave_exec_mode_options, SLAVE_EXEC_MODE_IDEMPOTENT);

  }

  if (bit_is_set(slave_exec_mode_options, SLAVE_EXEC_MODE_IDEMPOTENT) == 0)

    my_error(ER_TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR, MYF(0));

    return 1;

  }

  return sys_var_thd_enum::is_readonly();

}

 

                                enum_var_type type __attribute__((unused)))

{

  mysql_bin_log.set_max_size(max_binlog_size);

  if (!max_relay_log_size)

    active_mi->rli.relay_log.set_max_size(max_binlog_size);

  return;

}

 

static void fix_max_relay_log_size(THD *thd __attribute__((unused)),

                                   enum_var_type type __attribute__((unused)))

{

  active_mi->rli.relay_log.set_max_size(max_relay_log_size ?

                                        max_relay_log_size: max_binlog_size);

  return;

}

 

    *value= (ulong) fix_unsigned(thd, tmp, option_limits);

  else

  {

    {

      throw_bounds_warning(thd, true, true, name,

                           (int64_t) var->save_result.uint64_t_value);

    }

    *value= (ulong) tmp;

  }

 

}

 

 

                               enum_var_type type __attribute__((unused)),

                               LEX_STRING *base __attribute__((unused)))

{

}

 

 

                                     enum_var_type type __attribute__((unused)),

                                     LEX_STRING *base __attribute__((unused)))

{

}

 

bool sys_var_thd_ulong::check(THD *thd, set_var *var)

  

  if (option_limits)

    tmp= (ulong) fix_unsigned(thd, tmp, option_limits);

  {

    throw_bounds_warning(thd, true, true, name, (int64_t) var->save_result.uint64_t_value);

  }

  

  if (var->type == OPT_GLOBAL)

     global_system_variables.*offset= (ulong) tmp;

 }

 

 

                                    LEX_STRING *base __attribute__((unused)))

{

  if (type == OPT_GLOBAL)

}

 

 

}

 

 

                                      LEX_STRING *base __attribute__((unused)))

{

  if (type == OPT_GLOBAL)

}

 

bool sys_var_thd_uint64_t::check(THD *thd, set_var *var)

}

 

 

                                        LEX_STRING *base __attribute__((unused)))

{

  if (type == OPT_GLOBAL)

}

 

 

}

 

 

                                   LEX_STRING *base __attribute__((unused)))

{

  if (type == OPT_GLOBAL)

}

 

 

{

  bool not_used;

  char buff[STRING_BUFFER_USUAL_SIZE], *error= 0;

  String str(buff, sizeof(buff), system_charset_info), *res;

 

  if (var->value->result_type() == STRING_RESULT)

  {

    if (!(res= var->value->val_str(&str)))

    {

      goto err;

    }

 

                                            &not_used));

    if (error_len)

    {

      goto err;

    }

  }

      For when the enum is made to contain 64 elements, as 1ULL<<64 is

      undefined, we guard with a "count<64" test.

    */

                 (enum_names->count < 64)))

    {

      llstr(tmp, buff);

  switch (show_type()) {

  case SHOW_INT:

  {

    pthread_mutex_lock(&LOCK_global_system_variables);

    value= *(uint*) value_ptr(thd, var_type, base);

    pthread_mutex_unlock(&LOCK_global_system_variables);

    char *str= *(char**) value_ptr(thd, var_type, base);

    if (str)

    {

      tmp= new Item_string(thd->strmake(str, length), length,

                           system_charset_info, DERIVATION_SYSCONST);

    }

}

 

 

                                   LEX_STRING *base __attribute__((unused)))

{

  ulong tmp= ((type == OPT_GLOBAL) ?

              global_system_variables.*offset :

              thd->variables.*offset);

}

 

bool sys_var_thd_bit::check(THD *thd, set_var *var)

}

 

 

                                  enum_var_type type __attribute__((unused)),

                                  LEX_STRING *base __attribute__((unused)))

{

  */

  thd->sys_var_tmp.bool_value= ((thd->options & bit_flag) ?

                                   !reverse : reverse);

}

 

 

    old= (thd->variables.*offset);

    (thd->variables.*offset)= new_value;

  }

  return;

}

 

    update is aborted

  */

  var->save_result.date_time_format= date_time_format_copy(thd, format);

  return var->save_result.date_time_format == 0;

}

 

}

 

 

                                               LEX_STRING *base __attribute__((unused)))

{

  if (type == OPT_GLOBAL)

    */

    res= thd->strmake((global_system_variables.*offset)->format.str,

                      (global_system_variables.*offset)->format.length);

  }

}

 

 

  const char *new_name;

} my_old_conv;

 

bool sys_var_collation::check(THD *thd __attribute__((unused)),

                              set_var *var)

{

      }

      tmp= NULL;

    }

    {

      my_error(ER_UNKNOWN_CHARACTER_SET, MYF(0), res->c_ptr());

      return 1;

}

 

 

                                        LEX_STRING *base __attribute__((unused)))

{

  const CHARSET_INFO * const cs= ci_ptr(thd,type)[0];

}