~drizzle-trunk/drizzle/development

/* Copyright (C) 2000-2003 MySQL AB

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/**

  @file

  @brief

  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)

  @todo

    When updating myisam_delay_key_write, we should do a 'flush tables'

    of all MyISAM tables to ensure that they are reopen with the

    new attribute.

  @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 "rpl_mi.h"

#include <mysys/my_getopt.h>

#include <mysys/thr_alarm.h>

#include <storage/myisam/myisam.h>

#include <drizzled/drizzled_error_messages.h>

#include <libdrizzle/gettext.h>

extern const CHARSET_INFO *character_set_filesystem;

static DYNAMIC_ARRAY fixed_show_vars;

static HASH system_variable_hash;

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

TYPELIB bool_typelib=

{

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

};

const char *delay_key_write_type_names[]= { "OFF", "ON", "ALL", NullS };

TYPELIB delay_key_write_typelib=

{

  array_elements(delay_key_write_type_names)-1, "",

  delay_key_write_type_names, NULL

};

const char *slave_exec_mode_names[]=

{ "STRICT", "IDEMPOTENT", NullS };

static const unsigned int slave_exec_mode_names_len[]=

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

TYPELIB slave_exec_mode_typelib=

{

  array_elements(slave_exec_mode_names)-1, "",

  slave_exec_mode_names, (unsigned int *) slave_exec_mode_names_len

};

static bool sys_update_init_connect(THD*, set_var*);

static void sys_default_init_connect(THD*, enum_var_type type);

static bool sys_update_init_slave(THD*, set_var*);

static void sys_default_init_slave(THD*, enum_var_type type);

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 bool set_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 void fix_tx_isolation(THD *thd, enum_var_type type);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static KEY_CACHE *create_key_cache(const char *name, uint length);

static uchar *get_error_count(THD *thd);

static uchar *get_warning_count(THD *thd);

static uchar *get_tmpdir(THD *thd);

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

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

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

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

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

/*

  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_thd_ulong

sys_auto_increment_increment(&vars, "auto_increment_increment",

                             &SV::auto_increment_increment, NULL, NULL,

                             sys_var::SESSION_VARIABLE_IN_BINLOG);

static sys_var_thd_ulong

sys_auto_increment_offset(&vars, "auto_increment_offset",

                          &SV::auto_increment_offset, NULL, NULL,

                          sys_var::SESSION_VARIABLE_IN_BINLOG);

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

static sys_var_long_ptr	sys_binlog_cache_size(&vars, "binlog_cache_size",

					      &binlog_cache_size);

static sys_var_thd_binlog_format sys_binlog_format(&vars, "binlog_format",

                                            &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_character_set_sv

sys_character_set_server(&vars, "character_set_server",

                         &SV::collation_server, &default_charset_info, 0,

                         sys_var::SESSION_VARIABLE_IN_BINLOG);

sys_var_const_str       sys_charset_system(&vars, "character_set_system",

                                           (char *)my_charset_utf8_general_ci.name);

static sys_var_character_set_database

sys_character_set_database(&vars, "character_set_database",

                           sys_var::SESSION_VARIABLE_IN_BINLOG);

static sys_var_character_set_client

sys_character_set_client(&vars, "character_set_client",

                         &SV::character_set_client,

                         &default_charset_info,

                         sys_var::SESSION_VARIABLE_IN_BINLOG);

static sys_var_character_set_sv

sys_character_set_connection(&vars, "character_set_connection",

                             &SV::collation_connection,

                             &default_charset_info, 0,

                             sys_var::SESSION_VARIABLE_IN_BINLOG);

static sys_var_character_set_sv sys_character_set_results(&vars, "character_set_results",

                                        &SV::character_set_results,

                                        &default_charset_info, true);

static sys_var_character_set_sv sys_character_set_filesystem(&vars, "character_set_filesystem",

                                        &SV::character_set_filesystem,

                                        &character_set_filesystem);

static sys_var_thd_ulong	sys_completion_type(&vars, "completion_type",

					 &SV::completion_type,

					 check_completion_type,

					 fix_completion_type);

static sys_var_collation_sv

sys_collation_connection(&vars, "collation_connection",

                         &SV::collation_connection, &default_charset_info,

                         sys_var::SESSION_VARIABLE_IN_BINLOG);

static sys_var_collation_sv

sys_collation_database(&vars, "collation_database", &SV::collation_database,

                       &default_charset_info,

                       sys_var::SESSION_VARIABLE_IN_BINLOG);

static sys_var_collation_sv

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

static sys_var_enum		sys_delay_key_write(&vars, "delay_key_write",

					    &delay_key_write_options,

					    &delay_key_write_typelib,

					    fix_delay_key_write);

static sys_var_long_ptr	sys_expire_logs_days(&vars, "expire_logs_days",

					     &expire_logs_days);

static sys_var_bool_ptr	sys_flush(&vars, "flush", &myisam_flush);

sys_var_str             sys_init_connect(&vars, "init_connect", 0,

                                         sys_update_init_connect,

                                         sys_default_init_connect,0);

sys_var_str             sys_init_slave(&vars, "init_slave", 0,

                                       sys_update_init_slave,

                                       sys_default_init_slave,0);

static sys_var_thd_ulong	sys_interactive_timeout(&vars, "interactive_timeout",

						&SV::net_interactive_timeout);

static sys_var_thd_ulong	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_long  sys_key_cache_block_size(&vars, "key_cache_block_size",

						 offsetof(KEY_CACHE,

							  param_block_size));

static sys_var_key_cache_long	sys_key_cache_division_limit(&vars, "key_cache_division_limit",

						     offsetof(KEY_CACHE,

							      param_division_limit));

static sys_var_key_cache_long  sys_key_cache_age_threshold(&vars, "key_cache_age_threshold",

						     offsetof(KEY_CACHE,

							      param_age_threshold));

static sys_var_bool_ptr	sys_local_infile(&vars, "local_infile",

					 &opt_local_infile);

static sys_var_bool_ptr

  sys_log_queries_not_using_indexes(&vars, "log_queries_not_using_indexes",

                                    &opt_log_queries_not_using_indexes);

static sys_var_thd_ulong	sys_log_warnings(&vars, "log_warnings", &SV::log_warnings);

static sys_var_microseconds	sys_var_long_query_time(&vars, "long_query_time",

                                                        &SV::long_query_time);

static sys_var_thd_bool	sys_low_priority_updates(&vars, "low_priority_updates",

						 &SV::low_priority_updates,

						 fix_low_priority_updates);

#ifndef TO_BE_DELETED	/* Alias for the low_priority_updates */

