~drizzle-trunk/drizzle/development

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

    example).

*/

#include "rpl_mi.h"

 

 

 

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

                                              &SV::max_seeks_for_key);

static sys_var_thd_ulong   sys_max_length_for_sort_data(&vars, "max_length_for_sort_data",

                                                 &SV::max_length_for_sort_data);

static sys_var_long_ptr sys_max_relay_log_size(&vars, "max_relay_log_size",

                                               &max_relay_log_size,

                                               fix_max_relay_log_size);

                                                 &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_date_time_format sys_time_format(&vars, "time_format",

                                             &SV::time_format,

static sys_var_thd_date_time_format sys_date_format(&vars, "date_format",

                                             &SV::date_format,

static sys_var_thd_date_time_format sys_datetime_format(&vars, "datetime_format",

                                                 &SV::datetime_format,

 

/* Variables that are bits in THD */

 

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

/* Read only variables */

 

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

#endif

  {"log_bin",                 (char*) &opt_bin_log,                 SHOW_BOOL},

  {"log_error",               (char*) log_error_file,               SHOW_CHAR},

  {"myisam_recover_options",  (char*) &myisam_recover_options_str,  SHOW_CHAR_PTR},

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

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

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

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

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

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

};

 

 

{

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

  return 0;

                        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;

}

 

 

{

  return update_sys_var_str(&sys_init_connect, &LOCK_sys_init_connect, var);

}

 

 

{

  update_sys_var_str(&sys_init_connect, &LOCK_sys_init_connect, 0);

}

 

 

                                  set_var *var)

{

  return update_sys_var_str(&sys_init_slave, &LOCK_sys_init_slave, var);

}

 

 

{

  update_sys_var_str(&sys_init_slave, &LOCK_sys_init_slave, 0);

}

 

 

static void

{

  myisam_max_temp_length=

    (my_off_t) global_system_variables.myisam_max_sort_file_size;

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

                                enum_var_type type __attribute__((unused))) {}

 

                                 set_var *var)

{

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

  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;

}

{

  switch ((enum_delay_key_write) delay_key_write_options) {

  case DELAY_KEY_WRITE_NONE:

  }

}

 

                         set_var *var)

{

  *value= var->save_result.ulong_value;

  return 0;

}

 

{

  char buff[256];

  ulong length;

  ulong val= *value;

 

  tmp.length(0);

  {

    if (val & 1)

    {

 

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

    length--;

}

 

{

  slave_exec_mode_options= 0;

  bit_do_set(slave_exec_mode_options, SLAVE_EXEC_MODE_STRICT);

  return rc;

}

 

{

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

}

 

 

void fix_binlog_format_after_update(THD *thd,

{

  thd->reset_current_stmt_binlog_row_based();

}

 

 

{

  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;

}

 

{

  active_mi->rli.relay_log.set_max_size(max_relay_log_size ?

                                        max_relay_log_size: max_binlog_size);

  return;

}

 

{

  resize_thr_alarm(max_connections +  10);

}

}

 

 

{

  server_id_supplied = 1;

  thd->server_id= server_id;

    else

      llstr(val, buf);

 

                        ER_TRUNCATED_WRONG_VALUE,

                        ER(ER_TRUNCATED_WRONG_VALUE), name, buf);

  }

  return out;

}

 

{

  if (var->value->unsigned_flag)

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

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

  }