static sys_var_thd_bool	sys_sql_low_priority_updates(&vars, "sql_low_priority_updates",

						     &SV::low_priority_updates,

						     fix_low_priority_updates);

#endif

static sys_var_thd_ulong	sys_max_allowed_packet(&vars, "max_allowed_packet",

					       &SV::max_allowed_packet);

static sys_var_long_ptr	sys_max_binlog_cache_size(&vars, "max_binlog_cache_size",

						  &max_binlog_cache_size);

static sys_var_long_ptr	sys_max_binlog_size(&vars, "max_binlog_size",

					    &max_binlog_size,

                                            fix_max_binlog_size);

static sys_var_long_ptr	sys_max_connections(&vars, "max_connections",

					    &max_connections,

                                            fix_max_connections);

static sys_var_long_ptr	sys_max_connect_errors(&vars, "max_connect_errors",

					       &max_connect_errors);

static sys_var_thd_ulong	sys_max_error_count(&vars, "max_error_count",

					    &SV::max_error_count);

static sys_var_thd_uint64_t	sys_max_heap_table_size(&vars, "max_heap_table_size",

						&SV::max_heap_table_size);

static sys_var_thd_ulong sys_pseudo_thread_id(&vars, "pseudo_thread_id",

                                              &SV::pseudo_thread_id,

                                              check_pseudo_thread_id, 0,

                                              sys_var::SESSION_VARIABLE_IN_BINLOG);

static sys_var_thd_ha_rows	sys_max_join_size(&vars, "max_join_size",

					  &SV::max_join_size,

					  fix_max_join_size);

static sys_var_thd_ulong	sys_max_seeks_for_key(&vars, "max_seeks_for_key",

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

static sys_var_thd_ulong	sys_max_sort_length(&vars, "max_sort_length",

					    &SV::max_sort_length);

static sys_var_max_user_conn   sys_max_user_connections(&vars, "max_user_connections");

static sys_var_thd_ulong	sys_max_tmp_tables(&vars, "max_tmp_tables",

					   &SV::max_tmp_tables);

static sys_var_long_ptr	sys_max_write_lock_count(&vars, "max_write_lock_count",

						 &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_enum         sys_myisam_stats_method(&vars, "myisam_stats_method",

                                                &SV::myisam_stats_method,

                                                &myisam_stats_method_typelib,

                                                NULL);

static sys_var_thd_ulong	sys_net_buffer_length(&vars, "net_buffer_length",

					      &SV::net_buffer_length);

static sys_var_thd_ulong	sys_net_read_timeout(&vars, "net_read_timeout",

					     &SV::net_read_timeout,

					     0, fix_net_read_timeout);

static sys_var_thd_ulong	sys_net_write_timeout(&vars, "net_write_timeout",

					      &SV::net_write_timeout,

					      0, fix_net_write_timeout);

static sys_var_thd_ulong	sys_net_retry_count(&vars, "net_retry_count",

					    &SV::net_retry_count,

					    0, fix_net_retry_count);

static sys_var_thd_bool	sys_new_mode(&vars, "new", &SV::new_mode);

static sys_var_bool_ptr_readonly sys_old_mode(&vars, "old",

                                       &global_system_variables.old_mode);

/* these two cannot be static */

sys_var_thd_bool                sys_old_alter_table(&vars, "old_alter_table",

                                            &SV::old_alter_table);

static sys_var_thd_ulong        sys_optimizer_prune_level(&vars, "optimizer_prune_level",

                                                  &SV::optimizer_prune_level);

static sys_var_thd_ulong        sys_optimizer_search_depth(&vars, "optimizer_search_depth",

                                                   &SV::optimizer_search_depth);

const char *optimizer_use_mrr_names[] = {"auto", "force", "disable", NullS};

TYPELIB optimizer_use_mrr_typelib= {

  array_elements(optimizer_use_mrr_names) - 1, "",

  optimizer_use_mrr_names, NULL

};

static sys_var_thd_enum        sys_optimizer_use_mrr(&vars, "optimizer_use_mrr",

                                              &SV::optimizer_use_mrr,

                                              &optimizer_use_mrr_typelib,

                                              NULL);

static sys_var_thd_ulong        sys_preload_buff_size(&vars, "preload_buffer_size",

                                              &SV::preload_buff_size);

static sys_var_thd_ulong	sys_read_buff_size(&vars, "read_buffer_size",

					   &SV::read_buff_size);

static sys_var_opt_readonly	sys_readonly(&vars, "read_only", &opt_readonly);

static sys_var_thd_ulong	sys_read_rnd_buff_size(&vars, "read_rnd_buffer_size",

					       &SV::read_rnd_buff_size);

static sys_var_thd_ulong	sys_div_precincrement(&vars, "div_precision_increment",

                                              &SV::div_precincrement);

static sys_var_long_ptr	sys_rpl_recovery_rank(&vars, "rpl_recovery_rank",

					      &rpl_recovery_rank);

static sys_var_thd_ulong	sys_range_alloc_block_size(&vars, "range_alloc_block_size",

						   &SV::range_alloc_block_size);

static sys_var_thd_ulong	sys_query_alloc_block_size(&vars, "query_alloc_block_size",

						   &SV::query_alloc_block_size,

						   0, fix_thd_mem_root);

static sys_var_thd_ulong	sys_query_prealloc_size(&vars, "query_prealloc_size",

						&SV::query_prealloc_size,

						0, fix_thd_mem_root);

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

static sys_var_thd_ulong	sys_trans_alloc_block_size(&vars, "transaction_alloc_block_size",

						   &SV::trans_alloc_block_size,

						   0, fix_trans_mem_root);

static sys_var_thd_ulong	sys_trans_prealloc_size(&vars, "transaction_prealloc_size",

						&SV::trans_prealloc_size,

						0, fix_trans_mem_root);

static sys_var_bool_ptr	sys_secure_auth(&vars, "secure_auth", &opt_secure_auth);

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

#ifdef HAVE_REPLICATION

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

                                              &slave_exec_mode_options,

                                              &slave_exec_mode_typelib,

                                              0);

#endif

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

					&SV::sortbuff_size);

/*

  sql_mode should *not* have binlog_mode=SESSION_VARIABLE_IN_BINLOG:

  even though it is written to the binlog, the slave ignores the

  MODE_NO_DIR_IN_CREATE variable, so slave's value differs from

  master's (see log_event.cc: Query_log_event::do_apply_event()).

*/

static sys_var_thd_optimizer_switch   sys_optimizer_switch(&vars, "optimizer_switch",

                                     &SV::optimizer_switch);

static sys_var_const_str	sys_ssl_ca(&vars, "ssl_ca", NULL);

static sys_var_const_str	sys_ssl_capath(&vars, "ssl_capath", NULL);

static sys_var_const_str	sys_ssl_cert(&vars, "ssl_cert", NULL);

static sys_var_const_str	sys_ssl_cipher(&vars, "ssl_cipher", NULL);

static sys_var_const_str	sys_ssl_key(&vars, "ssl_key", NULL);

static sys_var_thd_storage_engine sys_storage_engine(&vars, "storage_engine",

				       &SV::table_plugin);

static sys_var_bool_ptr	sys_sync_frm(&vars, "sync_frm", &opt_sync_frm);

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

                                           &table_def_size);

static sys_var_long_ptr	sys_table_cache_size(&vars, "table_open_cache",

					     &table_cache_size);

static sys_var_long_ptr	sys_table_lock_wait_timeout(&vars, "table_lock_wait_timeout",

                                                    &table_lock_wait_timeout);

static sys_var_long_ptr	sys_thread_cache_size(&vars, "thread_cache_size",

					      &thread_cache_size);

sys_var_long_ptr	sys_thread_pool_size(&vars, "thread_pool_size",

					      &thread_pool_size);

static sys_var_thd_enum	sys_tx_isolation(&vars, "tx_isolation",

					 &SV::tx_isolation,

					 &tx_isolation_typelib,

					 fix_tx_isolation,

					 check_tx_isolation);

static sys_var_thd_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", server_version);

static sys_var_const_str	sys_version_comment(&vars, "version_comment",

                                            DRIZZLE_COMPILATION_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",

                                               SYSTEM_TYPE);

static sys_var_thd_ulong	sys_net_wait_timeout(&vars, "wait_timeout",

					     &SV::net_wait_timeout);

/* Condition pushdown to storage engine */

static sys_var_thd_bool

sys_engine_condition_pushdown(&vars, "engine_condition_pushdown",

			      &SV::engine_condition_pushdown);

/* Time/date/datetime formats */

static sys_var_thd_date_time_format sys_time_format(&vars, "time_format",

					     &SV::time_format,

					     DRIZZLE_TIMESTAMP_TIME);

static sys_var_thd_date_time_format sys_date_format(&vars, "date_format",

					     &SV::date_format,

					     DRIZZLE_TIMESTAMP_DATE);

static sys_var_thd_date_time_format sys_datetime_format(&vars, "datetime_format",

						 &SV::datetime_format,

						 DRIZZLE_TIMESTAMP_DATETIME);

/* Variables that are bits in THD */

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

                               set_option_autocommit,

                               OPTION_NOT_AUTOCOMMIT,

                               1);

static sys_var_thd_bit	sys_big_tables(&vars, "big_tables", 0,

				       set_option_bit,

				       OPTION_BIG_TABLES);

#ifndef TO_BE_DELETED	/* Alias for big_tables */

static sys_var_thd_bit	sys_sql_big_tables(&vars, "sql_big_tables", 0,

					   set_option_bit,

					   OPTION_BIG_TABLES);

#endif

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_off(&vars, "sql_log_off",

				    check_log_update,

				    set_option_bit,

				    OPTION_LOG_OFF);

static sys_var_thd_bit	sys_log_update(&vars, "sql_log_update",

                                       check_log_update,

				       set_log_update,

				       OPTION_BIN_LOG);

static sys_var_thd_bit	sys_log_binlog(&vars, "sql_log_bin",

                                       check_log_update,

				       set_option_bit,

				       OPTION_BIN_LOG);

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

					 set_option_bit,

					 OPTION_WARNINGS);

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

					 set_option_bit,

					 OPTION_SQL_NOTES);

static sys_var_thd_bit	sys_auto_is_null(&vars, "sql_auto_is_null", 0,

					 set_option_bit,

                                         OPTION_AUTO_IS_NULL, 0,

                                         sys_var::SESSION_VARIABLE_IN_BINLOG);

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

					 set_option_bit,

					 OPTION_SAFE_UPDATES);

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

					   set_option_bit,

					   OPTION_BUFFER_RESULT);

static sys_var_thd_bit	sys_quote_show_create(&vars, "sql_quote_show_create", 0,

					      set_option_bit,

					      OPTION_QUOTE_SHOW_CREATE);

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

					       set_option_bit,

					       OPTION_NO_FOREIGN_KEY_CHECKS,

                                               1, sys_var::SESSION_VARIABLE_IN_BINLOG);

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

					  set_option_bit,

					  OPTION_RELAXED_UNIQUE_CHECKS,

                                          1,

                                          sys_var::SESSION_VARIABLE_IN_BINLOG);

/* Local state variables */

static sys_var_thd_ha_rows	sys_select_limit(&vars, "sql_select_limit",

						 &SV::select_limit);

static sys_var_timestamp sys_timestamp(&vars, "timestamp",

                                       sys_var::SESSION_VARIABLE_IN_BINLOG);

static sys_var_last_insert_id

sys_last_insert_id(&vars, "last_insert_id",

                   sys_var::SESSION_VARIABLE_IN_BINLOG);

/*

  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", sys_var::SESSION_VARIABLE_IN_BINLOG);

static sys_var_thd_lc_time_names

sys_lc_time_names(&vars, "lc_time_names", sys_var::SESSION_VARIABLE_IN_BINLOG);

/*

  insert_id should *not* be marked as written to the binlog (i.e., it

  should *not* have binlog_status==SESSION_VARIABLE_IN_BINLOG),

  because we want any statement that refers to insert_id explicitly to

  be unsafe.  (By "explicitly", we mean using @@session.insert_id,

  whereas insert_id is used "implicitly" when NULL value is inserted

  into an auto_increment column).

  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_insert_id sys_insert_id(&vars, "insert_id");

static sys_var_readonly		sys_error_count(&vars, "error_count",

						OPT_SESSION,

						SHOW_LONG,

						get_error_count);

static sys_var_readonly		sys_warning_count(&vars, "warning_count",

						  OPT_SESSION,

						  SHOW_LONG,

						  get_warning_count);

static sys_var_rand_seed1 sys_rand_seed1(&vars, "rand_seed1",

                                         sys_var::SESSION_VARIABLE_IN_BINLOG);

static sys_var_rand_seed2 sys_rand_seed2(&vars, "rand_seed2",

                                         sys_var::SESSION_VARIABLE_IN_BINLOG);

static sys_var_thd_ulong        sys_default_week_format(&vars, "default_week_format",

					                &SV::default_week_format);

sys_var_thd_ulong               sys_group_concat_max_len(&vars, "group_concat_max_len",

                                                         &SV::group_concat_max_len);

sys_var_thd_time_zone sys_time_zone(&vars, "time_zone",

                                    sys_var::SESSION_VARIABLE_IN_BINLOG);

/* Global read-only variable containing hostname */

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

static sys_var_const_str_ptr    sys_repl_report_host(&vars, "report_host", &report_host);

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

static uchar *slave_get_report_port(THD *thd)

{

  thd->sys_var_tmp.long_value= report_port;

  return (uchar*) &thd->sys_var_tmp.long_value;

}

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

sys_var_thd_bool  sys_keep_files_on_create(&vars, "keep_files_on_create", 

                                           &SV::keep_files_on_create);

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

/* Global variables which enable|disable logging */

static sys_var_log_state sys_var_general_log(&vars, "general_log", &opt_log,

                                      QUERY_LOG_GENERAL);

/* Synonym of "general_log" for consistency with SHOW VARIABLES output */

static sys_var_log_state sys_var_log(&vars, "log", &opt_log, QUERY_LOG_GENERAL);

static sys_var_log_state sys_var_slow_query_log(&vars, "slow_query_log", &opt_slow_log,

                                         QUERY_LOG_SLOW);

/* Synonym of "slow_query_log" for consistency with SHOW VARIABLES output */

static sys_var_log_state sys_var_log_slow(&vars, "log_slow_queries",

                                          &opt_slow_log, QUERY_LOG_SLOW);

sys_var_str sys_var_general_log_path(&vars, "general_log_file", sys_check_log_path,

				     sys_update_general_log_path,

				     sys_default_general_log_path,

				     opt_logname);

sys_var_str sys_var_slow_log_path(&vars, "slow_query_log_file", sys_check_log_path,

				  sys_update_slow_log_path, 

				  sys_default_slow_log_path,

				  opt_slow_logname);

static sys_var_log_output sys_var_log_output_state(&vars, "log_output", &log_output_options,

					    &log_output_typelib, 0);

/*

  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_LONG},

  {"character_sets_dir",      mysql_charsets_dir,                   SHOW_CHAR},

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

  {"language",                language,                             SHOW_CHAR},

#ifdef HAVE_MLOCKALL

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

#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},

};

bool sys_var::check(THD *thd __attribute__((unused)), set_var *var)

{

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

  return 0;

}

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

{

  int res;

  if (!check_func)

    return 0;

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

    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0),

             name, var->value->str_value.ptr());

  return res;

}

/*

  Functions to check and update variables

*/

/*

  Update variables 'init_connect, init_slave'.

  In case of 'DEFAULT' value

  (for example: 'set GLOBAL init_connect=DEFAULT')

  'var' parameter is NULL pointer.

*/

bool update_sys_var_str(sys_var_str *var_str, rw_lock_t *var_mutex,

			set_var *var)

{

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

  uint new_length= (var ? var->value->str_value.length() : 0);

  if (!old_value)

    old_value= (char*) "";

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

    return 1;

  /*

    Replace the old value in such a way that the any thread using

    the value will work.

  */

  rw_wrlock(var_mutex);

  old_value= var_str->value;

  var_str->value= res;

  var_str->value_length= new_length;

  rw_unlock(var_mutex);

  my_free(old_value, MYF(MY_ALLOW_ZERO_PTR));

  return 0;

}

static bool sys_update_init_connect(THD *thd __attribute__((unused)), set_var *var)

{

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

}

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

                                     enum_var_type type __attribute__((unused)))

{

  update_sys_var_str(&sys_init_connect, &LOCK_sys_init_connect, 0);

}

static bool sys_update_init_slave(THD *thd __attribute__((unused)),

                                  set_var *var)

{

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

}

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

                                   enum_var_type type __attribute__((unused)))

{

  update_sys_var_str(&sys_init_slave, &LOCK_sys_init_slave, 0);

}