set_var.cc 125 KB
Newer Older
1
/* Copyright (C) 2000-2003 MySQL AB
unknown's avatar
unknown committed
2 3 4

   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
unknown's avatar
unknown committed
5
   the Free Software Foundation; version 2 of the License.
unknown's avatar
unknown committed
6 7 8 9 10 11 12 13 14 15

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

unknown's avatar
unknown committed
16 17 18 19
/**
  @file

  @brief
unknown's avatar
unknown committed
20 21
  Handling of MySQL SQL variables

unknown's avatar
unknown committed
22
  @details
unknown's avatar
unknown committed
23 24 25 26 27
  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.
28 29
  - 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'
unknown's avatar
unknown committed
30
  - If the variable should be changed from the command line, add a definition
unknown's avatar
unknown committed
31
    of it in the my_option structure list in mysqld.cc
32 33
  - Don't forget to initialize new fields in global_system_variables and
    max_system_variables!
unknown's avatar
unknown committed
34

unknown's avatar
unknown committed
35 36 37 38 39 40 41 42 43 44
  @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
45 46 47
    ulonglong_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).
unknown's avatar
unknown committed
48 49
*/

50
#ifdef USE_PRAGMA_IMPLEMENTATION
unknown's avatar
unknown committed
51 52 53 54
#pragma implementation				// gcc: Class implementation
#endif

#include "mysql_priv.h"
55
#include <mysql.h>
unknown's avatar
unknown committed
56
#include "slave.h"
57
#include "rpl_mi.h"
unknown's avatar
unknown committed
58
#include <my_getopt.h>
59
#include <thr_alarm.h>
unknown's avatar
unknown committed
60
#include <myisam.h>
61
#include <my_dir.h>
62

63
#include "events.h"
64

65
/* WITH_NDBCLUSTER_STORAGE_ENGINE */
66
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
67
extern ulong ndb_cache_check_time;
68
extern char opt_ndb_constrbuf[];
unknown's avatar
unknown committed
69
extern ulong ndb_extra_logging;
70 71
#endif

unknown's avatar
unknown committed
72 73 74 75
#ifdef HAVE_NDB_BINLOG
extern ulong ndb_report_thresh_binlog_epoch_slip;
extern ulong ndb_report_thresh_binlog_mem_usage;
#endif
76

unknown's avatar
unknown committed
77
extern CHARSET_INFO *character_set_filesystem;
78 79


unknown's avatar
unknown committed
80
static DYNAMIC_ARRAY fixed_show_vars;
unknown's avatar
unknown committed
81
static HASH system_variable_hash;
unknown's avatar
unknown committed
82

unknown's avatar
unknown committed
83 84 85
const char *bool_type_names[]= { "OFF", "ON", NullS };
TYPELIB bool_typelib=
{
86
  array_elements(bool_type_names)-1, "", bool_type_names, NULL
unknown's avatar
unknown committed
87 88
};

89 90 91
const char *delay_key_write_type_names[]= { "OFF", "ON", "ALL", NullS };
TYPELIB delay_key_write_typelib=
{
92 93
  array_elements(delay_key_write_type_names)-1, "",
  delay_key_write_type_names, NULL
94 95
};

96 97 98 99 100 101 102 103 104 105
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
};

106 107 108
static int  sys_check_ftb_syntax(THD *thd,  set_var *var);
static bool sys_update_ftb_syntax(THD *thd, set_var * var);
static void sys_default_ftb_syntax(THD *thd, enum_var_type type);
unknown's avatar
unknown committed
109 110 111 112
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);
unknown's avatar
unknown committed
113 114
static bool set_option_bit(THD *thd, set_var *var);
static bool set_option_autocommit(THD *thd, set_var *var);
115
static int  check_log_update(THD *thd, set_var *var);
unknown's avatar
unknown committed
116
static bool set_log_update(THD *thd, set_var *var);
117
static int  check_pseudo_thread_id(THD *thd, set_var *var);
118
void fix_binlog_format_after_update(THD *thd, enum_var_type type);
unknown's avatar
unknown committed
119
static void fix_low_priority_updates(THD *thd, enum_var_type type);
120
static int check_tx_isolation(THD *thd, set_var *var);
unknown's avatar
unknown committed
121
static void fix_tx_isolation(THD *thd, enum_var_type type);
unknown's avatar
unknown committed
122 123
static int check_completion_type(THD *thd, set_var *var);
static void fix_completion_type(THD *thd, enum_var_type type);
unknown's avatar
unknown committed
124 125
static void fix_net_read_timeout(THD *thd, enum_var_type type);
static void fix_net_write_timeout(THD *thd, enum_var_type type);
126
static void fix_net_retry_count(THD *thd, enum_var_type type);
unknown's avatar
unknown committed
127 128
static void fix_max_join_size(THD *thd, enum_var_type type);
static void fix_query_cache_size(THD *thd, enum_var_type type);
129
static void fix_query_cache_min_res_unit(THD *thd, enum_var_type type);
130
static void fix_myisam_max_sort_file_size(THD *thd, enum_var_type type);
131 132
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);
133
static void fix_max_connections(THD *thd, enum_var_type type);
134
static int check_max_delayed_threads(THD *thd, set_var *var);
135 136
static void fix_thd_mem_root(THD *thd, enum_var_type type);
static void fix_trans_mem_root(THD *thd, enum_var_type type);
137
static void fix_server_id(THD *thd, enum_var_type type);
138
static ulonglong fix_unsigned(THD *, ulonglong, const struct my_option *);
139
static bool get_unsigned(THD *thd, set_var *var);
140 141
bool throw_bounds_warning(THD *thd, bool fixed, bool unsignd,
                          const char *name, longlong val);
unknown's avatar
unknown committed
142
static KEY_CACHE *create_key_cache(const char *name, uint length);
143
void fix_sql_mode_var(THD *thd, enum_var_type type);
144 145 146
static uchar *get_error_count(THD *thd);
static uchar *get_warning_count(THD *thd);
static uchar *get_tmpdir(THD *thd);
147 148 149 150 151
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);
unknown's avatar
unknown committed
152 153 154 155 156

/*
  Variable definition list

  These are variables that can be set from the command line, in
157 158 159 160
  alphabetic order.

  The variables are linked into the list. A variable is added to
  it in the constructor (see sys_var class for details).
unknown's avatar
unknown committed
161 162
*/

unknown's avatar
unknown committed
163
static sys_var_chain vars = { NULL, NULL };
164

165 166 167 168 169 170 171 172
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);
173

unknown's avatar
unknown committed
174
static sys_var_bool_ptr	sys_automatic_sp_privileges(&vars, "automatic_sp_privileges",
175 176
					      &sp_automatic_privileges);

unknown's avatar
unknown committed
177 178
static sys_var_const_str       sys_basedir(&vars, "basedir", mysql_home);
static sys_var_long_ptr	sys_binlog_cache_size(&vars, "binlog_cache_size",
unknown's avatar
unknown committed
179
					      &binlog_cache_size);
unknown's avatar
unknown committed
180
static sys_var_thd_binlog_format sys_binlog_format(&vars, "binlog_format",
181
                                            &SV::binlog_format);
unknown's avatar
unknown committed
182
static sys_var_thd_ulong	sys_bulk_insert_buff_size(&vars, "bulk_insert_buffer_size",
unknown's avatar
unknown committed
183
						  &SV::bulk_insert_buff_size);
184 185 186 187
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);
unknown's avatar
unknown committed
188
sys_var_const_str       sys_charset_system(&vars, "character_set_system",
189
                                           (char *)my_charset_utf8_general_ci.name);
190 191 192 193 194 195 196 197 198 199 200 201 202
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);
unknown's avatar
unknown committed
203 204 205 206 207 208 209
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",
unknown's avatar
unknown committed
210 211 212
					 &SV::completion_type,
					 check_completion_type,
					 fix_completion_type);
213 214 215 216 217 218 219 220 221 222 223 224
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);
unknown's avatar
unknown committed
225
static sys_var_long_ptr	sys_concurrent_insert(&vars, "concurrent_insert",
226
                                              &myisam_concurrent_insert);
unknown's avatar
unknown committed
227
static sys_var_long_ptr	sys_connect_timeout(&vars, "connect_timeout",
unknown's avatar
unknown committed
228
					    &connect_timeout);
unknown's avatar
unknown committed
229
static sys_var_const_str       sys_datadir(&vars, "datadir", mysql_real_data_home);
unknown's avatar
unknown committed
230
#ifndef DBUG_OFF
unknown's avatar
unknown committed
231
static sys_var_thd_dbug        sys_dbug(&vars, "debug");
unknown's avatar
unknown committed
232
#endif
unknown's avatar
unknown committed
233
static sys_var_enum		sys_delay_key_write(&vars, "delay_key_write",
234 235 236
					    &delay_key_write_options,
					    &delay_key_write_typelib,
					    fix_delay_key_write);
unknown's avatar
unknown committed
237
static sys_var_long_ptr	sys_delayed_insert_limit(&vars, "delayed_insert_limit",
unknown's avatar
unknown committed
238
						 &delayed_insert_limit);
unknown's avatar
unknown committed
239
static sys_var_long_ptr	sys_delayed_insert_timeout(&vars, "delayed_insert_timeout",
unknown's avatar
unknown committed
240
						   &delayed_insert_timeout);
unknown's avatar
unknown committed
241
static sys_var_long_ptr	sys_delayed_queue_size(&vars, "delayed_queue_size",
unknown's avatar
unknown committed
242
					       &delayed_queue_size);
243

244
#ifdef HAVE_EVENT_SCHEDULER
unknown's avatar
unknown committed
245
static sys_var_event_scheduler sys_event_scheduler(&vars, "event_scheduler");
246 247
#endif

unknown's avatar
unknown committed
248
static sys_var_long_ptr	sys_expire_logs_days(&vars, "expire_logs_days",
unknown's avatar
unknown committed
249
					     &expire_logs_days);
unknown's avatar
unknown committed
250 251 252
static sys_var_bool_ptr	sys_flush(&vars, "flush", &myisam_flush);
static sys_var_long_ptr	sys_flush_time(&vars, "flush_time", &flush_time);
static sys_var_str             sys_ft_boolean_syntax(&vars, "ft_boolean_syntax",
253 254 255 256
                                         sys_check_ftb_syntax,
                                         sys_update_ftb_syntax,
                                         sys_default_ftb_syntax,
                                         ft_boolean_syntax);
unknown's avatar
unknown committed
257
sys_var_str             sys_init_connect(&vars, "init_connect", 0,
258 259
                                         sys_update_init_connect,
                                         sys_default_init_connect,0);
unknown's avatar
unknown committed
260
sys_var_str             sys_init_slave(&vars, "init_slave", 0,
261 262
                                       sys_update_init_slave,
                                       sys_default_init_slave,0);
unknown's avatar
unknown committed
263
static sys_var_thd_ulong	sys_interactive_timeout(&vars, "interactive_timeout",
unknown's avatar
unknown committed
264
						&SV::net_interactive_timeout);
unknown's avatar
unknown committed
265
static sys_var_thd_ulong	sys_join_buffer_size(&vars, "join_buffer_size",
unknown's avatar
unknown committed
266
					     &SV::join_buff_size);
unknown's avatar
unknown committed
267 268
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",
unknown's avatar
unknown committed
269 270
						 offsetof(KEY_CACHE,
							  param_block_size));
unknown's avatar
unknown committed
271
static sys_var_key_cache_long	sys_key_cache_division_limit(&vars, "key_cache_division_limit",
unknown's avatar
unknown committed
272 273
						     offsetof(KEY_CACHE,
							      param_division_limit));
unknown's avatar
unknown committed
274
static sys_var_key_cache_long  sys_key_cache_age_threshold(&vars, "key_cache_age_threshold",
unknown's avatar
unknown committed
275 276
						     offsetof(KEY_CACHE,
							      param_age_threshold));
unknown's avatar
unknown committed
277
static sys_var_bool_ptr	sys_local_infile(&vars, "local_infile",
unknown's avatar
unknown committed
278
					 &opt_local_infile);
unknown's avatar
unknown committed
279 280
static sys_var_trust_routine_creators
sys_trust_routine_creators(&vars, "log_bin_trust_routine_creators",
281
                           &trust_function_creators);
unknown's avatar
unknown committed
282 283
static sys_var_bool_ptr       
sys_trust_function_creators(&vars, "log_bin_trust_function_creators",
284
                            &trust_function_creators);
unknown's avatar
unknown committed
285 286
static sys_var_bool_ptr
  sys_log_queries_not_using_indexes(&vars, "log_queries_not_using_indexes",
287
                                    &opt_log_queries_not_using_indexes);
unknown's avatar
unknown committed
288
static sys_var_thd_ulong	sys_log_warnings(&vars, "log_warnings", &SV::log_warnings);
289 290
static sys_var_microseconds	sys_var_long_query_time(&vars, "long_query_time",
                                                        &SV::long_query_time);
unknown's avatar
unknown committed
291
static sys_var_thd_bool	sys_low_priority_updates(&vars, "low_priority_updates",
unknown's avatar
unknown committed
292 293 294
						 &SV::low_priority_updates,
						 fix_low_priority_updates);
#ifndef TO_BE_DELETED	/* Alias for the low_priority_updates */
unknown's avatar
unknown committed
295
static sys_var_thd_bool	sys_sql_low_priority_updates(&vars, "sql_low_priority_updates",
unknown's avatar
unknown committed
296 297 298
						     &SV::low_priority_updates,
						     fix_low_priority_updates);
#endif
unknown's avatar
unknown committed
299
static sys_var_thd_ulong	sys_max_allowed_packet(&vars, "max_allowed_packet",
unknown's avatar
unknown committed
300
					       &SV::max_allowed_packet);
unknown's avatar
unknown committed
301
static sys_var_long_ptr	sys_max_binlog_cache_size(&vars, "max_binlog_cache_size",
unknown's avatar
unknown committed
302
						  &max_binlog_cache_size);
unknown's avatar
unknown committed
303
static sys_var_long_ptr	sys_max_binlog_size(&vars, "max_binlog_size",
304 305
					    &max_binlog_size,
                                            fix_max_binlog_size);
unknown's avatar
unknown committed
306
static sys_var_long_ptr	sys_max_connections(&vars, "max_connections",
307 308
					    &max_connections,
                                            fix_max_connections);
unknown's avatar
unknown committed
309
static sys_var_long_ptr	sys_max_connect_errors(&vars, "max_connect_errors",
unknown's avatar
unknown committed
310
					       &max_connect_errors);
unknown's avatar
unknown committed
311
static sys_var_thd_ulong       sys_max_insert_delayed_threads(&vars, "max_insert_delayed_threads",
312 313 314
						       &SV::max_insert_delayed_threads,
                                                       check_max_delayed_threads,
                                                       fix_max_connections);
unknown's avatar
unknown committed
315
static sys_var_thd_ulong	sys_max_delayed_threads(&vars, "max_delayed_threads",
316
						&SV::max_insert_delayed_threads,
317 318
                                                check_max_delayed_threads,
                                                fix_max_connections);
unknown's avatar
unknown committed
319
static sys_var_thd_ulong	sys_max_error_count(&vars, "max_error_count",
320
					    &SV::max_error_count);
unknown's avatar
unknown committed
321
static sys_var_thd_ulonglong	sys_max_heap_table_size(&vars, "max_heap_table_size",
unknown's avatar
unknown committed
322
						&SV::max_heap_table_size);
323 324 325 326
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);
unknown's avatar
unknown committed
327
static sys_var_thd_ha_rows	sys_max_join_size(&vars, "max_join_size",
unknown's avatar
unknown committed
328 329
					  &SV::max_join_size,
					  fix_max_join_size);
unknown's avatar
unknown committed
330
static sys_var_thd_ulong	sys_max_seeks_for_key(&vars, "max_seeks_for_key",
331
					      &SV::max_seeks_for_key);
unknown's avatar
unknown committed
332
static sys_var_thd_ulong   sys_max_length_for_sort_data(&vars, "max_length_for_sort_data",
333
                                                 &SV::max_length_for_sort_data);
unknown's avatar
unknown committed
334
#ifndef TO_BE_DELETED	/* Alias for max_join_size */
unknown's avatar
unknown committed
335
static sys_var_thd_ha_rows	sys_sql_max_join_size(&vars, "sql_max_join_size",
unknown's avatar
unknown committed
336 337 338
					      &SV::max_join_size,
					      fix_max_join_size);
#endif
339
static sys_var_long_ptr_global
unknown's avatar
unknown committed
340
sys_max_prepared_stmt_count(&vars, "max_prepared_stmt_count",
341 342
                            &max_prepared_stmt_count,
                            &LOCK_prepared_stmt_count);
unknown's avatar
unknown committed
343
static sys_var_long_ptr	sys_max_relay_log_size(&vars, "max_relay_log_size",
344 345
                                               &max_relay_log_size,
                                               fix_max_relay_log_size);
unknown's avatar
unknown committed
346
static sys_var_thd_ulong	sys_max_sort_length(&vars, "max_sort_length",
unknown's avatar
unknown committed
347
					    &SV::max_sort_length);
unknown's avatar
unknown committed
348
static sys_var_thd_ulong	sys_max_sp_recursion_depth(&vars, "max_sp_recursion_depth",
349
                                                   &SV::max_sp_recursion_depth);
unknown's avatar
unknown committed
350 351
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",
unknown's avatar
unknown committed
352
					   &SV::max_tmp_tables);
unknown's avatar
unknown committed
353
static sys_var_long_ptr	sys_max_write_lock_count(&vars, "max_write_lock_count",
unknown's avatar
unknown committed
354
						 &max_write_lock_count);
355 356
static sys_var_thd_ulong       sys_min_examined_row_limit(&vars, "min_examined_row_limit",
                                                          &SV::min_examined_row_limit);
unknown's avatar
unknown committed
357
static sys_var_thd_ulong       sys_multi_range_count(&vars, "multi_range_count",
unknown's avatar
unknown committed
358
                                              &SV::multi_range_count);
unknown's avatar
unknown committed
359
static sys_var_long_ptr	sys_myisam_data_pointer_size(&vars, "myisam_data_pointer_size",
unknown's avatar
unknown committed
360
                                                    &myisam_data_pointer_size);
unknown's avatar
unknown committed
361 362 363
static sys_var_thd_ulonglong	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);
unknown's avatar
unknown committed
364
static sys_var_bool_ptr	sys_myisam_use_mmap(&vars, "myisam_use_mmap",
unknown's avatar
unknown committed
365
                                            &opt_myisam_use_mmap);
366

unknown's avatar
unknown committed
367
static sys_var_thd_enum         sys_myisam_stats_method(&vars, "myisam_stats_method",
368 369 370 371
                                                &SV::myisam_stats_method,
                                                &myisam_stats_method_typelib,
                                                NULL);

unknown's avatar
unknown committed
372
static sys_var_thd_ulong	sys_net_buffer_length(&vars, "net_buffer_length",
unknown's avatar
unknown committed
373
					      &SV::net_buffer_length);
unknown's avatar
unknown committed
374
static sys_var_thd_ulong	sys_net_read_timeout(&vars, "net_read_timeout",
unknown's avatar
unknown committed
375
					     &SV::net_read_timeout,
376
					     0, fix_net_read_timeout);
unknown's avatar
unknown committed
377
static sys_var_thd_ulong	sys_net_write_timeout(&vars, "net_write_timeout",
unknown's avatar
unknown committed
378
					      &SV::net_write_timeout,
379
					      0, fix_net_write_timeout);
unknown's avatar
unknown committed
380
static sys_var_thd_ulong	sys_net_retry_count(&vars, "net_retry_count",
381
					    &SV::net_retry_count,
382
					    0, fix_net_retry_count);
unknown's avatar
unknown committed
383
static sys_var_thd_bool	sys_new_mode(&vars, "new", &SV::new_mode);
unknown's avatar
unknown committed
384
static sys_var_bool_ptr_readonly sys_old_mode(&vars, "old",
unknown's avatar
unknown committed
385
                                       &global_system_variables.old_mode);
unknown's avatar
unknown committed
386 387 388 389 390
/* these two cannot be static */
sys_var_thd_bool                sys_old_alter_table(&vars, "old_alter_table",
                                            &SV::old_alter_table);
sys_var_thd_bool                sys_old_passwords(&vars, "old_passwords", &SV::old_passwords);
static sys_var_thd_ulong        sys_optimizer_prune_level(&vars, "optimizer_prune_level",
391
                                                  &SV::optimizer_prune_level);
unknown's avatar
unknown committed
392
static sys_var_thd_ulong        sys_optimizer_search_depth(&vars, "optimizer_search_depth",
393
                                                   &SV::optimizer_search_depth);
unknown's avatar
unknown committed
394
static sys_var_thd_ulong        sys_preload_buff_size(&vars, "preload_buffer_size",
unknown's avatar
unknown committed
395
                                              &SV::preload_buff_size);
unknown's avatar
unknown committed
396
static sys_var_thd_ulong	sys_read_buff_size(&vars, "read_buffer_size",
unknown's avatar
unknown committed
397
					   &SV::read_buff_size);
unknown's avatar
unknown committed
398 399
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",
unknown's avatar
unknown committed
400
					       &SV::read_rnd_buff_size);
unknown's avatar
unknown committed
401
static sys_var_thd_ulong	sys_div_precincrement(&vars, "div_precision_increment",
unknown's avatar
unknown committed
402
                                              &SV::div_precincrement);
unknown's avatar
unknown committed
403
static sys_var_long_ptr	sys_rpl_recovery_rank(&vars, "rpl_recovery_rank",
unknown's avatar
unknown committed
404
					      &rpl_recovery_rank);
unknown's avatar
unknown committed
405
static sys_var_long_ptr	sys_query_cache_size(&vars, "query_cache_size",
unknown's avatar
unknown committed
406 407
					     &query_cache_size,
					     fix_query_cache_size);
408

unknown's avatar
unknown committed
409
static sys_var_thd_ulong	sys_range_alloc_block_size(&vars, "range_alloc_block_size",
410
						   &SV::range_alloc_block_size);
unknown's avatar
unknown committed
411
static sys_var_thd_ulong	sys_query_alloc_block_size(&vars, "query_alloc_block_size",
412 413
						   &SV::query_alloc_block_size,
						   0, fix_thd_mem_root);
unknown's avatar
unknown committed
414
static sys_var_thd_ulong	sys_query_prealloc_size(&vars, "query_prealloc_size",
415 416
						&SV::query_prealloc_size,
						0, fix_thd_mem_root);
unknown's avatar
unknown committed
417 418
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",
419 420
						   &SV::trans_alloc_block_size,
						   0, fix_trans_mem_root);
unknown's avatar
unknown committed
421
static sys_var_thd_ulong	sys_trans_prealloc_size(&vars, "transaction_prealloc_size",
422 423
						&SV::trans_prealloc_size,
						0, fix_trans_mem_root);
424
sys_var_enum_const      sys_thread_handling(&vars, "thread_handling",
unknown's avatar
unknown committed
425 426 427
                                            &SV::thread_handling,
                                            &thread_handling_typelib,
                                            NULL);
428

unknown's avatar
unknown committed
429
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
430
static sys_var_long_ptr	sys_query_cache_limit(&vars, "query_cache_limit",
unknown's avatar
unknown committed
431
					      &query_cache.query_cache_limit);
unknown's avatar
unknown committed
432
static sys_var_long_ptr        sys_query_cache_min_res_unit(&vars, "query_cache_min_res_unit",
433 434
						     &query_cache_min_res_unit,
						     fix_query_cache_min_res_unit);
unknown's avatar
unknown committed
435
static sys_var_thd_enum	sys_query_cache_type(&vars, "query_cache_type",
unknown's avatar
unknown committed
436 437
					     &SV::query_cache_type,
					     &query_cache_type_typelib);
unknown's avatar
unknown committed
438 439
static sys_var_thd_bool
sys_query_cache_wlock_invalidate(&vars, "query_cache_wlock_invalidate",
440
				 &SV::query_cache_wlock_invalidate);
unknown's avatar
unknown committed
441
#endif /* HAVE_QUERY_CACHE */
unknown's avatar
unknown committed
442
static sys_var_bool_ptr	sys_secure_auth(&vars, "secure_auth", &opt_secure_auth);
443
static sys_var_const_str_ptr sys_secure_file_priv(&vars, "secure_file_priv",
444
                                             &opt_secure_file_priv);
unknown's avatar
unknown committed
445 446
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",
447
						      &opt_slave_compressed_protocol);
448 449 450 451 452
static sys_var_set_slave_mode slave_exec_mode(&vars,
                                              "slave_exec_mode",
                                              &slave_exec_mode_options,
                                              &slave_exec_mode_typelib,
                                              0);
unknown's avatar
unknown committed
453
static sys_var_long_ptr	sys_slow_launch_time(&vars, "slow_launch_time",
unknown's avatar
unknown committed
454
					     &slow_launch_time);
unknown's avatar
unknown committed
455
static sys_var_thd_ulong	sys_sort_buffer(&vars, "sort_buffer_size",
unknown's avatar
unknown committed
456
					&SV::sortbuff_size);
457 458 459 460 461 462
/*
  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()).
*/
unknown's avatar
unknown committed
463
static sys_var_thd_sql_mode    sys_sql_mode(&vars, "sql_mode",
464
                                            &SV::sql_mode);
465 466 467
#ifdef HAVE_OPENSSL
extern char *opt_ssl_ca, *opt_ssl_capath, *opt_ssl_cert, *opt_ssl_cipher,
            *opt_ssl_key;
unknown's avatar
unknown committed
468 469 470 471 472
static sys_var_const_str_ptr	sys_ssl_ca(&vars, "ssl_ca", &opt_ssl_ca);
static sys_var_const_str_ptr	sys_ssl_capath(&vars, "ssl_capath", &opt_ssl_capath);
static sys_var_const_str_ptr	sys_ssl_cert(&vars, "ssl_cert", &opt_ssl_cert);
static sys_var_const_str_ptr	sys_ssl_cipher(&vars, "ssl_cipher", &opt_ssl_cipher);
static sys_var_const_str_ptr	sys_ssl_key(&vars, "ssl_key", &opt_ssl_key);
473
#else
unknown's avatar
unknown committed
474 475 476 477 478
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);
479
#endif
unknown's avatar
unknown committed
480 481
static sys_var_thd_enum
sys_updatable_views_with_limit(&vars, "updatable_views_with_limit",
482 483
                               &SV::updatable_views_with_limit,
                               &updatable_views_with_limit_typelib);
unknown's avatar
VIEW  
unknown committed
484

unknown's avatar
unknown committed
485 486 487 488 489 490
static sys_var_thd_table_type  sys_table_type(&vars, "table_type",
				       &SV::table_plugin);
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",
491
                                             system_time_zone);
unknown's avatar
unknown committed
492
static sys_var_long_ptr	sys_table_def_size(&vars, "table_definition_cache",
unknown's avatar
unknown committed
493
                                           &table_def_size);
unknown's avatar
unknown committed
494
static sys_var_long_ptr	sys_table_cache_size(&vars, "table_open_cache",
unknown's avatar
unknown committed
495
					     &table_cache_size);
unknown's avatar
unknown committed
496
static sys_var_long_ptr	sys_table_lock_wait_timeout(&vars, "table_lock_wait_timeout",
497
                                                    &table_lock_wait_timeout);
unknown's avatar
unknown committed
498
static sys_var_long_ptr	sys_thread_cache_size(&vars, "thread_cache_size",
unknown's avatar
unknown committed
499
					      &thread_cache_size);
unknown's avatar
unknown committed
500
#if HAVE_POOL_OF_THREADS == 1
unknown's avatar
unknown committed
501
sys_var_long_ptr	sys_thread_pool_size(&vars, "thread_pool_size",
unknown's avatar
unknown committed
502 503
					      &thread_pool_size);
#endif
unknown's avatar
unknown committed
504
static sys_var_thd_enum	sys_tx_isolation(&vars, "tx_isolation",
unknown's avatar
unknown committed
505 506
					 &SV::tx_isolation,
					 &tx_isolation_typelib,
507 508
					 fix_tx_isolation,
					 check_tx_isolation);
unknown's avatar
unknown committed
509
static sys_var_thd_ulonglong	sys_tmp_table_size(&vars, "tmp_table_size",
unknown's avatar
unknown committed
510
					   &SV::tmp_table_size);
unknown's avatar
unknown committed
511
static sys_var_bool_ptr  sys_timed_mutexes(&vars, "timed_mutexes",
unknown's avatar
unknown committed
512
                                    &timed_mutexes);
unknown's avatar
unknown committed
513 514
static sys_var_const_str	sys_version(&vars, "version", server_version);
static sys_var_const_str	sys_version_comment(&vars, "version_comment",
515
                                            MYSQL_COMPILATION_COMMENT);
unknown's avatar
unknown committed
516
static sys_var_const_str	sys_version_compile_machine(&vars, "version_compile_machine",
517
                                                    MACHINE_TYPE);
unknown's avatar
unknown committed
518
static sys_var_const_str	sys_version_compile_os(&vars, "version_compile_os",
519
                                               SYSTEM_TYPE);
unknown's avatar
unknown committed
520
static sys_var_thd_ulong	sys_net_wait_timeout(&vars, "wait_timeout",
unknown's avatar
unknown committed
521
					     &SV::net_wait_timeout);
unknown's avatar
unknown committed
522

unknown's avatar
unknown committed
523
/* Condition pushdown to storage engine */
unknown's avatar
unknown committed
524 525
static sys_var_thd_bool
sys_engine_condition_pushdown(&vars, "engine_condition_pushdown",
unknown's avatar
unknown committed
526 527
			      &SV::engine_condition_pushdown);

528
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
529
/* ndb thread specific variable settings */
unknown's avatar
unknown committed
530 531
static sys_var_thd_ulong
sys_ndb_autoincrement_prefetch_sz(&vars, "ndb_autoincrement_prefetch_sz",
532
				  &SV::ndb_autoincrement_prefetch_sz);
unknown's avatar
unknown committed
533 534
static sys_var_thd_bool
sys_ndb_force_send(&vars, "ndb_force_send", &SV::ndb_force_send);
unknown's avatar
unknown committed
535
#ifdef HAVE_NDB_BINLOG
unknown's avatar
unknown committed
536 537
static sys_var_long_ptr
sys_ndb_report_thresh_binlog_epoch_slip(&vars, "ndb_report_thresh_binlog_epoch_slip",
unknown's avatar
unknown committed
538
                                        &ndb_report_thresh_binlog_epoch_slip);
unknown's avatar
unknown committed
539 540
static sys_var_long_ptr
sys_ndb_report_thresh_binlog_mem_usage(&vars, "ndb_report_thresh_binlog_mem_usage",
unknown's avatar
unknown committed
541 542
                                       &ndb_report_thresh_binlog_mem_usage);
#endif
unknown's avatar
unknown committed
543 544 545 546 547 548
static sys_var_thd_bool
sys_ndb_use_exact_count(&vars, "ndb_use_exact_count", &SV::ndb_use_exact_count);
static sys_var_thd_bool
sys_ndb_use_transactions(&vars, "ndb_use_transactions", &SV::ndb_use_transactions);
static sys_var_long_ptr
sys_ndb_cache_check_time(&vars, "ndb_cache_check_time", &ndb_cache_check_time);
549 550
static sys_var_const_str
sys_ndb_connectstring(&vars, "ndb_connectstring", opt_ndb_constrbuf);
unknown's avatar
unknown committed
551 552
static sys_var_thd_bool
sys_ndb_index_stat_enable(&vars, "ndb_index_stat_enable",
553
                          &SV::ndb_index_stat_enable);
unknown's avatar
unknown committed
554 555
static sys_var_thd_ulong
sys_ndb_index_stat_cache_entries(&vars, "ndb_index_stat_cache_entries",
556
                                 &SV::ndb_index_stat_cache_entries);
unknown's avatar
unknown committed
557 558
static sys_var_thd_ulong
sys_ndb_index_stat_update_freq(&vars, "ndb_index_stat_update_freq",
559
                               &SV::ndb_index_stat_update_freq);
unknown's avatar
unknown committed
560 561 562 563
static sys_var_long_ptr
sys_ndb_extra_logging(&vars, "ndb_extra_logging", &ndb_extra_logging);
static sys_var_thd_bool
sys_ndb_use_copying_alter_table(&vars, "ndb_use_copying_alter_table", &SV::ndb_use_copying_alter_table);
564
#endif //WITH_NDBCLUSTER_STORAGE_ENGINE
565 566 567

/* Time/date/datetime formats */

unknown's avatar
unknown committed
568
static sys_var_thd_date_time_format sys_time_format(&vars, "time_format",
569
					     &SV::time_format,
570
					     MYSQL_TIMESTAMP_TIME);
unknown's avatar
unknown committed
571
static sys_var_thd_date_time_format sys_date_format(&vars, "date_format",
572
					     &SV::date_format,
573
					     MYSQL_TIMESTAMP_DATE);
unknown's avatar
unknown committed
574
static sys_var_thd_date_time_format sys_datetime_format(&vars, "datetime_format",
575
						 &SV::datetime_format,
576
						 MYSQL_TIMESTAMP_DATETIME);
577 578

/* Variables that are bits in THD */
unknown's avatar
unknown committed
579

unknown's avatar
unknown committed
580
sys_var_thd_bit sys_autocommit(&vars, "autocommit", 0,
581 582 583
                               set_option_autocommit,
                               OPTION_NOT_AUTOCOMMIT,
                               1);
unknown's avatar
unknown committed
584
static sys_var_thd_bit	sys_big_tables(&vars, "big_tables", 0,
unknown's avatar
unknown committed
585 586 587
				       set_option_bit,
				       OPTION_BIG_TABLES);
#ifndef TO_BE_DELETED	/* Alias for big_tables */
unknown's avatar
unknown committed
588
static sys_var_thd_bit	sys_sql_big_tables(&vars, "sql_big_tables", 0,
unknown's avatar
unknown committed
589 590 591
					   set_option_bit,
					   OPTION_BIG_TABLES);
#endif
unknown's avatar
unknown committed
592
static sys_var_thd_bit	sys_big_selects(&vars, "sql_big_selects", 0,
unknown's avatar
unknown committed
593
					set_option_bit,
594
					OPTION_BIG_SELECTS);
unknown's avatar
unknown committed
595
static sys_var_thd_bit	sys_log_off(&vars, "sql_log_off",
596
				    check_log_update,
unknown's avatar
unknown committed
597 598
				    set_option_bit,
				    OPTION_LOG_OFF);
unknown's avatar
unknown committed
599
static sys_var_thd_bit	sys_log_update(&vars, "sql_log_update",
600
                                       check_log_update,
unknown's avatar
unknown committed
601
				       set_log_update,
602
				       OPTION_BIN_LOG);
unknown's avatar
unknown committed
603
static sys_var_thd_bit	sys_log_binlog(&vars, "sql_log_bin",
604
                                       check_log_update,
605
				       set_option_bit,
606
				       OPTION_BIN_LOG);
unknown's avatar
unknown committed
607
static sys_var_thd_bit	sys_sql_warnings(&vars, "sql_warnings", 0,
unknown's avatar
unknown committed
608 609
					 set_option_bit,
					 OPTION_WARNINGS);
unknown's avatar
unknown committed
610
static sys_var_thd_bit	sys_sql_notes(&vars, "sql_notes", 0,
611
					 set_option_bit,
612
					 OPTION_SQL_NOTES);
unknown's avatar
unknown committed
613
static sys_var_thd_bit	sys_auto_is_null(&vars, "sql_auto_is_null", 0,
unknown's avatar
unknown committed
614
					 set_option_bit,
615 616
                                         OPTION_AUTO_IS_NULL, 0,
                                         sys_var::SESSION_VARIABLE_IN_BINLOG);
unknown's avatar
unknown committed
617
static sys_var_thd_bit	sys_safe_updates(&vars, "sql_safe_updates", 0,
unknown's avatar
unknown committed
618 619
					 set_option_bit,
					 OPTION_SAFE_UPDATES);
unknown's avatar
unknown committed
620
static sys_var_thd_bit	sys_buffer_results(&vars, "sql_buffer_result", 0,
unknown's avatar
unknown committed
621 622
					   set_option_bit,
					   OPTION_BUFFER_RESULT);
unknown's avatar
unknown committed
623
static sys_var_thd_bit	sys_quote_show_create(&vars, "sql_quote_show_create", 0,
unknown's avatar
unknown committed
624 625
					      set_option_bit,
					      OPTION_QUOTE_SHOW_CREATE);
unknown's avatar
unknown committed
626
static sys_var_thd_bit	sys_foreign_key_checks(&vars, "foreign_key_checks", 0,
627 628
					       set_option_bit,
					       OPTION_NO_FOREIGN_KEY_CHECKS,
629
                                               1, sys_var::SESSION_VARIABLE_IN_BINLOG);
unknown's avatar
unknown committed
630
static sys_var_thd_bit	sys_unique_checks(&vars, "unique_checks", 0,
631 632
					  set_option_bit,
					  OPTION_RELAXED_UNIQUE_CHECKS,
633 634
                                          1,
                                          sys_var::SESSION_VARIABLE_IN_BINLOG);
635
#if defined(ENABLED_PROFILING) && defined(COMMUNITY_SERVER)
636 637
static sys_var_thd_bit  sys_profiling(&vars, "profiling", NULL, 
                                      set_option_bit,
638
                                      ulonglong(OPTION_PROFILING));
639
static sys_var_thd_ulong	sys_profiling_history_size(&vars, "profiling_history_size",
640 641
					      &SV::profiling_history_size);
#endif
642

unknown's avatar
unknown committed
643 644
/* Local state variables */

unknown's avatar
unknown committed
645
static sys_var_thd_ha_rows	sys_select_limit(&vars, "sql_select_limit",
unknown's avatar
unknown committed
646
						 &SV::select_limit);
647 648 649 650 651 652 653 654 655 656 657
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);
unknown's avatar
unknown committed
658

659 660
static sys_var_thd_lc_time_names
sys_lc_time_names(&vars, "lc_time_names", sys_var::SESSION_VARIABLE_IN_BINLOG);
unknown's avatar
unknown committed
661

662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
/*
  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");
unknown's avatar
unknown committed
682
static sys_var_readonly		sys_error_count(&vars, "error_count",
683 684 685
						OPT_SESSION,
						SHOW_LONG,
						get_error_count);
unknown's avatar
unknown committed
686
static sys_var_readonly		sys_warning_count(&vars, "warning_count",
687 688 689 690
						  OPT_SESSION,
						  SHOW_LONG,
						  get_warning_count);

691 692 693 694
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);
unknown's avatar
unknown committed
695

unknown's avatar
unknown committed
696
static sys_var_thd_ulong        sys_default_week_format(&vars, "default_week_format",
697
					                &SV::default_week_format);
unknown's avatar
unknown committed
698

unknown's avatar
unknown committed
699
sys_var_thd_ulong               sys_group_concat_max_len(&vars, "group_concat_max_len",
unknown's avatar
unknown committed
700 701
                                                         &SV::group_concat_max_len);

702 703
sys_var_thd_time_zone sys_time_zone(&vars, "time_zone",
                                    sys_var::SESSION_VARIABLE_IN_BINLOG);
704

705 706
/* Global read-only variable containing hostname */
static sys_var_const_str        sys_hostname(&vars, "hostname", glob_hostname);
707 708

#ifndef EMBEDDED_LIBRARY
709 710 711 712 713 714 715 716 717 718
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;
}

unknown's avatar
unknown committed
719
static sys_var_readonly    sys_repl_report_port(&vars, "report_port", OPT_GLOBAL, SHOW_LONG, slave_get_report_port);
720

721
#endif
722

723
sys_var_thd_bool  sys_keep_files_on_create(&vars, "keep_files_on_create", 
unknown's avatar
unknown committed
724
                                           &SV::keep_files_on_create);
725 726
/* Read only variables */

unknown's avatar
unknown committed
727 728 729 730 731 732 733
static sys_var_have_variable sys_have_compress(&vars, "have_compress", &have_compress);
static sys_var_have_variable sys_have_crypt(&vars, "have_crypt", &have_crypt);
static sys_var_have_plugin sys_have_csv(&vars, "have_csv", C_STRING_WITH_LEN("csv"), MYSQL_STORAGE_ENGINE_PLUGIN);
static sys_var_have_variable sys_have_dlopen(&vars, "have_dynamic_loading", &have_dlopen);
static sys_var_have_variable sys_have_geometry(&vars, "have_geometry", &have_geometry);
static sys_var_have_plugin sys_have_innodb(&vars, "have_innodb", C_STRING_WITH_LEN("innodb"), MYSQL_STORAGE_ENGINE_PLUGIN);
static sys_var_have_plugin sys_have_ndbcluster(&vars, "have_ndbcluster", C_STRING_WITH_LEN("ndbcluster"), MYSQL_STORAGE_ENGINE_PLUGIN);
unknown's avatar
unknown committed
734 735
static sys_var_have_variable sys_have_openssl(&vars, "have_openssl", &have_ssl);
static sys_var_have_variable sys_have_ssl(&vars, "have_ssl", &have_ssl);
unknown's avatar
unknown committed
736 737
static sys_var_have_plugin sys_have_partition_db(&vars, "have_partitioning", C_STRING_WITH_LEN("partition"), MYSQL_STORAGE_ENGINE_PLUGIN);
static sys_var_have_variable sys_have_query_cache(&vars, "have_query_cache",
unknown's avatar
unknown committed
738
                                           &have_query_cache);
739
static sys_var_have_variable sys_have_community_features(&vars, "have_community_features", &have_community_features);
unknown's avatar
unknown committed
740 741
static sys_var_have_variable sys_have_rtree_keys(&vars, "have_rtree_keys", &have_rtree_keys);
static sys_var_have_variable sys_have_symlink(&vars, "have_symlink", &have_symlink);
742
/* Global read-only variable describing server license */
unknown's avatar
unknown committed
743
static sys_var_const_str	sys_license(&vars, "license", STRINGIFY_ARG(LICENSE));
744
/* Global variables which enable|disable logging */
unknown's avatar
unknown committed
745
static sys_var_log_state sys_var_general_log(&vars, "general_log", &opt_log,
746
                                      QUERY_LOG_GENERAL);
747 748 749
/* 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);
unknown's avatar
unknown committed
750
static sys_var_log_state sys_var_slow_query_log(&vars, "slow_query_log", &opt_slow_log,
751
                                         QUERY_LOG_SLOW);
752 753 754
/* 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);
unknown's avatar
unknown committed
755
sys_var_str sys_var_general_log_path(&vars, "general_log_file", sys_check_log_path,
756 757 758
				     sys_update_general_log_path,
				     sys_default_general_log_path,
				     opt_logname);
unknown's avatar
unknown committed
759
sys_var_str sys_var_slow_log_path(&vars, "slow_query_log_file", sys_check_log_path,
760 761 762
				  sys_update_slow_log_path, 
				  sys_default_slow_log_path,
				  opt_slow_logname);
unknown's avatar
unknown committed
763
static sys_var_log_output sys_var_log_output_state(&vars, "log_output", &log_output_options,
764 765
					    &log_output_typelib, 0);

766

unknown's avatar
unknown committed
767
/*
unknown's avatar
unknown committed
768 769 770 771
  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
unknown's avatar
unknown committed
772 773
*/

unknown's avatar
unknown committed
774 775
#define FIXED_VARS_SIZE (sizeof(fixed_vars) / sizeof(SHOW_VAR))
static SHOW_VAR fixed_vars[]= {
unknown's avatar
unknown committed
776
  {"back_log",                (char*) &back_log,                    SHOW_LONG},
777
  {"character_sets_dir",      mysql_charsets_dir,                   SHOW_CHAR},
unknown's avatar
unknown committed
778
  {"ft_max_word_len",         (char*) &ft_max_word_len,             SHOW_LONG},
779
  {"ft_min_word_len",         (char*) &ft_min_word_len,             SHOW_LONG},
780
  {"ft_query_expansion_limit",(char*) &ft_query_expansion_limit,    SHOW_LONG},
781
  {"ft_stopword_file",        (char*) &ft_stopword_file,            SHOW_CHAR_PTR},
782
  {"init_file",               (char*) &opt_init_file,               SHOW_CHAR_PTR},
unknown's avatar
unknown committed
783
  {"language",                language,                             SHOW_CHAR},
784
  {"large_files_support",     (char*) &opt_large_files,             SHOW_BOOL},
785
  {"large_page_size",         (char*) &opt_large_page_size,         SHOW_INT},
unknown's avatar
unknown committed
786
  {"large_pages",             (char*) &opt_large_pages,             SHOW_MY_BOOL},
unknown's avatar
unknown committed
787
#ifdef HAVE_MLOCKALL
unknown's avatar
unknown committed
788
  {"locked_in_memory",	      (char*) &locked_in_memory,	    SHOW_MY_BOOL},
unknown's avatar
unknown committed
789 790
#endif
  {"log_bin",                 (char*) &opt_bin_log,                 SHOW_BOOL},
791
  {"log_error",               (char*) log_error_file,               SHOW_CHAR},
792
  {"lower_case_file_system",  (char*) &lower_case_file_system,      SHOW_MY_BOOL},
793 794
  {"lower_case_table_names",  (char*) &lower_case_table_names,      SHOW_INT},
  {"myisam_recover_options",  (char*) &myisam_recover_options_str,  SHOW_CHAR_PTR},
unknown's avatar
unknown committed
795
#ifdef __NT__
796
  {"named_pipe",	      (char*) &opt_enable_named_pipe,       SHOW_MY_BOOL},
797
#endif
unknown's avatar
unknown committed
798 799
  {"open_files_limit",	      (char*) &open_files_limit,	    SHOW_LONG},
  {"pid_file",                (char*) pidfile_name,                 SHOW_CHAR},
800
  {"plugin_dir",              (char*) opt_plugin_dir,               SHOW_CHAR},
unknown's avatar
unknown committed
801
  {"port",                    (char*) &mysqld_port,                 SHOW_INT},
802
  {"protocol_version",        (char*) &protocol_version,            SHOW_INT},
803 804 805 806
#ifdef HAVE_SMEM
  {"shared_memory",           (char*) &opt_enable_shared_memory,    SHOW_MY_BOOL},
  {"shared_memory_base_name", (char*) &shared_memory_base_name,     SHOW_CHAR_PTR},
#endif
807
  {"skip_external_locking",   (char*) &my_disable_locking,          SHOW_MY_BOOL},
unknown's avatar
unknown committed
808 809
  {"skip_networking",         (char*) &opt_disable_networking,      SHOW_BOOL},
  {"skip_show_database",      (char*) &opt_skip_show_db,            SHOW_BOOL},
810
#ifdef HAVE_SYS_UN_H
unknown's avatar
unknown committed
811
  {"socket",                  (char*) &mysqld_unix_port,            SHOW_CHAR_PTR},
unknown's avatar
unknown committed
812
#endif
unknown's avatar
unknown committed
813 814 815
#ifdef HAVE_THR_SETCONCURRENCY
  {"thread_concurrency",      (char*) &concurrency,                 SHOW_LONG},
#endif
816
  {"thread_stack",            (char*) &my_thread_stack_size,        SHOW_LONG},
unknown's avatar
unknown committed
817 818
};

819

820 821 822 823 824 825
bool sys_var::check(THD *thd, set_var *var)
{
  var->save_result.ulonglong_value= var->value->val_int();
  return 0;
}

826 827 828 829 830 831 832
bool sys_var_str::check(THD *thd, set_var *var)
{
  int res;
  if (!check_func)
    return 0;

  if ((res=(*check_func)(thd, var)) < 0)
833 834
    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0),
             name, var->value->str_value.ptr());
835 836 837
  return res;
}

unknown's avatar
unknown committed
838 839 840 841
/*
  Functions to check and update variables
*/

unknown's avatar
unknown committed
842

843 844 845 846 847 848 849 850 851 852
/*
  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)
unknown's avatar
unknown committed
853
{
854 855 856 857
  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*) "";
858
  if (!(res= my_strndup(old_value, new_length, MYF(0))))
859
    return 1;
unknown's avatar
unknown committed
860 861 862 863
  /*
    Replace the old value in such a way that the any thread using
    the value will work.
  */
864 865 866 867 868
  rw_wrlock(var_mutex);
  old_value= var_str->value;
  var_str->value= res;
  var_str->value_length= new_length;
  rw_unlock(var_mutex);
unknown's avatar
unknown committed
869 870 871 872 873
  my_free(old_value, MYF(MY_ALLOW_ZERO_PTR));
  return 0;
}


874 875 876 877 878 879
static bool sys_update_init_connect(THD *thd, set_var *var)
{
  return update_sys_var_str(&sys_init_connect, &LOCK_sys_init_connect, var);
}


unknown's avatar
unknown committed
880 881
static void sys_default_init_connect(THD* thd, enum_var_type type)
{
882
  update_sys_var_str(&sys_init_connect, &LOCK_sys_init_connect, 0);
unknown's avatar
unknown committed
883 884 885 886 887
}


static bool sys_update_init_slave(THD *thd, set_var *var)
{
888
  return update_sys_var_str(&sys_init_slave, &LOCK_sys_init_slave, var);
unknown's avatar
unknown committed
889 890 891 892 893
}


static void sys_default_init_slave(THD* thd, enum_var_type type)
{
894
  update_sys_var_str(&sys_init_slave, &LOCK_sys_init_slave, 0);
unknown's avatar
unknown committed
895 896
}

897 898
static int sys_check_ftb_syntax(THD *thd,  set_var *var)
{
899
  if (thd->security_ctx->master_access & SUPER_ACL)
900
    return (ft_boolean_check_syntax_string((uchar*)
901 902
                                           var->value->str_value.c_ptr()) ?
            -1 : 0);
903 904 905 906 907 908 909 910 911 912 913
  else
  {
    my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), "SUPER");
    return 1;
  }
}

static bool sys_update_ftb_syntax(THD *thd, set_var * var)
{
  strmake(ft_boolean_syntax, var->value->str_value.c_ptr(),
	  sizeof(ft_boolean_syntax)-1);
914 915 916 917 918

#ifdef HAVE_QUERY_CACHE
  query_cache.flush();
#endif /* HAVE_QUERY_CACHE */

919 920 921 922 923
  return 0;
}

static void sys_default_ftb_syntax(THD *thd, enum_var_type type)
{
924
  strmake(ft_boolean_syntax, def_ft_boolean_syntax,
925 926
	  sizeof(ft_boolean_syntax)-1);
}
unknown's avatar
unknown committed
927

unknown's avatar
unknown committed
928

unknown's avatar
unknown committed
929
/**
unknown's avatar
unknown committed
930
  If one sets the LOW_PRIORIY UPDATES flag, we also must change the
unknown's avatar
unknown committed
931
  used lock type.
unknown's avatar
unknown committed
932 933 934 935
*/

static void fix_low_priority_updates(THD *thd, enum_var_type type)
{
936 937 938 939 940
  if (type == OPT_GLOBAL)
    thr_upgraded_concurrent_insert_lock= 
      (global_system_variables.low_priority_updates ?
       TL_WRITE_LOW_PRIORITY : TL_WRITE);
  else
unknown's avatar
unknown committed
941 942 943 944 945
    thd->update_lock_default= (thd->variables.low_priority_updates ?
			       TL_WRITE_LOW_PRIORITY : TL_WRITE);
}


946 947 948 949 950 951 952
static void
fix_myisam_max_sort_file_size(THD *thd, enum_var_type type)
{
  myisam_max_temp_length=
    (my_off_t) global_system_variables.myisam_max_sort_file_size;
}

unknown's avatar
unknown committed
953 954
/**
  Set the OPTION_BIG_SELECTS flag if max_join_size == HA_POS_ERROR.
unknown's avatar
unknown committed
955 956 957 958 959 960
*/

static void fix_max_join_size(THD *thd, enum_var_type type)
{
  if (type != OPT_GLOBAL)
  {
961
    if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
962 963 964 965 966
      thd->options|= OPTION_BIG_SELECTS;
    else
      thd->options&= ~OPTION_BIG_SELECTS;
  }
}
967

unknown's avatar
unknown committed
968

unknown's avatar
unknown committed
969
/**
970 971 972 973 974 975 976 977 978 979 980 981 982
  Can't change the 'next' tx_isolation while we are already in
  a transaction
*/
static int check_tx_isolation(THD *thd, set_var *var)
{
  if (var->type == OPT_DEFAULT && (thd->server_status & SERVER_STATUS_IN_TRANS))
  {
    my_error(ER_CANT_CHANGE_TX_ISOLATION, MYF(0));
    return 1;
  }
  return 0;
}

unknown's avatar
unknown committed
983 984
/*
  If one doesn't use the SESSION modifier, the isolation level
unknown's avatar
unknown committed
985
  is only active for the next command.
unknown's avatar
unknown committed
986 987 988 989 990 991 992 993
*/
static void fix_tx_isolation(THD *thd, enum_var_type type)
{
  if (type == OPT_SESSION)
    thd->session_tx_isolation= ((enum_tx_isolation)
				thd->variables.tx_isolation);
}

994 995
static void fix_completion_type(THD *thd __attribute__((unused)),
				enum_var_type type __attribute__((unused))) {}
unknown's avatar
unknown committed
996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008

static int check_completion_type(THD *thd, set_var *var)
{
  longlong val= var->value->val_int();
  if (val < 0 || val > 2)
  {
    char buf[64];
    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->var->name, llstr(val, buf));
    return 1;
  }
  return 0;
}

unknown's avatar
unknown committed
1009 1010 1011 1012 1013

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

unknown's avatar
SCRUM  
unknown committed
1014
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
1015 1016 1017
static void fix_net_read_timeout(THD *thd, enum_var_type type)
{
  if (type != OPT_GLOBAL)
1018
    my_net_set_read_timeout(&thd->net, thd->variables.net_read_timeout);
unknown's avatar
unknown committed
1019 1020 1021 1022 1023 1024
}


static void fix_net_write_timeout(THD *thd, enum_var_type type)
{
  if (type != OPT_GLOBAL)
1025
    my_net_set_write_timeout(&thd->net, thd->variables.net_write_timeout);
unknown's avatar
unknown committed
1026 1027
}

1028 1029 1030 1031 1032
static void fix_net_retry_count(THD *thd, enum_var_type type)
{
  if (type != OPT_GLOBAL)
    thd->net.retry_count=thd->variables.net_retry_count;
}
unknown's avatar
SCRUM  
unknown committed
1033
#else /* HAVE_REPLICATION */
1034 1035
static void fix_net_read_timeout(THD *thd __attribute__((unused)),
				 enum_var_type type __attribute__((unused)))
1036
{}
1037 1038
static void fix_net_write_timeout(THD *thd __attribute__((unused)),
				  enum_var_type type __attribute__((unused)))
1039
{}
1040 1041
static void fix_net_retry_count(THD *thd __attribute__((unused)),
				enum_var_type type __attribute__((unused)))
1042
{}
unknown's avatar
SCRUM  
unknown committed
1043
#endif /* HAVE_REPLICATION */
1044

unknown's avatar
unknown committed
1045 1046 1047 1048

static void fix_query_cache_size(THD *thd, enum_var_type type)
{
#ifdef HAVE_QUERY_CACHE
1049 1050 1051 1052 1053 1054 1055 1056
  ulong new_cache_size= query_cache.resize(query_cache_size);

  /*
     Note: query_cache_size is a global variable reflecting the 
     requested cache size. See also query_cache_size_arg
  */

  if (query_cache_size != new_cache_size)
1057 1058
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
			ER_WARN_QC_RESIZE, ER(ER_WARN_QC_RESIZE),
1059 1060 1061
			query_cache_size, new_cache_size);
  
  query_cache_size= new_cache_size;
unknown's avatar
unknown committed
1062 1063 1064 1065
#endif
}


1066 1067 1068 1069 1070 1071 1072 1073 1074
#ifdef HAVE_QUERY_CACHE
static void fix_query_cache_min_res_unit(THD *thd, enum_var_type type)
{
  query_cache_min_res_unit= 
    query_cache.set_min_res_unit(query_cache_min_res_unit);
}
#endif


1075
extern void fix_delay_key_write(THD *thd, enum_var_type type)
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
{
  switch ((enum_delay_key_write) delay_key_write_options) {
  case DELAY_KEY_WRITE_NONE:
    myisam_delay_key_write=0;
    break;
  case DELAY_KEY_WRITE_ON:
    myisam_delay_key_write=1;
    break;
  case DELAY_KEY_WRITE_ALL:
    myisam_delay_key_write=1;
    ha_open_options|= HA_OPEN_DELAY_KEY_WRITE;
    break;
  }
}

1091 1092 1093 1094
bool sys_var_set::update(THD *thd, set_var *var)
{
  *value= var->save_result.ulong_value;
  return 0;
1095
}
1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163

uchar *sys_var_set::value_ptr(THD *thd, enum_var_type type,
                              LEX_STRING *base)
{
  char buff[256];
  String tmp(buff, sizeof(buff), &my_charset_latin1);
  ulong length;
  ulong val= *value;

  tmp.length(0);
  for (uint i= 0; val; val>>= 1, i++)
  {
    if (val & 1)
    {
      tmp.append(enum_names->type_names[i],
                 enum_names->type_lengths[i]);
      tmp.append(',');
    }
  }

  if ((length= tmp.length()))
    length--;
  return (uchar*) thd->strmake(tmp.ptr(), length);
}

void sys_var_set_slave_mode::set_default(THD *thd, enum_var_type type)
{
  slave_exec_mode_options= 0;
  bit_do_set(slave_exec_mode_options, SLAVE_EXEC_MODE_STRICT);
}

bool sys_var_set_slave_mode::check(THD *thd, set_var *var)
{
  bool rc=  sys_var_set::check(thd, var);
  if (!rc &&
      bit_is_set(var->save_result.ulong_value, SLAVE_EXEC_MODE_STRICT) == 1 &&
      bit_is_set(var->save_result.ulong_value, SLAVE_EXEC_MODE_IDEMPOTENT) == 1)
  {
    rc= true;
    my_error(ER_SLAVE_AMBIGOUS_EXEC_MODE, MYF(0), "");
  }
  return rc;
}

bool sys_var_set_slave_mode::update(THD *thd, set_var *var)
{
  bool rc;
  pthread_mutex_lock(&LOCK_global_system_variables);
  rc= sys_var_set::update(thd, var);
  pthread_mutex_unlock(&LOCK_global_system_variables);
  return rc;
}

void fix_slave_exec_mode(enum_var_type type)
{
  DBUG_ENTER("fix_slave_exec_mode");
  compile_time_assert(sizeof(slave_exec_mode_options) * CHAR_BIT
                      > SLAVE_EXEC_MODE_LAST_BIT - 1);
  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)
  {
    sql_print_error("Ambiguous slave modes combination."
                    " STRICT will be used");
    bit_do_clear(slave_exec_mode_options, SLAVE_EXEC_MODE_IDEMPOTENT);
  }
  if (bit_is_set(slave_exec_mode_options, SLAVE_EXEC_MODE_IDEMPOTENT) == 0)
    bit_do_set(slave_exec_mode_options, SLAVE_EXEC_MODE_STRICT);
}
1164

Mats Kindahl's avatar
Mats Kindahl committed
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179

bool sys_var_thd_binlog_format::check(THD *thd, set_var *var) {
  /*
    All variables that affect writing to binary log (either format or
    turning logging on and off) use the same checking. We call the
    superclass ::check function to assign the variable correctly, and
    then check the value.
   */
  bool result= sys_var_thd_enum::check(thd, var);
  if (!result)
    result= check_log_update(thd, var);
  return result;
}


1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
bool sys_var_thd_binlog_format::is_readonly() const
{
  /*
    Under certain circumstances, the variable is read-only (unchangeable):
  */
  THD *thd= current_thd;
  /*
    If RBR and open temporary tables, their CREATE TABLE may not be in the
    binlog, so we can't toggle to SBR in this connection.
    The test below will also prevent SET GLOBAL, well it was not easy to test
    if global or not here.
    And this test will also prevent switching from RBR to RBR (a no-op which
    should not happen too often).
1193 1194 1195

    If we don't have row-based replication compiled in, the variable
    is always read-only.
1196 1197 1198 1199 1200 1201 1202 1203
  */
  if ((thd->variables.binlog_format == BINLOG_FORMAT_ROW) &&
      thd->temporary_tables)
  {
    my_error(ER_TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR, MYF(0));
    return 1;
  }
  /*
unknown's avatar
unknown committed
1204
    if in a stored function/trigger, it's too late to change mode
1205
  */
unknown's avatar
unknown committed
1206
  if (thd->in_sub_stmt)
1207 1208 1209 1210 1211 1212 1213
  {
    my_error(ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_FORMAT, MYF(0));
    return 1;    
  }
  return sys_var_thd_enum::is_readonly();
}

unknown's avatar
unknown committed
1214

1215 1216 1217 1218 1219 1220
void fix_binlog_format_after_update(THD *thd, enum_var_type type)
{
  thd->reset_current_stmt_binlog_row_based();
}


1221
static void fix_max_binlog_size(THD *thd, enum_var_type type)
1222 1223 1224 1225 1226
{
  DBUG_ENTER("fix_max_binlog_size");
  DBUG_PRINT("info",("max_binlog_size=%lu max_relay_log_size=%lu",
                     max_binlog_size, max_relay_log_size));
  mysql_bin_log.set_max_size(max_binlog_size);
1227
#ifdef HAVE_REPLICATION
1228 1229
  if (!max_relay_log_size)
    active_mi->rli.relay_log.set_max_size(max_binlog_size);
unknown's avatar
unknown committed
1230
#endif
1231 1232 1233
  DBUG_VOID_RETURN;
}

1234
static void fix_max_relay_log_size(THD *thd, enum_var_type type)
1235 1236 1237 1238
{
  DBUG_ENTER("fix_max_relay_log_size");
  DBUG_PRINT("info",("max_binlog_size=%lu max_relay_log_size=%lu",
                     max_binlog_size, max_relay_log_size));
1239
#ifdef HAVE_REPLICATION
1240 1241
  active_mi->rli.relay_log.set_max_size(max_relay_log_size ?
                                        max_relay_log_size: max_binlog_size);
1242
#endif
1243 1244
  DBUG_VOID_RETURN;
}
1245

1246

1247 1248
static int check_max_delayed_threads(THD *thd, set_var *var)
{
unknown's avatar
unknown committed
1249
  longlong val= var->value->val_int();
1250
  if (var->type != OPT_GLOBAL && val != 0 &&
unknown's avatar
unknown committed
1251
      val != (longlong) global_system_variables.max_insert_delayed_threads)
1252 1253
  {
    char buf[64];
1254
    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->var->name, llstr(val, buf));
1255 1256 1257 1258 1259
    return 1;
  }
  return 0;
}

1260
static void fix_max_connections(THD *thd, enum_var_type type)
1261
{
1262
#ifndef EMBEDDED_LIBRARY
1263 1264
  resize_thr_alarm(max_connections + 
		   global_system_variables.max_insert_delayed_threads + 10);
1265
#endif
1266 1267 1268 1269 1270 1271
}


static void fix_thd_mem_root(THD *thd, enum_var_type type)
{
  if (type != OPT_GLOBAL)
unknown's avatar
unknown committed
1272
    reset_root_defaults(thd->mem_root,
1273 1274 1275 1276 1277 1278 1279
                        thd->variables.query_alloc_block_size,
                        thd->variables.query_prealloc_size);
}


static void fix_trans_mem_root(THD *thd, enum_var_type type)
{
1280
#ifdef USING_TRANSACTIONS
1281 1282 1283 1284
  if (type != OPT_GLOBAL)
    reset_root_defaults(&thd->transaction.mem_root,
                        thd->variables.trans_alloc_block_size,
                        thd->variables.trans_prealloc_size);
1285
#endif
1286 1287
}

1288

1289 1290 1291
static void fix_server_id(THD *thd, enum_var_type type)
{
  server_id_supplied = 1;
1292
  thd->server_id= server_id;
1293
}
1294

1295

1296 1297
bool throw_bounds_warning(THD *thd, bool fixed, bool unsignd,
                          const char *name, longlong val)
1298
{
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
  if (fixed)
  {
    char buf[22];

    if (unsignd)
      ullstr((ulonglong) val, buf);
    else
      llstr(val, buf);

    if (thd->variables.sql_mode & MODE_STRICT_ALL_TABLES)
    {
      my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name, buf);
      return TRUE;
    }

    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_TRUNCATED_WRONG_VALUE,
                        ER(ER_TRUNCATED_WRONG_VALUE), name, buf);
  }
  return FALSE;
1319 1320 1321 1322 1323
}

static ulonglong fix_unsigned(THD *thd, ulonglong num,
                              const struct my_option *option_limits)
{
1324
  my_bool fixed= FALSE;
1325 1326
  ulonglong out= getopt_ull_limit_value(num, option_limits, &fixed);

1327
  throw_bounds_warning(thd, fixed, TRUE, option_limits->name, (longlong) num);
1328 1329 1330
  return out;
}

1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342
static bool get_unsigned(THD *thd, set_var *var)
{
  if (var->value->unsigned_flag)
    var->save_result.ulonglong_value= (ulonglong) var->value->val_int();
  else
  {
    longlong v= var->value->val_int();
    var->save_result.ulonglong_value= (ulonglong) ((v < 0) ? 0 : v);
  }
  return 0;
}

1343

1344
sys_var_long_ptr::
unknown's avatar
unknown committed
1345
sys_var_long_ptr(sys_var_chain *chain, const char *name_arg, ulong *value_ptr_arg,
1346
                 sys_after_update_func after_update_arg)
unknown's avatar
unknown committed
1347
  :sys_var_long_ptr_global(chain, name_arg, value_ptr_arg,
1348 1349 1350 1351 1352
                           &LOCK_global_system_variables, after_update_arg)
{}


bool sys_var_long_ptr_global::check(THD *thd, set_var *var)
unknown's avatar
unknown committed
1353
{
1354
  return get_unsigned(thd, var);
unknown's avatar
unknown committed
1355
}
1356

1357
bool sys_var_long_ptr_global::update(THD *thd, set_var *var)
unknown's avatar
unknown committed
1358
{
1359
  ulonglong tmp= var->save_result.ulonglong_value;
1360
  pthread_mutex_lock(guard);
unknown's avatar
unknown committed
1361
  if (option_limits)
1362
    *value= (ulong) fix_unsigned(thd, tmp, option_limits);
unknown's avatar
unknown committed
1363
  else
1364 1365 1366
  {
#if SIZEOF_LONG < SIZEOF_LONG_LONG
    /* Avoid overflows on 32 bit systems */
1367
    if (tmp > ULONG_MAX)
1368
    {
1369
      tmp= ULONG_MAX;
1370 1371
      throw_bounds_warning(thd, TRUE, TRUE, name,
                           (longlong) var->save_result.ulonglong_value);
1372 1373
    }
#endif
unknown's avatar
unknown committed
1374
    *value= (ulong) tmp;
1375 1376
  }

1377
  pthread_mutex_unlock(guard);
unknown's avatar
unknown committed
1378 1379 1380 1381
  return 0;
}


1382
void sys_var_long_ptr_global::set_default(THD *thd, enum_var_type type)
unknown's avatar
unknown committed
1383
{
1384
  my_bool not_used;
1385
  pthread_mutex_lock(guard);
1386 1387
  *value= (ulong) getopt_ull_limit_value((ulong) option_limits->def_value,
                                         option_limits, &not_used);
1388
  pthread_mutex_unlock(guard);
unknown's avatar
unknown committed
1389 1390 1391
}


1392 1393
bool sys_var_ulonglong_ptr::update(THD *thd, set_var *var)
{
1394
  ulonglong tmp= var->save_result.ulonglong_value;
1395
  pthread_mutex_lock(&LOCK_global_system_variables);
1396
  if (option_limits)
1397
    *value= (ulonglong) fix_unsigned(thd, tmp, option_limits);
1398 1399
  else
    *value= (ulonglong) tmp;
1400
  pthread_mutex_unlock(&LOCK_global_system_variables);
1401 1402 1403 1404 1405 1406
  return 0;
}


void sys_var_ulonglong_ptr::set_default(THD *thd, enum_var_type type)
{
1407
  my_bool not_used;
1408
  pthread_mutex_lock(&LOCK_global_system_variables);
1409 1410
  *value= getopt_ull_limit_value((ulonglong) option_limits->def_value,
                                 option_limits, &not_used);
1411
  pthread_mutex_unlock(&LOCK_global_system_variables);
1412 1413 1414
}


unknown's avatar
unknown committed
1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427
bool sys_var_bool_ptr::update(THD *thd, set_var *var)
{
  *value= (my_bool) var->save_result.ulong_value;
  return 0;
}


void sys_var_bool_ptr::set_default(THD *thd, enum_var_type type)
{
  *value= (my_bool) option_limits->def_value;
}


1428 1429 1430 1431 1432 1433 1434
bool sys_var_enum::update(THD *thd, set_var *var)
{
  *value= (uint) var->save_result.ulong_value;
  return 0;
}


1435
uchar *sys_var_enum::value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
1436
{
1437
  return (uchar*) enum_names->type_names[*value];
1438 1439
}

1440 1441 1442 1443 1444 1445 1446

uchar *sys_var_enum_const::value_ptr(THD *thd, enum_var_type type,
                                     LEX_STRING *base)
{
  return (uchar*) enum_names->type_names[global_system_variables.*offset];
}

1447 1448
bool sys_var_thd_ulong::check(THD *thd, set_var *var)
{
1449
  return (get_unsigned(thd, var) ||
1450 1451
          (check_func && (*check_func)(thd, var)));
}
1452

unknown's avatar
unknown committed
1453 1454
bool sys_var_thd_ulong::update(THD *thd, set_var *var)
{
1455
  ulonglong tmp= var->save_result.ulonglong_value;
unknown's avatar
unknown committed
1456 1457 1458

  /* Don't use bigger value than given with --maximum-variable-name=.. */
  if ((ulong) tmp > max_system_variables.*offset)
1459
  {
1460
    throw_bounds_warning(thd, TRUE, TRUE, name, (longlong) tmp);
unknown's avatar
unknown committed
1461
    tmp= max_system_variables.*offset;
1462
  }
unknown's avatar
unknown committed
1463

1464 1465 1466
  if (option_limits)
    tmp= (ulong) fix_unsigned(thd, tmp, option_limits);
#if SIZEOF_LONG < SIZEOF_LONG_LONG
1467
  else if (tmp > ULONG_MAX)
1468
  {
1469
    tmp= ULONG_MAX;
1470
    throw_bounds_warning(thd, TRUE, TRUE, name, (longlong) var->save_result.ulonglong_value);
1471
  }
1472 1473
#endif

unknown's avatar
unknown committed
1474
  if (var->type == OPT_GLOBAL)
1475
    global_system_variables.*offset= (ulong) tmp;
unknown's avatar
unknown committed
1476 1477
  else
    thd->variables.*offset= (ulong) tmp;
1478

unknown's avatar
unknown committed
1479 1480 1481 1482 1483 1484 1485 1486
  return 0;
}


void sys_var_thd_ulong::set_default(THD *thd, enum_var_type type)
{
  if (type == OPT_GLOBAL)
  {
1487
    my_bool not_used;
unknown's avatar
unknown committed
1488
    /* We will not come here if option_limits is not set */
1489
    global_system_variables.*offset=
unknown's avatar
unknown committed
1490 1491
      (ulong) getopt_ull_limit_value((ulong) option_limits->def_value,
                                     option_limits, &not_used);
unknown's avatar
unknown committed
1492 1493 1494 1495 1496 1497
  }
  else
    thd->variables.*offset= global_system_variables.*offset;
}


1498
uchar *sys_var_thd_ulong::value_ptr(THD *thd, enum_var_type type,
1499
				   LEX_STRING *base)
unknown's avatar
unknown committed
1500 1501
{
  if (type == OPT_GLOBAL)
1502 1503
    return (uchar*) &(global_system_variables.*offset);
  return (uchar*) &(thd->variables.*offset);
unknown's avatar
unknown committed
1504 1505 1506
}


1507 1508
bool sys_var_thd_ha_rows::update(THD *thd, set_var *var)
{
1509
  ulonglong tmp= var->save_result.ulonglong_value;
1510 1511 1512 1513 1514 1515

  /* 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)
1516
    tmp= (ha_rows) fix_unsigned(thd, tmp, option_limits);
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
  if (var->type == OPT_GLOBAL)
  {
    /* Lock is needed to make things safe on 32 bit systems */
    pthread_mutex_lock(&LOCK_global_system_variables);    
    global_system_variables.*offset= (ha_rows) tmp;
    pthread_mutex_unlock(&LOCK_global_system_variables);
  }
  else
    thd->variables.*offset= (ha_rows) tmp;
  return 0;
}


void sys_var_thd_ha_rows::set_default(THD *thd, enum_var_type type)
{
  if (type == OPT_GLOBAL)
  {
1534
    my_bool not_used;
1535 1536
    /* We will not come here if option_limits is not set */
    pthread_mutex_lock(&LOCK_global_system_variables);
1537 1538 1539
    global_system_variables.*offset=
      (ha_rows) getopt_ull_limit_value((ha_rows) option_limits->def_value,
                                       option_limits, &not_used);
1540 1541 1542 1543 1544 1545 1546
    pthread_mutex_unlock(&LOCK_global_system_variables);
  }
  else
    thd->variables.*offset= global_system_variables.*offset;
}


1547
uchar *sys_var_thd_ha_rows::value_ptr(THD *thd, enum_var_type type,
1548
				     LEX_STRING *base)
1549 1550
{
  if (type == OPT_GLOBAL)
1551 1552
    return (uchar*) &(global_system_variables.*offset);
  return (uchar*) &(thd->variables.*offset);
1553 1554
}

1555 1556 1557 1558 1559
bool sys_var_thd_ulonglong::check(THD *thd, set_var *var)
{
  return get_unsigned(thd, var);
}

unknown's avatar
unknown committed
1560 1561
bool sys_var_thd_ulonglong::update(THD *thd,  set_var *var)
{
1562
  ulonglong tmp= var->save_result.ulonglong_value;
1563

1564
  if (tmp > max_system_variables.*offset)
1565 1566 1567
    tmp= max_system_variables.*offset;

  if (option_limits)
1568
    tmp= fix_unsigned(thd, tmp, option_limits);
unknown's avatar
unknown committed
1569
  if (var->type == OPT_GLOBAL)
1570 1571 1572
  {
    /* Lock is needed to make things safe on 32 bit systems */
    pthread_mutex_lock(&LOCK_global_system_variables);
1573
    global_system_variables.*offset= (ulonglong) tmp;
1574 1575
    pthread_mutex_unlock(&LOCK_global_system_variables);
  }
unknown's avatar
unknown committed
1576
  else
1577
    thd->variables.*offset= (ulonglong) tmp;
unknown's avatar
unknown committed
1578 1579 1580 1581 1582 1583 1584
  return 0;
}


void sys_var_thd_ulonglong::set_default(THD *thd, enum_var_type type)
{
  if (type == OPT_GLOBAL)
1585
  {
1586
    my_bool not_used;
1587
    pthread_mutex_lock(&LOCK_global_system_variables);
1588 1589 1590
    global_system_variables.*offset=
      getopt_ull_limit_value((ulonglong) option_limits->def_value,
                             option_limits, &not_used);
1591 1592
    pthread_mutex_unlock(&LOCK_global_system_variables);
  }
unknown's avatar
unknown committed
1593 1594 1595 1596 1597
  else
    thd->variables.*offset= global_system_variables.*offset;
}


1598
uchar *sys_var_thd_ulonglong::value_ptr(THD *thd, enum_var_type type,
1599
				       LEX_STRING *base)
unknown's avatar
unknown committed
1600 1601
{
  if (type == OPT_GLOBAL)
1602 1603
    return (uchar*) &(global_system_variables.*offset);
  return (uchar*) &(thd->variables.*offset);
unknown's avatar
unknown committed
1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
}


bool sys_var_thd_bool::update(THD *thd,  set_var *var)
{
  if (var->type == OPT_GLOBAL)
    global_system_variables.*offset= (my_bool) var->save_result.ulong_value;
  else
    thd->variables.*offset= (my_bool) var->save_result.ulong_value;
  return 0;
}


void sys_var_thd_bool::set_default(THD *thd,  enum_var_type type)
{
  if (type == OPT_GLOBAL)
    global_system_variables.*offset= (my_bool) option_limits->def_value;
  else
    thd->variables.*offset= global_system_variables.*offset;
}


1626
uchar *sys_var_thd_bool::value_ptr(THD *thd, enum_var_type type,
1627
				  LEX_STRING *base)
unknown's avatar
unknown committed
1628 1629
{
  if (type == OPT_GLOBAL)
1630 1631
    return (uchar*) &(global_system_variables.*offset);
  return (uchar*) &(thd->variables.*offset);
unknown's avatar
unknown committed
1632 1633 1634
}


1635
bool sys_var::check_enum(THD *thd, set_var *var, const TYPELIB *enum_names)
unknown's avatar
unknown committed
1636
{
unknown's avatar
unknown committed
1637
  char buff[STRING_BUFFER_USUAL_SIZE];
1638
  const char *value;
1639
  String str(buff, sizeof(buff), system_charset_info), *res;
unknown's avatar
unknown committed
1640 1641 1642 1643 1644

  if (var->value->result_type() == STRING_RESULT)
  {
    if (!(res=var->value->val_str(&str)) ||
	((long) (var->save_result.ulong_value=
1645 1646
		 (ulong) find_type(enum_names, res->ptr(),
				   res->length(),1)-1)) < 0)
unknown's avatar
unknown committed
1647
    {
1648
      value= res ? res->c_ptr() : "NULL";
unknown's avatar
unknown committed
1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665
      goto err;
    }
  }
  else
  {
    ulonglong tmp=var->value->val_int();
    if (tmp >= enum_names->count)
    {
      llstr(tmp,buff);
      value=buff;				// Wrong value is here
      goto err;
    }
    var->save_result.ulong_value= (ulong) tmp;	// Save for update
  }
  return 0;

err:
1666
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name, value);
unknown's avatar
unknown committed
1667 1668 1669
  return 1;
}

1670 1671 1672

bool sys_var::check_set(THD *thd, set_var *var, TYPELIB *enum_names)
{
1673
  bool not_used;
unknown's avatar
unknown committed
1674
  char buff[STRING_BUFFER_USUAL_SIZE], *error= 0;
1675 1676 1677 1678 1679 1680
  uint error_len= 0;
  String str(buff, sizeof(buff), system_charset_info), *res;

  if (var->value->result_type() == STRING_RESULT)
  {
    if (!(res= var->value->val_str(&str)))
1681
    {
unknown's avatar
unknown committed
1682
      strmov(buff, "NULL");
1683
      goto err;
1684
    }
1685 1686 1687 1688 1689 1690 1691 1692

    if (!m_allow_empty_value &&
        res->length() == 0)
    {
      buff[0]= 0;
      goto err;
    }

unknown's avatar
unknown committed
1693 1694
    var->save_result.ulong_value= ((ulong)
				   find_set(enum_names, res->c_ptr(),
1695 1696 1697
					    res->length(),
                                            NULL,
                                            &error, &error_len,
unknown's avatar
unknown committed
1698
					    &not_used));
1699 1700
    if (error_len)
    {
1701
      strmake(buff, error, min(sizeof(buff) - 1, error_len));
1702 1703 1704 1705 1706 1707
      goto err;
    }
  }
  else
  {
    ulonglong tmp= var->value->val_int();
1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720

    if (!m_allow_empty_value &&
        tmp == 0)
    {
      buff[0]= '0';
      buff[1]= 0;
      goto err;
    }

    /*
      For when the enum is made to contain 64 elements, as 1ULL<<64 is
      undefined, we guard with a "count<64" test.
    */
1721 1722
    if (unlikely((tmp >= ((ULL(1)) << enum_names->count)) &&
                 (enum_names->count < 64)))
1723 1724 1725 1726 1727 1728 1729 1730 1731
    {
      llstr(tmp, buff);
      goto err;
    }
    var->save_result.ulong_value= (ulong) tmp;  // Save for update
  }
  return 0;

err:
1732
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name, buff);
1733 1734 1735 1736
  return 1;
}


unknown's avatar
unknown committed
1737 1738 1739 1740 1741 1742
/**
  Return an Item for a variable.

  Used with @@[global.]variable_name.

  If type is not given, return local value if exists, else global.
unknown's avatar
unknown committed
1743 1744
*/

1745
Item *sys_var::item(THD *thd, enum_var_type var_type, LEX_STRING *base)
unknown's avatar
unknown committed
1746 1747 1748 1749 1750
{
  if (check_type(var_type))
  {
    if (var_type != OPT_DEFAULT)
    {
1751 1752
      my_error(ER_INCORRECT_GLOBAL_LOCAL_VAR, MYF(0),
               name, var_type == OPT_GLOBAL ? "SESSION" : "GLOBAL");
unknown's avatar
unknown committed
1753 1754 1755 1756 1757
      return 0;
    }
    /* As there was no local variable, return the global value */
    var_type= OPT_GLOBAL;
  }
1758
  switch (show_type()) {
1759 1760 1761 1762 1763 1764
  case SHOW_INT:
  {
    uint value;
    pthread_mutex_lock(&LOCK_global_system_variables);
    value= *(uint*) value_ptr(thd, var_type, base);
    pthread_mutex_unlock(&LOCK_global_system_variables);
1765
    return new Item_uint((ulonglong) value);
1766
  }
unknown's avatar
unknown committed
1767
  case SHOW_LONG:
1768 1769 1770 1771 1772
  {
    ulong value;
    pthread_mutex_lock(&LOCK_global_system_variables);
    value= *(ulong*) value_ptr(thd, var_type, base);
    pthread_mutex_unlock(&LOCK_global_system_variables);
1773
    return new Item_uint((ulonglong) value);
1774
  }
unknown's avatar
unknown committed
1775
  case SHOW_LONGLONG:
1776 1777 1778
  {
    longlong value;
    pthread_mutex_lock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
1779
    value= *(longlong*) value_ptr(thd, var_type, base);
1780 1781 1782
    pthread_mutex_unlock(&LOCK_global_system_variables);
    return new Item_int(value);
  }
1783 1784 1785 1786 1787 1788 1789 1790 1791
  case SHOW_DOUBLE:
  {
    double value;
    pthread_mutex_lock(&LOCK_global_system_variables);
    value= *(double*) value_ptr(thd, var_type, base);
    pthread_mutex_unlock(&LOCK_global_system_variables);
    /* 6, as this is for now only used with microseconds */
    return new Item_float(value, 6);
  }
1792
  case SHOW_HA_ROWS:
1793 1794 1795
  {
    ha_rows value;
    pthread_mutex_lock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
1796
    value= *(ha_rows*) value_ptr(thd, var_type, base);
1797
    pthread_mutex_unlock(&LOCK_global_system_variables);
1798
    return new Item_int((ulonglong) value);
1799
  }
unknown's avatar
unknown committed
1800
  case SHOW_MY_BOOL:
unknown's avatar
unknown committed
1801 1802 1803 1804 1805 1806 1807
  {
    int32 value;
    pthread_mutex_lock(&LOCK_global_system_variables);
    value= *(my_bool*) value_ptr(thd, var_type, base);
    pthread_mutex_unlock(&LOCK_global_system_variables);
    return new Item_int(value,1);
  }
unknown's avatar
unknown committed
1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826
  case SHOW_CHAR_PTR:
  {
    Item *tmp;
    pthread_mutex_lock(&LOCK_global_system_variables);
    char *str= *(char**) value_ptr(thd, var_type, base);
    if (str)
    {
      uint length= strlen(str);
      tmp= new Item_string(thd->strmake(str, length), length,
                           system_charset_info, DERIVATION_SYSCONST);
    }
    else
    {
      tmp= new Item_null();
      tmp->collation.set(system_charset_info, DERIVATION_SYSCONST);
    }
    pthread_mutex_unlock(&LOCK_global_system_variables);
    return tmp;
  }
unknown's avatar
unknown committed
1827 1828
  case SHOW_CHAR:
  {
unknown's avatar
unknown committed
1829
    Item *tmp;
1830
    pthread_mutex_lock(&LOCK_global_system_variables);
1831
    char *str= (char*) value_ptr(thd, var_type, base);
unknown's avatar
unknown committed
1832 1833 1834 1835 1836 1837 1838 1839
    if (str)
      tmp= new Item_string(str, strlen(str),
                           system_charset_info, DERIVATION_SYSCONST);
    else
    {
      tmp= new Item_null();
      tmp->collation.set(system_charset_info, DERIVATION_SYSCONST);
    }
1840 1841
    pthread_mutex_unlock(&LOCK_global_system_variables);
    return tmp;
unknown's avatar
unknown committed
1842 1843
  }
  default:
1844
    my_error(ER_VAR_CANT_BE_READ, MYF(0), name);
unknown's avatar
unknown committed
1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868
  }
  return 0;
}


bool sys_var_thd_enum::update(THD *thd, set_var *var)
{
  if (var->type == OPT_GLOBAL)
    global_system_variables.*offset= var->save_result.ulong_value;
  else
    thd->variables.*offset= var->save_result.ulong_value;
  return 0;
}


void sys_var_thd_enum::set_default(THD *thd, enum_var_type type)
{
  if (type == OPT_GLOBAL)
    global_system_variables.*offset= (ulong) option_limits->def_value;
  else
    thd->variables.*offset= global_system_variables.*offset;
}


1869
uchar *sys_var_thd_enum::value_ptr(THD *thd, enum_var_type type,
1870
				  LEX_STRING *base)
unknown's avatar
unknown committed
1871 1872 1873 1874
{
  ulong tmp= ((type == OPT_GLOBAL) ?
	      global_system_variables.*offset :
	      thd->variables.*offset);
1875
  return (uchar*) enum_names->type_names[tmp];
unknown's avatar
unknown committed
1876 1877
}

1878 1879 1880 1881 1882
bool sys_var_thd_bit::check(THD *thd, set_var *var)
{
  return (check_enum(thd, var, &bool_typelib) ||
          (check_func && (*check_func)(thd, var)));
}
unknown's avatar
unknown committed
1883 1884 1885

bool sys_var_thd_bit::update(THD *thd, set_var *var)
{
1886
  int res= (*update_func)(thd, var);
unknown's avatar
unknown committed
1887 1888 1889 1890
  return res;
}


1891
uchar *sys_var_thd_bit::value_ptr(THD *thd, enum_var_type type,
1892
				 LEX_STRING *base)
unknown's avatar
unknown committed
1893 1894 1895 1896 1897 1898 1899
{
  /*
    If reverse is 0 (default) return 1 if bit is set.
    If reverse is 1, return 0 if bit is set
  */
  thd->sys_var_tmp.my_bool_value= ((thd->options & bit_flag) ?
				   !reverse : reverse);
1900
  return (uchar*) &thd->sys_var_tmp.my_bool_value;
unknown's avatar
unknown committed
1901 1902 1903
}


unknown's avatar
unknown committed
1904
/** Update a date_time format variable based on given value. */
1905 1906 1907 1908 1909 1910

void sys_var_thd_date_time_format::update2(THD *thd, enum_var_type type,
					   DATE_TIME_FORMAT *new_value)
{
  DATE_TIME_FORMAT *old;
  DBUG_ENTER("sys_var_date_time_format::update2");
1911
  DBUG_DUMP("positions", (uchar*) new_value->positions,
1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945
	    sizeof(new_value->positions));

  if (type == OPT_GLOBAL)
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
    old= (global_system_variables.*offset);
    (global_system_variables.*offset)= new_value;
    pthread_mutex_unlock(&LOCK_global_system_variables);
  }
  else
  {
    old= (thd->variables.*offset);
    (thd->variables.*offset)= new_value;
  }
  my_free((char*) old, MYF(MY_ALLOW_ZERO_PTR));
  DBUG_VOID_RETURN;
}


bool sys_var_thd_date_time_format::update(THD *thd, set_var *var)
{
  DATE_TIME_FORMAT *new_value;
  /* We must make a copy of the last value to get it into normal memory */
  new_value= date_time_format_copy((THD*) 0,
				   var->save_result.date_time_format);
  if (!new_value)
    return 1;					// Out of memory
  update2(thd, var->type, new_value);		// Can't fail
  return 0;
}


bool sys_var_thd_date_time_format::check(THD *thd, set_var *var)
{
unknown's avatar
unknown committed
1946
  char buff[STRING_BUFFER_USUAL_SIZE];
1947 1948 1949 1950 1951 1952 1953 1954 1955
  String str(buff,sizeof(buff), system_charset_info), *res;
  DATE_TIME_FORMAT *format;

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

  if (!(format= date_time_format_make(date_time_type,
				      res->ptr(), res->length())))
  {
1956
    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name, res->c_ptr());
1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990
    return 1;
  }
  
  /*
    We must copy result to thread space to not get a memory leak if
    update is aborted
  */
  var->save_result.date_time_format= date_time_format_copy(thd, format);
  my_free((char*) format, MYF(0));
  return var->save_result.date_time_format == 0;
}


void sys_var_thd_date_time_format::set_default(THD *thd, enum_var_type type)
{
  DATE_TIME_FORMAT *res= 0;

  if (type == OPT_GLOBAL)
  {
    const char *format;
    if ((format= opt_date_time_formats[date_time_type]))
      res= date_time_format_make(date_time_type, format, strlen(format));
  }
  else
  {
    /* Make copy with malloc */
    res= date_time_format_copy((THD *) 0, global_system_variables.*offset);
  }

  if (res)					// Should always be true
    update2(thd, type, res);
}


1991
uchar *sys_var_thd_date_time_format::value_ptr(THD *thd, enum_var_type type,
1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003
					      LEX_STRING *base)
{
  if (type == OPT_GLOBAL)
  {
    char *res;
    /*
      We do a copy here just to be sure things will work even if someone
      is modifying the original string while the copy is accessed
      (Can't happen now in SQL SHOW, but this is a good safety for the future)
    */
    res= thd->strmake((global_system_variables.*offset)->format.str,
		      (global_system_variables.*offset)->format.length);
2004
    return (uchar*) res;
2005
  }
2006
  return (uchar*) (thd->variables.*offset)->format.str;
2007 2008 2009
}


2010 2011
typedef struct old_names_map_st
{
unknown's avatar
unknown committed
2012 2013 2014
  const char *old_name;
  const char *new_name;
} my_old_conv;
unknown's avatar
unknown committed
2015

unknown's avatar
unknown committed
2016 2017
static my_old_conv old_conv[]= 
{
2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028
  {	"cp1251_koi8"		,	"cp1251"	},
  {	"cp1250_latin2"		,	"cp1250"	},
  {	"kam_latin2"		,	"keybcs2"	},
  {	"mac_latin2"		,	"MacRoman"	},
  {	"macce_latin2"		,	"MacCE"		},
  {	"pc2_latin2"		,	"pclatin2"	},
  {	"vga_latin2"		,	"pclatin1"	},
  {	"koi8_cp1251"		,	"koi8r"		},
  {	"win1251ukr_koi8_ukr"	,	"win1251ukr"	},
  {	"koi8_ukr_win1251ukr"	,	"koi8u"		},
  {	NULL			,	NULL		}
unknown's avatar
unknown committed
2029
};
unknown's avatar
unknown committed
2030

unknown's avatar
unknown committed
2031
CHARSET_INFO *get_old_charset_by_name(const char *name)
unknown's avatar
unknown committed
2032
{
unknown's avatar
unknown committed
2033
  my_old_conv *conv;
unknown's avatar
unknown committed
2034
 
unknown's avatar
unknown committed
2035
  for (conv= old_conv; conv->old_name; conv++)
2036
  {
unknown's avatar
unknown committed
2037 2038
    if (!my_strcasecmp(&my_charset_latin1, name, conv->old_name))
      return get_charset_by_csname(conv->new_name, MY_CS_PRIMARY, MYF(0));
2039
  }
unknown's avatar
unknown committed
2040
  return NULL;
unknown's avatar
unknown committed
2041 2042
}

unknown's avatar
unknown committed
2043

2044
bool sys_var_collation::check(THD *thd, set_var *var)
unknown's avatar
unknown committed
2045 2046
{
  CHARSET_INFO *tmp;
2047
  LINT_INIT(tmp);
unknown's avatar
unknown committed
2048

2049
  if (var->value->result_type() == STRING_RESULT)
2050
  {
unknown's avatar
unknown committed
2051
    char buff[STRING_BUFFER_USUAL_SIZE];
2052 2053 2054
    String str(buff,sizeof(buff), system_charset_info), *res;
    if (!(res=var->value->val_str(&str)))
    {
2055
      my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name, "NULL");
2056 2057 2058 2059
      return 1;
    }
    if (!(tmp=get_charset_by_name(res->c_ptr(),MYF(0))))
    {
2060
      my_error(ER_UNKNOWN_COLLATION, MYF(0), res->c_ptr());
2061 2062
      return 1;
    }
2063
  }
2064
  else // INT_RESULT
2065
  {
2066
    if (!(tmp=get_charset((int) var->value->val_int(),MYF(0))))
2067 2068
    {
      char buf[20];
2069
      int10_to_str((int) var->value->val_int(), buf, -10);
2070
      my_error(ER_UNKNOWN_COLLATION, MYF(0), buf);
2071 2072
      return 1;
    }
2073 2074 2075 2076 2077
  }
  var->save_result.charset= tmp;	// Save for update
  return 0;
}

2078

2079 2080 2081
bool sys_var_character_set::check(THD *thd, set_var *var)
{
  CHARSET_INFO *tmp;
2082
  LINT_INIT(tmp);
2083

2084 2085
  if (var->value->result_type() == STRING_RESULT)
  {
unknown's avatar
unknown committed
2086
    char buff[STRING_BUFFER_USUAL_SIZE];
2087 2088
    String str(buff,sizeof(buff), system_charset_info), *res;
    if (!(res=var->value->val_str(&str)))
2089
    {
2090 2091
      if (!nullable)
      {
2092
        my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name, "NULL");
2093 2094 2095 2096 2097 2098 2099
        return 1;
      }
      tmp= NULL;
    }
    else if (!(tmp=get_charset_by_csname(res->c_ptr(),MY_CS_PRIMARY,MYF(0))) &&
             !(tmp=get_old_charset_by_name(res->c_ptr())))
    {
2100
      my_error(ER_UNKNOWN_CHARACTER_SET, MYF(0), res->c_ptr());
2101 2102 2103
      return 1;
    }
  }
2104
  else // INT_RESULT
unknown's avatar
unknown committed
2105
  {
2106
    if (!(tmp=get_charset((int) var->value->val_int(),MYF(0))))
2107 2108
    {
      char buf[20];
2109
      int10_to_str((int) var->value->val_int(), buf, -10);
2110 2111 2112
      my_error(ER_UNKNOWN_CHARACTER_SET, MYF(0), buf);
      return 1;
    }
unknown's avatar
unknown committed
2113 2114 2115 2116 2117
  }
  var->save_result.charset= tmp;	// Save for update
  return 0;
}

2118

2119
bool sys_var_character_set::update(THD *thd, set_var *var)
unknown's avatar
unknown committed
2120
{
2121
  ci_ptr(thd,var->type)[0]= var->save_result.charset;
unknown's avatar
unknown committed
2122
  thd->update_charset();
unknown's avatar
unknown committed
2123 2124 2125
  return 0;
}

2126

2127
uchar *sys_var_character_set::value_ptr(THD *thd, enum_var_type type,
2128
				       LEX_STRING *base)
unknown's avatar
unknown committed
2129
{
2130
  CHARSET_INFO *cs= ci_ptr(thd,type)[0];
2131
  return cs ? (uchar*) cs->csname : (uchar*) NULL;
unknown's avatar
unknown committed
2132 2133 2134
}


unknown's avatar
unknown committed
2135
void sys_var_character_set_sv::set_default(THD *thd, enum_var_type type)
2136
{
2137
  if (type == OPT_GLOBAL)
unknown's avatar
unknown committed
2138
    global_system_variables.*offset= *global_default;
2139
  else
unknown's avatar
unknown committed
2140 2141 2142 2143
  {
    thd->variables.*offset= global_system_variables.*offset;
    thd->update_charset();
  }
2144
}
unknown's avatar
unknown committed
2145
CHARSET_INFO **sys_var_character_set_sv::ci_ptr(THD *thd, enum_var_type type)
2146 2147
{
  if (type == OPT_GLOBAL)
unknown's avatar
unknown committed
2148
    return &(global_system_variables.*offset);
2149
  else
unknown's avatar
unknown committed
2150
    return &(thd->variables.*offset);
2151 2152
}

2153

2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168
bool sys_var_character_set_client::check(THD *thd, set_var *var)
{
  if (sys_var_character_set_sv::check(thd, var))
    return 1;
  /* Currently, UCS-2 cannot be used as a client character set */
  if (var->save_result.charset->mbminlen > 1)
  {
    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name, 
             var->save_result.charset->csname);
    return 1;
  }
  return 0;
}


2169 2170
CHARSET_INFO ** sys_var_character_set_database::ci_ptr(THD *thd,
						       enum_var_type type)
2171 2172
{
  if (type == OPT_GLOBAL)
2173
    return &global_system_variables.collation_database;
2174
  else
2175
    return &thd->variables.collation_database;
2176 2177
}

2178

2179 2180 2181
void sys_var_character_set_database::set_default(THD *thd, enum_var_type type)
{
 if (type == OPT_GLOBAL)
2182
    global_system_variables.collation_database= default_charset_info;
2183
  else
unknown's avatar
unknown committed
2184
  {
2185
    thd->variables.collation_database= thd->db_charset;
unknown's avatar
unknown committed
2186 2187
    thd->update_charset();
  }
2188 2189
}

2190

unknown's avatar
unknown committed
2191
bool sys_var_collation_sv::update(THD *thd, set_var *var)
2192 2193
{
  if (var->type == OPT_GLOBAL)
unknown's avatar
unknown committed
2194
    global_system_variables.*offset= var->save_result.charset;
2195
  else
unknown's avatar
unknown committed
2196
  {
unknown's avatar
unknown committed
2197
    thd->variables.*offset= var->save_result.charset;
unknown's avatar
unknown committed
2198 2199
    thd->update_charset();
  }
2200 2201 2202
  return 0;
}

2203

unknown's avatar
unknown committed
2204
void sys_var_collation_sv::set_default(THD *thd, enum_var_type type)
2205
{
unknown's avatar
unknown committed
2206 2207
  if (type == OPT_GLOBAL)
    global_system_variables.*offset= *global_default;
2208 2209
  else
  {
unknown's avatar
unknown committed
2210
    thd->variables.*offset= global_system_variables.*offset;
2211 2212 2213 2214 2215
    thd->update_charset();
  }
}


2216
uchar *sys_var_collation_sv::value_ptr(THD *thd, enum_var_type type,
2217
                                       LEX_STRING *base)
2218 2219
{
  CHARSET_INFO *cs= ((type == OPT_GLOBAL) ?
2220
		     global_system_variables.*offset : thd->variables.*offset);
2221
  return cs ? (uchar*) cs->name : (uchar*) "NULL";
2222 2223
}

2224

2225
LEX_STRING default_key_cache_base= {(char *) "default", 7 };
unknown's avatar
unknown committed
2226

unknown's avatar
unknown committed
2227
static KEY_CACHE zero_key_cache;
unknown's avatar
unknown committed
2228

unknown's avatar
unknown committed
2229
KEY_CACHE *get_key_cache(LEX_STRING *cache_name)
unknown's avatar
unknown committed
2230
{
2231 2232
  safe_mutex_assert_owner(&LOCK_global_system_variables);
  if (!cache_name || ! cache_name->length)
unknown's avatar
unknown committed
2233
    cache_name= &default_key_cache_base;
unknown's avatar
unknown committed
2234
  return ((KEY_CACHE*) find_named(&key_caches,
2235
                                      cache_name->str, cache_name->length, 0));
unknown's avatar
unknown committed
2236 2237
}

2238

2239
uchar *sys_var_key_cache_param::value_ptr(THD *thd, enum_var_type type,
unknown's avatar
unknown committed
2240
					 LEX_STRING *base)
2241
{
unknown's avatar
unknown committed
2242
  KEY_CACHE *key_cache= get_key_cache(base);
unknown's avatar
unknown committed
2243 2244
  if (!key_cache)
    key_cache= &zero_key_cache;
2245
  return (uchar*) key_cache + offset ;
unknown's avatar
unknown committed
2246
}
2247

2248

2249 2250
bool sys_var_key_buffer_size::update(THD *thd, set_var *var)
{
2251
  ulonglong tmp= var->save_result.ulonglong_value;
unknown's avatar
unknown committed
2252
  LEX_STRING *base_name= &var->base;
unknown's avatar
unknown committed
2253
  KEY_CACHE *key_cache;
2254 2255 2256
  bool error= 0;

  /* If no basename, assume it's for the key cache named 'default' */
unknown's avatar
unknown committed
2257
  if (!base_name->length)
2258
    base_name= &default_key_cache_base;
2259 2260 2261

  pthread_mutex_lock(&LOCK_global_system_variables);
  key_cache= get_key_cache(base_name);
unknown's avatar
unknown committed
2262
                            
2263 2264
  if (!key_cache)
  {
2265
    /* Key cache didn't exists */
2266
    if (!tmp)					// Tried to delete cache
2267 2268 2269 2270 2271 2272
      goto end;					// Ok, nothing to do
    if (!(key_cache= create_key_cache(base_name->str, base_name->length)))
    {
      error= 1;
      goto end;
    }
2273
  }
2274 2275 2276 2277 2278 2279 2280 2281 2282

  /*
    Abort if some other thread is changing the key cache
    TODO: This should be changed so that we wait until the previous
    assignment is done and then do the new assign
  */
  if (key_cache->in_init)
    goto end;

unknown's avatar
unknown committed
2283
  if (!tmp)					// Zero size means delete
2284
  {
unknown's avatar
unknown committed
2285
    if (key_cache == dflt_key_cache)
2286 2287 2288 2289
    {
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                          ER_WARN_CANT_DROP_DEFAULT_KEYCACHE,
                          ER(ER_WARN_CANT_DROP_DEFAULT_KEYCACHE));
2290
      goto end;					// Ignore default key cache
2291
    }
2292

unknown's avatar
unknown committed
2293
    if (key_cache->key_cache_inited)		// If initied
2294 2295
    {
      /*
2296 2297
	Move tables using this key cache to the default key cache
	and clear the old key cache.
2298
      */
2299
      NAMED_LIST *list; 
unknown's avatar
unknown committed
2300
      key_cache= (KEY_CACHE *) find_named(&key_caches, base_name->str,
2301
					      base_name->length, &list);
2302 2303
      key_cache->in_init= 1;
      pthread_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
2304
      error= reassign_keycache_tables(thd, key_cache, dflt_key_cache);
2305 2306
      pthread_mutex_lock(&LOCK_global_system_variables);
      key_cache->in_init= 0;
2307
    }
2308 2309 2310 2311 2312
    /*
      We don't delete the key cache as some running threads my still be
      in the key cache code with a pointer to the deleted (empty) key cache
    */
    goto end;
2313 2314
  }

unknown's avatar
unknown committed
2315
  key_cache->param_buff_size=
2316
    (ulonglong) fix_unsigned(thd, tmp, option_limits);
2317

2318 2319 2320 2321
  /* If key cache didn't existed initialize it, else resize it */
  key_cache->in_init= 1;
  pthread_mutex_unlock(&LOCK_global_system_variables);

unknown's avatar
unknown committed
2322
  if (!key_cache->key_cache_inited)
2323
    error= (bool) (ha_init_key_cache("", key_cache));
unknown's avatar
unknown committed
2324
  else
2325
    error= (bool)(ha_resize_key_cache(key_cache));
2326

2327 2328
  pthread_mutex_lock(&LOCK_global_system_variables);
  key_cache->in_init= 0;  
2329

2330 2331 2332
end:
  pthread_mutex_unlock(&LOCK_global_system_variables);
  return error;
2333 2334
}

2335

unknown's avatar
unknown committed
2336 2337 2338 2339 2340 2341
/**
  @todo
  Abort if some other thread is changing the key cache.
  This should be changed so that we wait until the previous
  assignment is done and then do the new assign
*/
2342
bool sys_var_key_cache_long::update(THD *thd, set_var *var)
2343
{
unknown's avatar
unknown committed
2344
  ulong tmp= (ulong) var->value->val_int();
2345
  LEX_STRING *base_name= &var->base;
2346 2347
  bool error= 0;

2348
  if (!base_name->length)
unknown's avatar
unknown committed
2349
    base_name= &default_key_cache_base;
2350 2351

  pthread_mutex_lock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
2352
  KEY_CACHE *key_cache= get_key_cache(base_name);
2353

unknown's avatar
unknown committed
2354 2355
  if (!key_cache && !(key_cache= create_key_cache(base_name->str,
				                  base_name->length)))
2356 2357 2358 2359
  {
    error= 1;
    goto end;
  }
2360

2361 2362 2363 2364 2365 2366 2367 2368 2369
  /*
    Abort if some other thread is changing the key cache
    TODO: This should be changed so that we wait until the previous
    assignment is done and then do the new assign
  */
  if (key_cache->in_init)
    goto end;

  *((ulong*) (((char*) key_cache) + offset))=
2370
    (ulong) fix_unsigned(thd, tmp, option_limits);
unknown's avatar
unknown committed
2371

2372 2373 2374 2375 2376
  /*
    Don't create a new key cache if it didn't exist
    (key_caches are created only when the user sets block_size)
  */
  key_cache->in_init= 1;
2377

2378
  pthread_mutex_unlock(&LOCK_global_system_variables);
2379

2380 2381 2382 2383 2384 2385 2386 2387
  error= (bool) (ha_resize_key_cache(key_cache));

  pthread_mutex_lock(&LOCK_global_system_variables);
  key_cache->in_init= 0;  

end:
  pthread_mutex_unlock(&LOCK_global_system_variables);
  return error;
2388 2389
}

2390

2391 2392
bool sys_var_log_state::update(THD *thd, set_var *var)
{
2393
  bool res;
2394 2395 2396 2397 2398 2399

  if (this == &sys_var_log)
    WARN_DEPRECATED(thd, "7.0", "@@log", "'@@general_log'");
  else if (this == &sys_var_log_slow)
    WARN_DEPRECATED(thd, "7.0", "@@log_slow_queries", "'@@slow_query_log'");

2400 2401 2402
  pthread_mutex_lock(&LOCK_global_system_variables);
  if (!var->save_result.ulong_value)
  {
2403 2404
    logger.deactivate_log_handler(thd, log_type);
    res= false;
2405
  }
2406 2407
  else
    res= logger.activate_log_handler(thd, log_type);
2408 2409 2410 2411 2412 2413
  pthread_mutex_unlock(&LOCK_global_system_variables);
  return res;
}

void sys_var_log_state::set_default(THD *thd, enum_var_type type)
{
2414 2415 2416 2417 2418
  if (this == &sys_var_log)
    WARN_DEPRECATED(thd, "7.0", "@@log", "'@@general_log'");
  else if (this == &sys_var_log_slow)
    WARN_DEPRECATED(thd, "7.0", "@@log_slow_queries", "'@@slow_query_log'");

2419 2420 2421 2422 2423 2424 2425 2426
  pthread_mutex_lock(&LOCK_global_system_variables);
  logger.deactivate_log_handler(thd, log_type);
  pthread_mutex_unlock(&LOCK_global_system_variables);
}


static int  sys_check_log_path(THD *thd,  set_var *var)
{
2427
  char path[FN_REFLEN], buff[FN_REFLEN];
2428
  MY_STAT f_stat;
2429 2430
  String str(buff, sizeof(buff), system_charset_info), *res;
  const char *log_file_str;
2431 2432
  size_t path_length;

2433 2434 2435 2436
  if (!(res= var->value->val_str(&str)))
    goto err;

  log_file_str= res->c_ptr();
2437 2438
  bzero(&f_stat, sizeof(MY_STAT));

2439 2440 2441
  path_length= unpack_filename(path, log_file_str);

  if (!path_length)
2442
  {
2443 2444 2445
    /* File name is empty. */

    goto err;
2446
  }
2447 2448

  if (my_stat(path, &f_stat, MYF(0)))
2449 2450
  {
    /*
2451 2452
      A file system object exists. Check if argument is a file and we have
      'write' permission.
2453
    */
2454 2455 2456

    if (!MY_S_ISREG(f_stat.st_mode) ||
        !(f_stat.st_mode & MY_S_IWRITE))
2457
      goto err;
2458 2459

    return 0;
2460
  }
2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475

  /* Get dirname of the file path. */
  (void) dirname_part(path, log_file_str, &path_length);

  /* Dirname is empty if file path is relative. */
  if (!path_length)
    return 0;

  /*
    Check if directory exists and we have permission to create file and
    write to file.
  */
  if (my_access(path, (F_OK|W_OK)))
    goto err;

2476
  return 0;
2477 2478 2479 2480 2481

err:
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->var->name, 
           res ? log_file_str : "NULL");
  return 1;
2482 2483 2484 2485 2486 2487 2488
}


bool update_sys_var_str_path(THD *thd, sys_var_str *var_str,
			     set_var *var, const char *log_ext,
			     bool log_state, uint log_type)
{
unknown's avatar
unknown committed
2489
  MYSQL_QUERY_LOG *file_log;
2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502
  char buff[FN_REFLEN];
  char *res= 0, *old_value=(char *)(var ? var->value->str_value.ptr() : 0);
  bool result= 0;
  uint str_length= (var ? var->value->str_value.length() : 0);

  switch (log_type) {
  case QUERY_LOG_SLOW:
    file_log= logger.get_slow_log_file_handler();
    break;
  case QUERY_LOG_GENERAL:
    file_log= logger.get_log_file_handler();
    break;
  default:
unknown's avatar
unknown committed
2503
    assert(0);                                  // Impossible
2504 2505 2506 2507 2508 2509 2510
  }

  if (!old_value)
  {
    old_value= make_default_log_name(buff, log_ext);
    str_length= strlen(old_value);
  }
2511
  if (!(res= my_strndup(old_value, str_length, MYF(MY_FAE+MY_WME))))
2512 2513 2514 2515 2516 2517
  {
    result= 1;
    goto err;
  }

  pthread_mutex_lock(&LOCK_global_system_variables);
2518
  logger.lock_exclusive();
2519 2520 2521 2522 2523 2524 2525 2526

  if (file_log && log_state)
    file_log->close(0);
  old_value= var_str->value;
  var_str->value= res;
  var_str->value_length= str_length;
  my_free(old_value, MYF(MY_ALLOW_ZERO_PTR));
  if (file_log && log_state)
unknown's avatar
unknown committed
2527 2528 2529
  {
    switch (log_type) {
    case QUERY_LOG_SLOW:
2530
      file_log->open_slow_log(sys_var_slow_log_path.value);
unknown's avatar
unknown committed
2531 2532 2533 2534 2535 2536 2537 2538
      break;
    case QUERY_LOG_GENERAL:
      file_log->open_query_log(sys_var_general_log_path.value);
      break;
    default:
      DBUG_ASSERT(0);
    }
  }
2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580

  logger.unlock();
  pthread_mutex_unlock(&LOCK_global_system_variables);

err:
  return result;
}


static bool sys_update_general_log_path(THD *thd, set_var * var)
{
  return update_sys_var_str_path(thd, &sys_var_general_log_path, 
				 var, ".log", opt_log, QUERY_LOG_GENERAL);
}


static void sys_default_general_log_path(THD *thd, enum_var_type type)
{
  (void) update_sys_var_str_path(thd, &sys_var_general_log_path,
				 0, ".log", opt_log, QUERY_LOG_GENERAL);
}


static bool sys_update_slow_log_path(THD *thd, set_var * var)
{
  return update_sys_var_str_path(thd, &sys_var_slow_log_path,
				 var, "-slow.log", opt_slow_log,
                                 QUERY_LOG_SLOW);
}


static void sys_default_slow_log_path(THD *thd, enum_var_type type)
{
  (void) update_sys_var_str_path(thd, &sys_var_slow_log_path,
				 0, "-slow.log", opt_slow_log,
                                 QUERY_LOG_SLOW);
}


bool sys_var_log_output::update(THD *thd, set_var *var)
{
  pthread_mutex_lock(&LOCK_global_system_variables);
2581
  logger.lock_exclusive();
2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593
  logger.init_slow_log(var->save_result.ulong_value);
  logger.init_general_log(var->save_result.ulong_value);
  *value= var->save_result.ulong_value;
  logger.unlock();
  pthread_mutex_unlock(&LOCK_global_system_variables);
  return 0;
}


void sys_var_log_output::set_default(THD *thd, enum_var_type type)
{
  pthread_mutex_lock(&LOCK_global_system_variables);
2594 2595 2596 2597
  logger.lock_exclusive();
  logger.init_slow_log(LOG_FILE);
  logger.init_general_log(LOG_FILE);
  *value= LOG_FILE;
2598 2599 2600 2601 2602
  logger.unlock();
  pthread_mutex_unlock(&LOCK_global_system_variables);
}


2603
uchar *sys_var_log_output::value_ptr(THD *thd, enum_var_type type,
unknown's avatar
unknown committed
2604
                                    LEX_STRING *base)
2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623
{
  char buff[256];
  String tmp(buff, sizeof(buff), &my_charset_latin1);
  ulong length;
  ulong val= *value;

  tmp.length(0);
  for (uint i= 0; val; val>>= 1, i++)
  {
    if (val & 1)
    {
      tmp.append(log_output_typelib.type_names[i],
                 log_output_typelib.type_lengths[i]);
      tmp.append(',');
    }
  }

  if ((length= tmp.length()))
    length--;
2624
  return (uchar*) thd->strmake(tmp.ptr(), length);
2625 2626 2627
}


2628 2629 2630 2631
/*****************************************************************************
  Functions to handle SET NAMES and SET CHARACTER SET
*****************************************************************************/

unknown's avatar
unknown committed
2632
int set_var_collation_client::check(THD *thd)
2633
{
2634 2635 2636 2637 2638 2639 2640
  /* Currently, UCS-2 cannot be used as a client character set */
  if (character_set_client->mbminlen > 1)
  {
    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "character_set_client",
             character_set_client->csname);
    return 1;
  }
2641 2642 2643
  return 0;
}

unknown's avatar
unknown committed
2644
int set_var_collation_client::update(THD *thd)
2645
{
2646 2647
  thd->variables.character_set_client= character_set_client;
  thd->variables.character_set_results= character_set_results;
unknown's avatar
unknown committed
2648
  thd->variables.collation_connection= collation_connection;
unknown's avatar
unknown committed
2649
  thd->update_charset();
unknown's avatar
unknown committed
2650 2651
  thd->protocol_text.init(thd);
  thd->protocol_binary.init(thd);
2652 2653 2654 2655 2656
  return 0;
}

/****************************************************************************/

unknown's avatar
unknown committed
2657 2658
bool sys_var_timestamp::update(THD *thd,  set_var *var)
{
2659
  thd->set_time((time_t) var->save_result.ulonglong_value);
unknown's avatar
unknown committed
2660 2661 2662 2663 2664 2665 2666 2667 2668 2669
  return 0;
}


void sys_var_timestamp::set_default(THD *thd, enum_var_type type)
{
  thd->user_time=0;
}


2670
uchar *sys_var_timestamp::value_ptr(THD *thd, enum_var_type type,
2671
				   LEX_STRING *base)
unknown's avatar
unknown committed
2672 2673
{
  thd->sys_var_tmp.long_value= (long) thd->start_time;
2674
  return (uchar*) &thd->sys_var_tmp.long_value;
unknown's avatar
unknown committed
2675 2676 2677 2678 2679
}


bool sys_var_last_insert_id::update(THD *thd, set_var *var)
{
2680 2681
  thd->first_successful_insert_id_in_prev_stmt= 
    var->save_result.ulonglong_value;
unknown's avatar
unknown committed
2682 2683 2684 2685
  return 0;
}


2686
uchar *sys_var_last_insert_id::value_ptr(THD *thd, enum_var_type type,
2687
					LEX_STRING *base)
unknown's avatar
unknown committed
2688
{
2689 2690 2691 2692 2693 2694
  /*
    this tmp var makes it robust againt change of type of 
    read_first_successful_insert_id_in_prev_stmt().
  */
  thd->sys_var_tmp.ulonglong_value= 
    thd->read_first_successful_insert_id_in_prev_stmt();
2695
  return (uchar*) &thd->sys_var_tmp.ulonglong_value;
unknown's avatar
unknown committed
2696 2697 2698 2699 2700
}


bool sys_var_insert_id::update(THD *thd, set_var *var)
{
2701
  thd->force_one_auto_inc_interval(var->save_result.ulonglong_value);
unknown's avatar
unknown committed
2702 2703 2704 2705
  return 0;
}


2706
uchar *sys_var_insert_id::value_ptr(THD *thd, enum_var_type type,
2707
				   LEX_STRING *base)
unknown's avatar
unknown committed
2708
{
2709 2710
  thd->sys_var_tmp.ulonglong_value= 
    thd->auto_inc_intervals_forced.minimum();
2711
  return (uchar*) &thd->sys_var_tmp.ulonglong_value;
unknown's avatar
unknown committed
2712
}
2713 2714


2715 2716
bool sys_var_rand_seed1::update(THD *thd, set_var *var)
{
2717
  thd->rand.seed1= (ulong) var->save_result.ulonglong_value;
2718 2719 2720 2721 2722
  return 0;
}

bool sys_var_rand_seed2::update(THD *thd, set_var *var)
{
2723
  thd->rand.seed2= (ulong) var->save_result.ulonglong_value;
2724 2725 2726 2727
  return 0;
}


2728 2729
bool sys_var_thd_time_zone::check(THD *thd, set_var *var)
{
2730
  char buff[MAX_TIME_ZONE_NAME_LENGTH];
2731 2732 2733
  String str(buff, sizeof(buff), &my_charset_latin1);
  String *res= var->value->val_str(&str);

2734
  if (!(var->save_result.time_zone= my_tz_find(thd, res)))
2735
  {
2736
    my_error(ER_UNKNOWN_TIME_ZONE, MYF(0), res ? res->c_ptr() : "NULL");
2737 2738 2739 2740 2741 2742 2743 2744
    return 1;
  }
  return 0;
}


bool sys_var_thd_time_zone::update(THD *thd, set_var *var)
{
2745 2746 2747 2748 2749 2750 2751 2752 2753
  /* We are using Time_zone object found during check() phase. */
  if (var->type == OPT_GLOBAL)
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
    global_system_variables.time_zone= var->save_result.time_zone;
    pthread_mutex_unlock(&LOCK_global_system_variables);
  }
  else
    thd->variables.time_zone= var->save_result.time_zone;
2754 2755 2756 2757
  return 0;
}


2758
uchar *sys_var_thd_time_zone::value_ptr(THD *thd, enum_var_type type,
2759 2760 2761 2762 2763 2764 2765
				       LEX_STRING *base)
{
  /* 
    We can use ptr() instead of c_ptr() here because String contaning
    time zone name is guaranteed to be zero ended.
  */
  if (type == OPT_GLOBAL)
2766
    return (uchar *)(global_system_variables.time_zone->get_name()->ptr());
2767
  else
2768 2769 2770 2771 2772 2773 2774 2775 2776 2777
  {
    /*
      This is an ugly fix for replication: we don't replicate properly queries
      invoking system variables' values to update tables; but
      CONVERT_TZ(,,@@session.time_zone) is so popular that we make it
      replicable (i.e. we tell the binlog code to store the session
      timezone). If it's the global value which was used we can't replicate
      (binlog code stores session value only).
    */
    thd->time_zone_used= 1;
2778
    return (uchar *)(thd->variables.time_zone->get_name()->ptr());
2779
  }
2780 2781 2782 2783 2784
}


void sys_var_thd_time_zone::set_default(THD *thd, enum_var_type type)
{
2785
 pthread_mutex_lock(&LOCK_global_system_variables);
2786 2787 2788 2789 2790
 if (type == OPT_GLOBAL)
 {
   if (default_tz_name)
   {
     String str(default_tz_name, &my_charset_latin1);
2791 2792 2793 2794
     /*
       We are guaranteed to find this time zone since its existence
       is checked during start-up.
     */
2795
     global_system_variables.time_zone= my_tz_find(thd, &str);
2796 2797 2798 2799 2800 2801
   }
   else
     global_system_variables.time_zone= my_tz_SYSTEM;
 }
 else
   thd->variables.time_zone= global_system_variables.time_zone;
2802
 pthread_mutex_unlock(&LOCK_global_system_variables);
2803 2804
}

2805 2806 2807 2808 2809 2810 2811 2812 2813

bool sys_var_max_user_conn::check(THD *thd, set_var *var)
{
  if (var->type == OPT_GLOBAL)
    return sys_var_thd::check(thd, var);
  else
  {
    /*
      Per-session values of max_user_connections can't be set directly.
2814
      May be we should have a separate error message for this?
2815 2816 2817 2818 2819 2820 2821 2822 2823 2824
    */
    my_error(ER_GLOBAL_VARIABLE, MYF(0), name);
    return TRUE;
  }
}

bool sys_var_max_user_conn::update(THD *thd, set_var *var)
{
  DBUG_ASSERT(var->type == OPT_GLOBAL);
  pthread_mutex_lock(&LOCK_global_system_variables);
2825
  max_user_connections= (uint)var->save_result.ulonglong_value;
2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839
  pthread_mutex_unlock(&LOCK_global_system_variables);
  return 0;
}


void sys_var_max_user_conn::set_default(THD *thd, enum_var_type type)
{
  DBUG_ASSERT(type == OPT_GLOBAL);
  pthread_mutex_lock(&LOCK_global_system_variables);
  max_user_connections= (ulong) option_limits->def_value;
  pthread_mutex_unlock(&LOCK_global_system_variables);
}


2840
uchar *sys_var_max_user_conn::value_ptr(THD *thd, enum_var_type type,
2841 2842 2843 2844
                                       LEX_STRING *base)
{
  if (type != OPT_GLOBAL &&
      thd->user_connect && thd->user_connect->user_resources.user_conn)
2845 2846
    return (uchar*) &(thd->user_connect->user_resources.user_conn);
  return (uchar*) &(max_user_connections);
2847 2848
}

2849

unknown's avatar
unknown committed
2850 2851
bool sys_var_thd_lc_time_names::check(THD *thd, set_var *var)
{
2852
  MY_LOCALE *locale_match;
unknown's avatar
unknown committed
2853

2854
  if (var->value->result_type() == INT_RESULT)
unknown's avatar
unknown committed
2855
  {
2856 2857 2858 2859 2860 2861 2862
    if (!(locale_match= my_locale_by_number((uint) var->value->val_int())))
    {
      char buf[20];
      int10_to_str((int) var->value->val_int(), buf, -10);
      my_printf_error(ER_UNKNOWN_ERROR, "Unknown locale: '%s'", MYF(0), buf);
      return 1;
    }
unknown's avatar
unknown committed
2863
  }
2864
  else // STRING_RESULT
unknown's avatar
unknown committed
2865
  {
2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879
    char buff[6]; 
    String str(buff, sizeof(buff), &my_charset_latin1), *res;
    if (!(res=var->value->val_str(&str)))
    {
      my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name, "NULL");
      return 1;
    }
    const char *locale_str= res->c_ptr();
    if (!(locale_match= my_locale_by_name(locale_str)))
    {
      my_printf_error(ER_UNKNOWN_ERROR,
                      "Unknown locale: '%s'", MYF(0), locale_str);
      return 1;
    }
unknown's avatar
unknown committed
2880
  }
2881

2882 2883
  var->save_result.locale_value= locale_match;
  return 0;
unknown's avatar
unknown committed
2884 2885 2886 2887 2888
}


bool sys_var_thd_lc_time_names::update(THD *thd, set_var *var)
{
2889 2890 2891 2892
  if (var->type == OPT_GLOBAL)
    global_system_variables.lc_time_names= var->save_result.locale_value;
  else
    thd->variables.lc_time_names= var->save_result.locale_value;
unknown's avatar
unknown committed
2893 2894 2895 2896
  return 0;
}


2897
uchar *sys_var_thd_lc_time_names::value_ptr(THD *thd, enum_var_type type,
unknown's avatar
unknown committed
2898 2899
					  LEX_STRING *base)
{
2900
  return type == OPT_GLOBAL ?
2901 2902
                 (uchar *) global_system_variables.lc_time_names->name :
                 (uchar *) thd->variables.lc_time_names->name;
unknown's avatar
unknown committed
2903 2904 2905 2906 2907
}


void sys_var_thd_lc_time_names::set_default(THD *thd, enum_var_type type)
{
2908 2909 2910 2911
  if (type == OPT_GLOBAL)
    global_system_variables.lc_time_names= my_default_lc_time_names;
  else
    thd->variables.lc_time_names= global_system_variables.lc_time_names;
unknown's avatar
unknown committed
2912
}
2913

2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967
/*
  Handling of microseoncds given as seconds.part_seconds

  NOTES
    The argument to long query time is in seconds in decimal
    which is converted to ulonglong integer holding microseconds for storage.
    This is used for handling long_query_time
*/

bool sys_var_microseconds::update(THD *thd, set_var *var)
{
  double num= var->value->val_real();
  longlong microseconds;
  if (num > (double) option_limits->max_value)
    num= (double) option_limits->max_value;
  if (num < (double) option_limits->min_value)
    num= (double) option_limits->min_value;
  microseconds= (longlong) (num * 1000000.0 + 0.5);
  if (var->type == OPT_GLOBAL)
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
    (global_system_variables.*offset)= microseconds;
    pthread_mutex_unlock(&LOCK_global_system_variables);
  }
  else
    thd->variables.*offset= microseconds;
  return 0;
}


void sys_var_microseconds::set_default(THD *thd, enum_var_type type)
{
  longlong microseconds= (longlong) (option_limits->def_value * 1000000.0);
  if (type == OPT_GLOBAL)
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
    global_system_variables.*offset= microseconds;
    pthread_mutex_unlock(&LOCK_global_system_variables);
  }
  else
    thd->variables.*offset= microseconds;
}


uchar *sys_var_microseconds::value_ptr(THD *thd, enum_var_type type,
                                          LEX_STRING *base)
{
  thd->tmp_double_value= (double) ((type == OPT_GLOBAL) ?
                                   global_system_variables.*offset :
                                   thd->variables.*offset) / 1000000.0;
  return (uchar*) &thd->tmp_double_value;
}


unknown's avatar
unknown committed
2968 2969 2970 2971 2972 2973
/*
  Functions to update thd->options bits
*/

static bool set_option_bit(THD *thd, set_var *var)
{
2974 2975 2976
  sys_var_thd_bit *sys_var= ((sys_var_thd_bit*) var->var);
  if ((var->save_result.ulong_value != 0) == sys_var->reverse)
    thd->options&= ~sys_var->bit_flag;
unknown's avatar
unknown committed
2977
  else
2978
    thd->options|= sys_var->bit_flag;
unknown's avatar
unknown committed
2979 2980 2981 2982 2983 2984 2985 2986
  return 0;
}


static bool set_option_autocommit(THD *thd, set_var *var)
{
  /* The test is negative as the flag we use is NOT autocommit */

2987
  ulonglong org_options= thd->options;
unknown's avatar
unknown committed
2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998

  if (var->save_result.ulong_value != 0)
    thd->options&= ~((sys_var_thd_bit*) var->var)->bit_flag;
  else
    thd->options|= ((sys_var_thd_bit*) var->var)->bit_flag;

  if ((org_options ^ thd->options) & OPTION_NOT_AUTOCOMMIT)
  {
    if ((org_options & OPTION_NOT_AUTOCOMMIT))
    {
      /* We changed to auto_commit mode */
unknown's avatar
unknown committed
2999
      thd->options&= ~(ulonglong) (OPTION_BEGIN | OPTION_KEEP_LOG);
unknown's avatar
unknown committed
3000
      thd->transaction.all.modified_non_trans_table= FALSE;
unknown's avatar
unknown committed
3001 3002 3003 3004 3005 3006
      thd->server_status|= SERVER_STATUS_AUTOCOMMIT;
      if (ha_commit(thd))
	return 1;
    }
    else
    {
unknown's avatar
unknown committed
3007
      thd->transaction.all.modified_non_trans_table= FALSE;
unknown's avatar
unknown committed
3008 3009 3010 3011 3012 3013
      thd->server_status&= ~SERVER_STATUS_AUTOCOMMIT;
    }
  }
  return 0;
}

3014 3015 3016
static int check_log_update(THD *thd, set_var *var)
{
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3017
  if (!(thd->security_ctx->master_access & SUPER_ACL))
3018 3019 3020 3021 3022 3023 3024
  {
    my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), "SUPER");
    return 1;
  }
#endif
  return 0;
}
unknown's avatar
unknown committed
3025 3026 3027

static bool set_log_update(THD *thd, set_var *var)
{
3028 3029 3030 3031 3032
  /*
    The update log is not supported anymore since 5.0.
    See sql/mysqld.cc/, comments in function init_server_components() for an
    explaination of the different warnings we send below
  */
3033

unknown's avatar
unknown committed
3034
  if (opt_sql_bin_update)
3035 3036 3037 3038 3039 3040 3041 3042 3043
  {
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
                 ER_UPDATE_LOG_DEPRECATED_TRANSLATED,
                 ER(ER_UPDATE_LOG_DEPRECATED_TRANSLATED));
  }
  else
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
                 ER_UPDATE_LOG_DEPRECATED_IGNORED,
                 ER(ER_UPDATE_LOG_DEPRECATED_IGNORED));
unknown's avatar
unknown committed
3044 3045 3046 3047 3048
  set_option_bit(thd, var);
  return 0;
}


3049 3050 3051 3052
static int check_pseudo_thread_id(THD *thd, set_var *var)
{
  var->save_result.ulonglong_value= var->value->val_int();
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3053
  if (thd->security_ctx->master_access & SUPER_ACL)
3054 3055 3056 3057 3058 3059 3060 3061 3062 3063
    return 0;
  else
  {
    my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), "SUPER");
    return 1;
  }
#else
  return 0;
#endif
}
3064

3065
static uchar *get_warning_count(THD *thd)
3066 3067 3068
{
  thd->sys_var_tmp.long_value=
    (thd->warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_NOTE] +
3069
     thd->warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_ERROR] +
3070
     thd->warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_WARN]);
3071
  return (uchar*) &thd->sys_var_tmp.long_value;
3072 3073
}

3074
static uchar *get_error_count(THD *thd)
3075 3076 3077
{
  thd->sys_var_tmp.long_value= 
    thd->warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_ERROR];
3078
  return (uchar*) &thd->sys_var_tmp.long_value;
3079 3080
}

3081

unknown's avatar
unknown committed
3082 3083
/**
  Get the tmpdir that was specified or chosen by default.
3084

unknown's avatar
unknown committed
3085 3086 3087 3088 3089
  This is necessary because if the user does not specify a temporary
  directory via the command line, one is chosen based on the environment
  or system defaults.  But we can't just always use mysql_tmpdir, because
  that is actually a call to my_tmpdir() which cycles among possible
  temporary directories.
3090

unknown's avatar
unknown committed
3091
  @param thd		thread handle
3092

unknown's avatar
unknown committed
3093
  @retval
3094
    ptr		pointer to NUL-terminated string
unknown's avatar
unknown committed
3095
*/
3096
static uchar *get_tmpdir(THD *thd)
3097 3098
{
  if (opt_mysql_tmpdir)
3099 3100
    return (uchar *)opt_mysql_tmpdir;
  return (uchar*)mysql_tmpdir;
3101 3102
}

unknown's avatar
unknown committed
3103 3104 3105 3106 3107 3108 3109
/****************************************************************************
  Main handling of variables:
  - Initialisation
  - Searching during parsing
  - Update loop
****************************************************************************/

unknown's avatar
unknown committed
3110 3111 3112
/**
  Find variable name in option my_getopt structure used for
  command line args.
unknown's avatar
unknown committed
3113

unknown's avatar
unknown committed
3114 3115
  @param opt	option structure array to search in
  @param name	variable name
unknown's avatar
unknown committed
3116

unknown's avatar
unknown committed
3117
  @retval
unknown's avatar
unknown committed
3118
    0		Error
unknown's avatar
unknown committed
3119
  @retval
unknown's avatar
unknown committed
3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141
    ptr		pointer to option structure
*/

static struct my_option *find_option(struct my_option *opt, const char *name) 
{
  uint length=strlen(name);
  for (; opt->name; opt++)
  {
    if (!getopt_compare_strings(opt->name, name, length) &&
	!opt->name[length])
    {
      /*
	Only accept the option if one can set values through it.
	If not, there is no default value or limits in the option.
      */
      return (opt->value) ? opt : 0;
    }
  }
  return 0;
}


unknown's avatar
unknown committed
3142 3143
/**
  Return variable name and length for hashing of variables.
unknown's avatar
unknown committed
3144 3145
*/

3146 3147
static uchar *get_sys_var_length(const sys_var *var, size_t *length,
                                 my_bool first)
unknown's avatar
unknown committed
3148 3149
{
  *length= var->name_length;
3150
  return (uchar*) var->name;
unknown's avatar
unknown committed
3151 3152 3153 3154
}


/*
unknown's avatar
unknown committed
3155 3156 3157 3158 3159 3160 3161 3162 3163 3164
  Add variables to the dynamic hash of system variables
  
  SYNOPSIS
    mysql_add_sys_var_chain()
    first       Pointer to first system variable to add
    long_opt    (optional)command line arguments may be tied for limit checks.
  
  RETURN VALUES
    0           SUCCESS
    otherwise   FAILURE
unknown's avatar
unknown committed
3165 3166 3167
*/


unknown's avatar
unknown committed
3168
int mysql_add_sys_var_chain(sys_var *first, struct my_option *long_options)
unknown's avatar
unknown committed
3169
{
3170
  sys_var *var;
unknown's avatar
unknown committed
3171 3172 3173 3174
  
  /* A write lock should be held on LOCK_system_variables_hash */
  
  for (var= first; var; var= var->next)
unknown's avatar
unknown committed
3175
  {
3176
    var->name_length= strlen(var->name);
unknown's avatar
unknown committed
3177
    /* this fails if there is a conflicting variable name. see HASH_UNIQUE */
3178
    if (my_hash_insert(&system_variable_hash, (uchar*) var))
unknown's avatar
unknown committed
3179 3180 3181
      goto error;
    if (long_options)
      var->option_limits= find_option(long_options, var->name);
unknown's avatar
unknown committed
3182
  }
unknown's avatar
unknown committed
3183 3184 3185 3186
  return 0;

error:
  for (; first != var; first= first->next)
3187
    hash_delete(&system_variable_hash, (uchar*) first);
unknown's avatar
unknown committed
3188 3189
  return 1;
}
3190 3191
 
 
unknown's avatar
unknown committed
3192 3193
/*
  Remove variables to the dynamic hash of system variables
3194
   
unknown's avatar
unknown committed
3195 3196 3197
  SYNOPSIS
    mysql_del_sys_var_chain()
    first       Pointer to first system variable to remove
3198
   
unknown's avatar
unknown committed
3199 3200 3201 3202
  RETURN VALUES
    0           SUCCESS
    otherwise   FAILURE
*/
3203
 
unknown's avatar
unknown committed
3204 3205 3206
int mysql_del_sys_var_chain(sys_var *first)
{
  int result= 0;
3207
 
unknown's avatar
unknown committed
3208
  /* A write lock should be held on LOCK_system_variables_hash */
3209
   
unknown's avatar
unknown committed
3210
  for (sys_var *var= first; var; var= var->next)
3211
    result|= hash_delete(&system_variable_hash, (uchar*) var);
unknown's avatar
unknown committed
3212 3213 3214

  return result;
}
3215 3216
 
 
unknown's avatar
unknown committed
3217 3218 3219 3220
static int show_cmp(SHOW_VAR *a, SHOW_VAR *b)
{
  return strcmp(a->name, b->name);
}
3221 3222
 
 
unknown's avatar
unknown committed
3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258
/*
  Constructs an array of system variables for display to the user.
  
  SYNOPSIS
    enumerate_sys_vars()
    thd         current thread
    sorted      If TRUE, the system variables should be sorted
  
  RETURN VALUES
    pointer     Array of SHOW_VAR elements for display
    NULL        FAILURE
*/

SHOW_VAR* enumerate_sys_vars(THD *thd, bool sorted)
{
  int count= system_variable_hash.records, i;
  int fixed_count= fixed_show_vars.elements;
  int size= sizeof(SHOW_VAR) * (count + fixed_count + 1);
  SHOW_VAR *result= (SHOW_VAR*) thd->alloc(size);

  if (result)
  {
    SHOW_VAR *show= result + fixed_count;
    memcpy(result, fixed_show_vars.buffer, fixed_count * sizeof(SHOW_VAR));

    for (i= 0; i < count; i++)
    {
      sys_var *var= (sys_var*) hash_element(&system_variable_hash, i);
      show->name= var->name;
      show->value= (char*) var;
      show->type= SHOW_SYS;
      show++;
    }

    /* sort into order */
    if (sorted)
3259 3260
      my_qsort(result, count + fixed_count, sizeof(SHOW_VAR),
               (qsort_cmp) show_cmp);
unknown's avatar
unknown committed
3261 3262 3263
    
    /* make last element empty */
    bzero(show, sizeof(SHOW_VAR));
unknown's avatar
unknown committed
3264
  }
unknown's avatar
unknown committed
3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301
  return result;
}


/*
  Initialize the system variables
  
  SYNOPSIS
    set_var_init()
  
  RETURN VALUES
    0           SUCCESS
    otherwise   FAILURE
*/

int set_var_init()
{
  uint count= 0;
  DBUG_ENTER("set_var_init");
  
  for (sys_var *var=vars.first; var; var= var->next, count++);

  if (my_init_dynamic_array(&fixed_show_vars, sizeof(SHOW_VAR),
                            FIXED_VARS_SIZE + 64, 64))
    goto error;

  fixed_show_vars.elements= FIXED_VARS_SIZE;
  memcpy(fixed_show_vars.buffer, fixed_vars, sizeof(fixed_vars));

  if (hash_init(&system_variable_hash, system_charset_info, count, 0,
                0, (hash_get_key) get_sys_var_length, 0, HASH_UNIQUE))
    goto error;

  vars.last->next= NULL;
  if (mysql_add_sys_var_chain(vars.first, my_long_options))
    goto error;

unknown's avatar
unknown committed
3302 3303 3304 3305 3306 3307 3308
  /*
    Special cases
    Needed because MySQL can't find the limits for a variable it it has
    a different name than the command line option.
    As these variables are deprecated, this code will disappear soon...
  */
  sys_sql_max_join_size.option_limits= sys_max_join_size.option_limits;
unknown's avatar
unknown committed
3309 3310 3311 3312 3313 3314

  DBUG_RETURN(0);

error:
  fprintf(stderr, "failed to initialize system variables");
  DBUG_RETURN(1);
unknown's avatar
unknown committed
3315 3316 3317 3318 3319 3320
}


void set_var_free()
{
  hash_free(&system_variable_hash);
unknown's avatar
unknown committed
3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339
  delete_dynamic(&fixed_show_vars);
}


/*
  Add elements to the dynamic list of read-only system variables.
  
  SYNOPSIS
    mysql_append_static_vars()
    show_vars	Pointer to start of array
    count       Number of elements
  
  RETURN VALUES
    0           SUCCESS
    otherwise   FAILURE
*/
int mysql_append_static_vars(const SHOW_VAR *show_vars, uint count)
{
  for (; count > 0; count--, show_vars++)
unknown's avatar
unknown committed
3340
    if (insert_dynamic(&fixed_show_vars, (uchar*) show_vars))
unknown's avatar
unknown committed
3341 3342
      return 1;
  return 0;
unknown's avatar
unknown committed
3343 3344 3345
}


unknown's avatar
unknown committed
3346 3347
/**
  Find a user set-table variable.
unknown's avatar
unknown committed
3348

unknown's avatar
unknown committed
3349 3350 3351 3352
  @param str	   Name of system variable to find
  @param length    Length of variable.  zero means that we should use strlen()
                   on the variable
  @param no_error  Refuse to emit an error, even if one occurred.
unknown's avatar
unknown committed
3353

unknown's avatar
unknown committed
3354
  @retval
unknown's avatar
unknown committed
3355
    pointer	pointer to variable definitions
unknown's avatar
unknown committed
3356
  @retval
unknown's avatar
unknown committed
3357 3358 3359
    0		Unknown variable (error message is given)
*/

unknown's avatar
unknown committed
3360
sys_var *intern_find_sys_var(const char *str, uint length, bool no_error)
unknown's avatar
unknown committed
3361
{
unknown's avatar
unknown committed
3362 3363 3364 3365 3366 3367 3368
  sys_var *var;

  /*
    This function is only called from the sql_plugin.cc.
    A lock on LOCK_system_variable_hash should be held
  */
  var= (sys_var*) hash_search(&system_variable_hash,
3369
			      (uchar*) str, length ? length : strlen(str));
unknown's avatar
unknown committed
3370
  if (!(var || no_error))
3371
    my_error(ER_UNKNOWN_SYSTEM_VARIABLE, MYF(0), (char*) str);
unknown's avatar
unknown committed
3372

unknown's avatar
unknown committed
3373 3374 3375 3376
  return var;
}


unknown's avatar
unknown committed
3377 3378
/**
  Execute update of all variables.
unknown's avatar
unknown committed
3379

unknown's avatar
unknown committed
3380 3381
  First run a check of all variables that all updates will go ok.
  If yes, then execute all updates, returning an error if any one failed.
unknown's avatar
unknown committed
3382

unknown's avatar
unknown committed
3383 3384
  This should ensure that in all normal cases none all or variables are
  updated.
unknown's avatar
unknown committed
3385

unknown's avatar
unknown committed
3386 3387
  @param THD		Thread id
  @param var_list       List of variables to update
unknown's avatar
unknown committed
3388

unknown's avatar
unknown committed
3389
  @retval
unknown's avatar
unknown committed
3390
    0	ok
unknown's avatar
unknown committed
3391
  @retval
3392
    1	ERROR, message sent (normally no variables was updated)
unknown's avatar
unknown committed
3393
  @retval
3394
    -1  ERROR, message not sent
unknown's avatar
unknown committed
3395 3396
*/

3397
int sql_set_variables(THD *thd, List<set_var_base> *var_list)
unknown's avatar
unknown committed
3398
{
unknown's avatar
unknown committed
3399
  int error;
unknown's avatar
unknown committed
3400
  List_iterator_fast<set_var_base> it(*var_list);
unknown's avatar
unknown committed
3401
  DBUG_ENTER("sql_set_variables");
unknown's avatar
unknown committed
3402 3403 3404 3405

  set_var_base *var;
  while ((var=it++))
  {
unknown's avatar
unknown committed
3406
    if ((error= var->check(thd)))
3407
      goto err;
unknown's avatar
unknown committed
3408
  }
3409
  if (!(error= test(thd->is_error())))
3410 3411 3412 3413 3414
  {
    it.rewind();
    while ((var= it++))
      error|= var->update(thd);         // Returns 0, -1 or 1
  }
unknown's avatar
unknown committed
3415

3416 3417
err:
  free_underlaid_joins(thd, &thd->lex->select_lex);
unknown's avatar
unknown committed
3418
  DBUG_RETURN(error);
unknown's avatar
unknown committed
3419 3420 3421
}


unknown's avatar
unknown committed
3422 3423 3424 3425
/**
  Say if all variables set by a SET support the ONE_SHOT keyword
  (currently, only character set and collation do; later timezones
  will).
3426

unknown's avatar
unknown committed
3427
  @param var_list	List of variables to update
3428

unknown's avatar
unknown committed
3429
  @note
3430 3431
    It has a "not_" because it makes faster tests (no need to "!")

unknown's avatar
unknown committed
3432
  @retval
3433
    0	all variables of the list support ONE_SHOT
unknown's avatar
unknown committed
3434
  @retval
3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450
    1	at least one does not support ONE_SHOT
*/

bool not_all_support_one_shot(List<set_var_base> *var_list)
{
  List_iterator_fast<set_var_base> it(*var_list);
  set_var_base *var;
  while ((var= it++))
  {
    if (var->no_support_one_shot())
      return 1;
  }
  return 0;
}


unknown's avatar
unknown committed
3451 3452 3453 3454
/*****************************************************************************
  Functions to handle SET mysql_internal_variable=const_expr
*****************************************************************************/

3455
int set_var::check(THD *thd)
unknown's avatar
unknown committed
3456
{
3457 3458 3459 3460 3461
  if (var->is_readonly())
  {
    my_error(ER_INCORRECT_GLOBAL_LOCAL_VAR, MYF(0), var->name, "read only");
    return -1;
  }
unknown's avatar
unknown committed
3462 3463
  if (var->check_type(type))
  {
unknown's avatar
unknown committed
3464
    int err= type == OPT_GLOBAL ? ER_LOCAL_VARIABLE : ER_GLOBAL_VARIABLE;
3465
    my_error(err, MYF(0), var->name);
3466
    return -1;
unknown's avatar
unknown committed
3467 3468 3469 3470 3471 3472 3473 3474
  }
  if ((type == OPT_GLOBAL && check_global_access(thd, SUPER_ACL)))
    return 1;
  /* value is a NULL pointer if we are using SET ... = DEFAULT */
  if (!value)
  {
    if (var->check_default(type))
    {
3475
      my_error(ER_NO_DEFAULT, MYF(0), var->name);
3476
      return -1;
unknown's avatar
unknown committed
3477 3478 3479 3480
    }
    return 0;
  }

unknown's avatar
unknown committed
3481
  if ((!value->fixed &&
3482
       value->fix_fields(thd, &value)) || value->check_cols(1))
3483
    return -1;
unknown's avatar
unknown committed
3484 3485
  if (var->check_update_type(value->result_type()))
  {
3486
    my_error(ER_WRONG_TYPE_FOR_VAR, MYF(0), var->name);
3487
    return -1;
3488
  }
3489
  return var->check(thd, this) ? -1 : 0;
unknown's avatar
unknown committed
3490 3491 3492
}


unknown's avatar
unknown committed
3493 3494
/**
  Check variable, but without assigning value (used by PS).
unknown's avatar
unknown committed
3495

unknown's avatar
unknown committed
3496
  @param thd		thread handler
unknown's avatar
unknown committed
3497

unknown's avatar
unknown committed
3498
  @retval
unknown's avatar
unknown committed
3499
    0	ok
unknown's avatar
unknown committed
3500
  @retval
unknown's avatar
unknown committed
3501
    1	ERROR, message sent (normally no variables was updated)
unknown's avatar
unknown committed
3502 3503
  @retval
    -1   ERROR, message not sent
unknown's avatar
unknown committed
3504
*/
3505 3506 3507 3508
int set_var::light_check(THD *thd)
{
  if (var->check_type(type))
  {
unknown's avatar
unknown committed
3509
    int err= type == OPT_GLOBAL ? ER_LOCAL_VARIABLE : ER_GLOBAL_VARIABLE;
3510
    my_error(err, MYF(0), var->name);
3511 3512
    return -1;
  }
unknown's avatar
unknown committed
3513
  if (type == OPT_GLOBAL && check_global_access(thd, SUPER_ACL))
3514 3515
    return 1;

3516
  if (value && ((!value->fixed && value->fix_fields(thd, &value)) ||
unknown's avatar
unknown committed
3517
                value->check_cols(1)))
3518 3519 3520 3521
    return -1;
  return 0;
}

3522 3523
/**
  Update variable
3524

3525 3526 3527 3528 3529 3530 3531 3532 3533
  @param   thd    thread handler
  @returns 0|1    ok or	ERROR

  @note ERROR can be only due to abnormal operations involving
  the server's execution evironment such as
  out of memory, hard disk failure or the computer blows up.
  Consider set_var::check() method if there is a need to return
  an error due to logics.
*/
3534
int set_var::update(THD *thd)
unknown's avatar
unknown committed
3535 3536 3537 3538
{
  if (!value)
    var->set_default(thd, type);
  else if (var->update(thd, this))
3539
    return -1;				// should never happen
unknown's avatar
unknown committed
3540 3541 3542 3543 3544 3545 3546 3547 3548 3549
  if (var->after_update)
    (*var->after_update)(thd, type);
  return 0;
}


/*****************************************************************************
  Functions to handle SET @user_variable=const_expr
*****************************************************************************/

3550
int set_var_user::check(THD *thd)
unknown's avatar
unknown committed
3551
{
unknown's avatar
unknown committed
3552 3553
  /*
    Item_func_set_user_var can't substitute something else on its place =>
3554
    0 can be passed as last argument (reference on item)
unknown's avatar
unknown committed
3555
  */
3556
  return (user_var_item->fix_fields(thd, (Item**) 0) ||
3557
	  user_var_item->check(0)) ? -1 : 0;
unknown's avatar
unknown committed
3558 3559 3560
}


unknown's avatar
unknown committed
3561 3562
/**
  Check variable, but without assigning value (used by PS).
unknown's avatar
unknown committed
3563

unknown's avatar
unknown committed
3564
  @param thd		thread handler
unknown's avatar
unknown committed
3565

unknown's avatar
unknown committed
3566
  @retval
unknown's avatar
unknown committed
3567
    0	ok
unknown's avatar
unknown committed
3568
  @retval
unknown's avatar
unknown committed
3569
    1	ERROR, message sent (normally no variables was updated)
unknown's avatar
unknown committed
3570 3571
  @retval
    -1   ERROR, message not sent
unknown's avatar
unknown committed
3572
*/
3573 3574 3575 3576 3577 3578
int set_var_user::light_check(THD *thd)
{
  /*
    Item_func_set_user_var can't substitute something else on its place =>
    0 can be passed as last argument (reference on item)
  */
3579
  return (user_var_item->fix_fields(thd, (Item**) 0));
3580 3581 3582
}


3583
int set_var_user::update(THD *thd)
unknown's avatar
unknown committed
3584 3585 3586 3587
{
  if (user_var_item->update())
  {
    /* Give an error if it's not given already */
unknown's avatar
unknown committed
3588
    my_message(ER_SET_CONSTANTS_ONLY, ER(ER_SET_CONSTANTS_ONLY), MYF(0));
3589
    return -1;
unknown's avatar
unknown committed
3590 3591 3592 3593 3594 3595 3596 3597 3598
  }
  return 0;
}


/*****************************************************************************
  Functions to handle SET PASSWORD
*****************************************************************************/

3599
int set_var_password::check(THD *thd)
unknown's avatar
unknown committed
3600
{
unknown's avatar
unknown committed
3601
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
3602
  if (!user->host.str)
3603
  {
3604
    if (*thd->security_ctx->priv_host != 0)
3605
    {
3606 3607
      user->host.str= (char *) thd->security_ctx->priv_host;
      user->host.length= strlen(thd->security_ctx->priv_host);
3608 3609 3610 3611 3612 3613 3614
    }
    else
    {
      user->host.str= (char *)"%";
      user->host.length= 1;
    }
  }
3615
  /* Returns 1 as the function sends error to client */
3616 3617
  return check_change_password(thd, user->host.str, user->user.str,
                               password, strlen(password)) ? 1 : 0;
3618
#else
unknown's avatar
unknown committed
3619 3620
  return 0;
#endif
unknown's avatar
unknown committed
3621 3622
}

3623
int set_var_password::update(THD *thd)
unknown's avatar
unknown committed
3624
{
unknown's avatar
unknown committed
3625
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3626
  /* Returns 1 as the function sends error to client */
3627 3628
  return change_password(thd, user->host.str, user->user.str, password) ?
	  1 : 0;
unknown's avatar
unknown committed
3629 3630 3631
#else
  return 0;
#endif
unknown's avatar
unknown committed
3632 3633
}

3634 3635 3636 3637
/****************************************************************************
 Functions to handle table_type
****************************************************************************/

unknown's avatar
unknown committed
3638 3639
/* Based upon sys_var::check_enum() */

unknown's avatar
unknown committed
3640
bool sys_var_thd_storage_engine::check(THD *thd, set_var *var)
3641
{
unknown's avatar
unknown committed
3642
  char buff[STRING_BUFFER_USUAL_SIZE];
3643 3644 3645
  const char *value;
  String str(buff, sizeof(buff), &my_charset_latin1), *res;

unknown's avatar
unknown committed
3646
  var->save_result.plugin= NULL;
3647 3648
  if (var->value->result_type() == STRING_RESULT)
  {
3649
    LEX_STRING engine_name;
unknown's avatar
unknown committed
3650
    handlerton *hton;
3651
    if (!(res=var->value->val_str(&str)) ||
3652 3653 3654
        !(engine_name.str= (char *)res->ptr()) ||
        !(engine_name.length= res->length()) ||
	!(var->save_result.plugin= ha_resolve_by_name(thd, &engine_name)) ||
unknown's avatar
unknown committed
3655 3656
        !(hton= plugin_data(var->save_result.plugin, handlerton *)) ||
        ha_checktype(thd, ha_legacy_type(hton), 1, 0) != hton)
3657 3658 3659 3660 3661 3662
    {
      value= res ? res->c_ptr() : "NULL";
      goto err;
    }
    return 0;
  }
unknown's avatar
unknown committed
3663
  value= "unknown";
3664 3665

err:
3666
  my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), value);
unknown's avatar
unknown committed
3667
  return 1;
3668 3669
}

unknown's avatar
unknown committed
3670

3671
uchar *sys_var_thd_storage_engine::value_ptr(THD *thd, enum_var_type type,
unknown's avatar
unknown committed
3672
					    LEX_STRING *base)
3673
{
3674
  uchar* result;
unknown's avatar
unknown committed
3675
  handlerton *hton;
3676
  LEX_STRING *engine_name;
unknown's avatar
unknown committed
3677 3678 3679 3680
  plugin_ref plugin= thd->variables.*offset;
  if (type == OPT_GLOBAL)
    plugin= my_plugin_lock(thd, &(global_system_variables.*offset));
  hton= plugin_data(plugin, handlerton*);
3681 3682
  engine_name= &hton2plugin[hton->slot]->name;
  result= (uchar *) thd->strmake(engine_name->str, engine_name->length);
unknown's avatar
unknown committed
3683 3684 3685
  if (type == OPT_GLOBAL)
    plugin_unlock(thd, plugin);
  return result;
3686 3687
}

unknown's avatar
unknown committed
3688

unknown's avatar
unknown committed
3689
void sys_var_thd_storage_engine::set_default(THD *thd, enum_var_type type)
3690
{
unknown's avatar
unknown committed
3691
  plugin_ref old_value, new_value, *value;
3692
  if (type == OPT_GLOBAL)
unknown's avatar
unknown committed
3693 3694 3695 3696
  {
    value= &(global_system_variables.*offset);
    new_value= ha_lock_engine(NULL, myisam_hton);
  }
3697
  else
unknown's avatar
unknown committed
3698 3699 3700 3701 3702 3703 3704 3705
  {
    value= &(thd->variables.*offset);
    new_value= my_plugin_lock(NULL, &(global_system_variables.*offset));
  }
  DBUG_ASSERT(new_value);
  old_value= *value;
  *value= new_value;
  plugin_unlock(NULL, old_value);
3706 3707
}

unknown's avatar
unknown committed
3708

unknown's avatar
unknown committed
3709
bool sys_var_thd_storage_engine::update(THD *thd, set_var *var)
3710
{
unknown's avatar
unknown committed
3711 3712 3713 3714 3715 3716 3717 3718 3719
  plugin_ref *value= &(global_system_variables.*offset), old_value;
   if (var->type != OPT_GLOBAL)
     value= &(thd->variables.*offset);
  old_value= *value;
  if (old_value != var->save_result.plugin)
  {
    *value= my_plugin_lock(NULL, &var->save_result.plugin);
    plugin_unlock(NULL, old_value);
  }
3720 3721 3722
  return 0;
}

unknown's avatar
unknown committed
3723 3724
void sys_var_thd_table_type::warn_deprecated(THD *thd)
{
3725
  WARN_DEPRECATED(thd, "5.2", "@@table_type", "'@@storage_engine'");
unknown's avatar
unknown committed
3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739
}

void sys_var_thd_table_type::set_default(THD *thd, enum_var_type type)
{
  warn_deprecated(thd);
  sys_var_thd_storage_engine::set_default(thd, type);
}

bool sys_var_thd_table_type::update(THD *thd, set_var *var)
{
  warn_deprecated(thd);
  return sys_var_thd_storage_engine::update(thd, var);
}

unknown's avatar
unknown committed
3740

3741 3742 3743
/****************************************************************************
 Functions to handle sql_mode
****************************************************************************/
3744

unknown's avatar
unknown committed
3745 3746
/**
  Make string representation of mode.
3747

unknown's avatar
unknown committed
3748 3749 3750 3751 3752 3753
  @param[in]  thd    thread handler
  @param[in]  val    sql_mode value
  @param[out] len    pointer on length of string

  @return
    pointer to string with sql_mode representation
3754 3755
*/

3756 3757 3758
bool
sys_var_thd_sql_mode::
symbolic_mode_representation(THD *thd, ulonglong val, LEX_STRING *rep)
3759
{
3760
  char buff[STRING_BUFFER_USUAL_SIZE*8];
3761 3762 3763
  String tmp(buff, sizeof(buff), &my_charset_latin1);

  tmp.length(0);
3764

3765 3766 3767 3768
  for (uint i= 0; val; val>>= 1, i++)
  {
    if (val & 1)
    {
3769 3770
      tmp.append(sql_mode_typelib.type_names[i],
                 sql_mode_typelib.type_lengths[i]);
3771 3772 3773
      tmp.append(',');
    }
  }
unknown's avatar
unknown committed
3774

3775 3776 3777 3778 3779 3780 3781 3782
  if (tmp.length())
    tmp.length(tmp.length() - 1); /* trim the trailing comma */

  rep->str= thd->strmake(tmp.ptr(), tmp.length());

  rep->length= rep->str ? tmp.length() : 0;

  return rep->length != tmp.length();
3783 3784
}

unknown's avatar
unknown committed
3785

3786
uchar *sys_var_thd_sql_mode::value_ptr(THD *thd, enum_var_type type,
3787 3788
				      LEX_STRING *base)
{
3789
  LEX_STRING sql_mode;
3790 3791
  ulonglong val= ((type == OPT_GLOBAL) ? global_system_variables.*offset :
                  thd->variables.*offset);
3792
  (void) symbolic_mode_representation(thd, val, &sql_mode);
3793
  return (uchar *) sql_mode.str;
3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804
}


void sys_var_thd_sql_mode::set_default(THD *thd, enum_var_type type)
{
  if (type == OPT_GLOBAL)
    global_system_variables.*offset= 0;
  else
    thd->variables.*offset= global_system_variables.*offset;
}

unknown's avatar
unknown committed
3805

3806 3807 3808 3809 3810 3811
void fix_sql_mode_var(THD *thd, enum_var_type type)
{
  if (type == OPT_GLOBAL)
    global_system_variables.sql_mode=
      fix_sql_mode(global_system_variables.sql_mode);
  else
3812
  {
3813
    thd->variables.sql_mode= fix_sql_mode(thd->variables.sql_mode);
3814 3815 3816 3817 3818 3819 3820 3821
    /*
      Update thd->server_status
     */
    if (thd->variables.sql_mode & MODE_NO_BACKSLASH_ESCAPES)
      thd->server_status|= SERVER_STATUS_NO_BACKSLASH_ESCAPES;
    else
      thd->server_status&= ~SERVER_STATUS_NO_BACKSLASH_ESCAPES;
  }
3822 3823
}

unknown's avatar
unknown committed
3824
/** Map database specific bits to function bits. */
3825

3826 3827 3828 3829 3830 3831 3832 3833 3834
ulong fix_sql_mode(ulong sql_mode)
{
  /*
    Note that we dont set 
    MODE_NO_KEY_OPTIONS | MODE_NO_TABLE_OPTIONS | MODE_NO_FIELD_OPTIONS
    to allow one to get full use of MySQL in this mode.
  */

  if (sql_mode & MODE_ANSI)
3835
  {
3836
    sql_mode|= (MODE_REAL_AS_FLOAT | MODE_PIPES_AS_CONCAT | MODE_ANSI_QUOTES |
3837 3838 3839 3840 3841 3842
		MODE_IGNORE_SPACE);
    /* 
      MODE_ONLY_FULL_GROUP_BY removed from ANSI mode because it is currently
      overly restrictive (see BUG#8510).
    */
  }
3843 3844 3845 3846
  if (sql_mode & MODE_ORACLE)
    sql_mode|= (MODE_PIPES_AS_CONCAT | MODE_ANSI_QUOTES |
		MODE_IGNORE_SPACE |
		MODE_NO_KEY_OPTIONS | MODE_NO_TABLE_OPTIONS |
3847
		MODE_NO_FIELD_OPTIONS | MODE_NO_AUTO_CREATE_USER);
3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862
  if (sql_mode & MODE_MSSQL)
    sql_mode|= (MODE_PIPES_AS_CONCAT | MODE_ANSI_QUOTES |
		MODE_IGNORE_SPACE |
		MODE_NO_KEY_OPTIONS | MODE_NO_TABLE_OPTIONS |
		MODE_NO_FIELD_OPTIONS);
  if (sql_mode & MODE_POSTGRESQL)
    sql_mode|= (MODE_PIPES_AS_CONCAT | MODE_ANSI_QUOTES |
		MODE_IGNORE_SPACE |
		MODE_NO_KEY_OPTIONS | MODE_NO_TABLE_OPTIONS |
		MODE_NO_FIELD_OPTIONS);
  if (sql_mode & MODE_DB2)
    sql_mode|= (MODE_PIPES_AS_CONCAT | MODE_ANSI_QUOTES |
		MODE_IGNORE_SPACE |
		MODE_NO_KEY_OPTIONS | MODE_NO_TABLE_OPTIONS |
		MODE_NO_FIELD_OPTIONS);
3863
  if (sql_mode & MODE_MAXDB)
3864 3865 3866
    sql_mode|= (MODE_PIPES_AS_CONCAT | MODE_ANSI_QUOTES |
		MODE_IGNORE_SPACE |
		MODE_NO_KEY_OPTIONS | MODE_NO_TABLE_OPTIONS |
3867
		MODE_NO_FIELD_OPTIONS | MODE_NO_AUTO_CREATE_USER);
3868
  if (sql_mode & MODE_MYSQL40)
3869
    sql_mode|= MODE_HIGH_NOT_PRECEDENCE;
3870
  if (sql_mode & MODE_MYSQL323)
3871
    sql_mode|= MODE_HIGH_NOT_PRECEDENCE;
unknown's avatar
unknown committed
3872 3873 3874
  if (sql_mode & MODE_TRADITIONAL)
    sql_mode|= (MODE_STRICT_TRANS_TABLES | MODE_STRICT_ALL_TABLES |
                MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
3875
                MODE_ERROR_FOR_DIVISION_BY_ZERO | MODE_NO_AUTO_CREATE_USER);
3876 3877
  return sql_mode;
}
3878 3879


3880 3881 3882 3883
/****************************************************************************
  Named list handling
****************************************************************************/

3884
uchar* find_named(I_List<NAMED_LIST> *list, const char *name, uint length,
unknown's avatar
unknown committed
3885
		NAMED_LIST **found)
3886 3887 3888 3889 3890 3891
{
  I_List_iterator<NAMED_LIST> it(*list);
  NAMED_LIST *element;
  while ((element= it++))
  {
    if (element->cmp(name, length))
unknown's avatar
unknown committed
3892
    {
3893 3894
      if (found)
        *found= element;
3895
      return element->data;
unknown's avatar
unknown committed
3896
    }
3897 3898 3899 3900 3901
  }
  return 0;
}


3902
void delete_elements(I_List<NAMED_LIST> *list,
3903
		     void (*free_element)(const char *name, uchar*))
3904 3905
{
  NAMED_LIST *element;
unknown's avatar
unknown committed
3906
  DBUG_ENTER("delete_elements");
3907 3908
  while ((element= list->get()))
  {
3909
    (*free_element)(element->name, element->data);
3910 3911
    delete element;
  }
unknown's avatar
unknown committed
3912
  DBUG_VOID_RETURN;
3913 3914 3915 3916 3917
}


/* Key cache functions */

unknown's avatar
unknown committed
3918
static KEY_CACHE *create_key_cache(const char *name, uint length)
3919
{
unknown's avatar
unknown committed
3920
  KEY_CACHE *key_cache;
3921 3922 3923
  DBUG_ENTER("create_key_cache");
  DBUG_PRINT("enter",("name: %.*s", length, name));
  
unknown's avatar
unknown committed
3924
  if ((key_cache= (KEY_CACHE*) my_malloc(sizeof(KEY_CACHE),
3925
					     MYF(MY_ZEROFILL | MY_WME))))
unknown's avatar
unknown committed
3926
  {
3927
    if (!new NAMED_LIST(&key_caches, name, length, (uchar*) key_cache))
3928 3929
    {
      my_free((char*) key_cache, MYF(0));
unknown's avatar
unknown committed
3930
      key_cache= 0;
3931 3932 3933 3934 3935 3936 3937 3938 3939
    }
    else
    {
      /*
	Set default values for a key cache
	The values in dflt_key_cache_var is set by my_getopt() at startup

	We don't set 'buff_size' as this is used to enable the key cache
      */
unknown's avatar
unknown committed
3940 3941 3942
      key_cache->param_block_size=     dflt_key_cache_var.param_block_size;
      key_cache->param_division_limit= dflt_key_cache_var.param_division_limit;
      key_cache->param_age_threshold=  dflt_key_cache_var.param_age_threshold;
3943
    }
unknown's avatar
unknown committed
3944
  }
3945
  DBUG_RETURN(key_cache);
3946 3947 3948
}


unknown's avatar
unknown committed
3949
KEY_CACHE *get_or_create_key_cache(const char *name, uint length)
3950
{
unknown's avatar
unknown committed
3951
  LEX_STRING key_cache_name;
unknown's avatar
unknown committed
3952
  KEY_CACHE *key_cache;
3953

unknown's avatar
unknown committed
3954 3955
  key_cache_name.str= (char *) name;
  key_cache_name.length= length;
3956 3957
  pthread_mutex_lock(&LOCK_global_system_variables);
  if (!(key_cache= get_key_cache(&key_cache_name)))
3958
    key_cache= create_key_cache(name, length);
3959
  pthread_mutex_unlock(&LOCK_global_system_variables);
3960 3961 3962 3963
  return key_cache;
}


unknown's avatar
unknown committed
3964
void free_key_cache(const char *name, KEY_CACHE *key_cache)
3965
{
3966 3967
  ha_end_key_cache(key_cache);
  my_free((char*) key_cache, MYF(0));
unknown's avatar
unknown committed
3968 3969 3970
}


3971
bool process_key_caches(process_key_cache_t func)
3972
{
unknown's avatar
unknown committed
3973 3974
  I_List_iterator<NAMED_LIST> it(key_caches);
  NAMED_LIST *element;
3975

unknown's avatar
unknown committed
3976 3977
  while ((element= it++))
  {
unknown's avatar
unknown committed
3978
    KEY_CACHE *key_cache= (KEY_CACHE *) element->data;
3979
    func(element->name, key_cache);
unknown's avatar
unknown committed
3980 3981
  }
  return 0;
3982 3983
}

3984

3985 3986
void sys_var_trust_routine_creators::warn_deprecated(THD *thd)
{
3987 3988
  WARN_DEPRECATED(thd, "5.2", "@@log_bin_trust_routine_creators",
                      "'@@log_bin_trust_function_creators'");
3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002
}

void sys_var_trust_routine_creators::set_default(THD *thd, enum_var_type type)
{
  warn_deprecated(thd);
  sys_var_bool_ptr::set_default(thd, type);
}

bool sys_var_trust_routine_creators::update(THD *thd, set_var *var)
{
  warn_deprecated(thd);
  return sys_var_bool_ptr::update(thd, var);
}

unknown's avatar
unknown committed
4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050
bool sys_var_opt_readonly::update(THD *thd, set_var *var)
{
  bool result;

  DBUG_ENTER("sys_var_opt_readonly::update");

  /* Prevent self dead-lock */
  if (thd->locked_tables || thd->active_transaction())
  {
    my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
    DBUG_RETURN(true);
  }

  if (thd->global_read_lock)
  {
    /*
      This connection already holds the global read lock.
      This can be the case with:
      - FLUSH TABLES WITH READ LOCK
      - SET GLOBAL READ_ONLY = 1
    */
    result= sys_var_bool_ptr::update(thd, var);
    DBUG_RETURN(result);
  }

  /*
    Perform a 'FLUSH TABLES WITH READ LOCK'.
    This is a 3 step process:
    - [1] lock_global_read_lock()
    - [2] close_cached_tables()
    - [3] make_global_read_lock_block_commit()
    [1] prevents new connections from obtaining tables locked for write.
    [2] waits until all existing connections close their tables.
    [3] prevents transactions from being committed.
  */

  if (lock_global_read_lock(thd))
    DBUG_RETURN(true);

  /*
    This call will be blocked by any connection holding a READ or WRITE lock.
    Ideally, we want to wait only for pending WRITE locks, but since:
    con 1> LOCK TABLE T FOR READ;
    con 2> LOCK TABLE T FOR WRITE; (blocked by con 1)
    con 3> SET GLOBAL READ ONLY=1; (blocked by con 2)
    can cause to wait on a read lock, it's required for the client application
    to unlock everything, and acceptable for the server to wait on all locks.
  */
4051
  if (result= close_cached_tables(thd, NULL, FALSE, TRUE, TRUE))
unknown's avatar
unknown committed
4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066
    goto end_with_read_lock;

  if (result= make_global_read_lock_block_commit(thd))
    goto end_with_read_lock;

  /* Change the opt_readonly system variable, safe because the lock is held */
  result= sys_var_bool_ptr::update(thd, var);

end_with_read_lock:
  /* Release the lock */
  unlock_global_read_lock(thd);
  DBUG_RETURN(result);
}


unknown's avatar
unknown committed
4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077
/* even session variable here requires SUPER, because of -#o,file */
bool sys_var_thd_dbug::check(THD *thd, set_var *var)
{
  return check_global_access(thd, SUPER_ACL);
}

bool sys_var_thd_dbug::update(THD *thd, set_var *var)
{
  if (var->type == OPT_GLOBAL)
    DBUG_SET_INITIAL(var ? var->value->str_value.c_ptr() : "");
  else
4078 4079
    DBUG_SET(var ? var->value->str_value.c_ptr() : "");

unknown's avatar
unknown committed
4080 4081 4082
  return 0;
}

4083

4084
uchar *sys_var_thd_dbug::value_ptr(THD *thd, enum_var_type type, LEX_STRING *b)
unknown's avatar
unknown committed
4085 4086 4087 4088 4089 4090
{
  char buf[256];
  if (type == OPT_GLOBAL)
    DBUG_EXPLAIN_INITIAL(buf, sizeof(buf));
  else
    DBUG_EXPLAIN(buf, sizeof(buf));
4091
  return (uchar*) thd->strdup(buf);
unknown's avatar
unknown committed
4092
}
unknown's avatar
unknown committed
4093

4094
#ifdef HAVE_EVENT_SCHEDULER
4095 4096 4097 4098 4099
bool sys_var_event_scheduler::check(THD *thd, set_var *var)
{
  return check_enum(thd, var, &Events::var_typelib);
}

4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117
/*
   The update method of the global variable event_scheduler.
   If event_scheduler is switched from 0 to 1 then the scheduler main
   thread is resumed and if from 1 to 0 the scheduler thread is suspended

   SYNOPSIS
     sys_var_event_scheduler::update()
       thd  Thread context (unused)
       var  The new value

   Returns
     FALSE  OK
     TRUE   Error
*/

bool
sys_var_event_scheduler::update(THD *thd, set_var *var)
{
unknown's avatar
unknown committed
4118
  int res;
4119 4120
  /* here start the thread if not running. */
  DBUG_ENTER("sys_var_event_scheduler::update");
unknown's avatar
unknown committed
4121
  DBUG_PRINT("info", ("new_value: %d", (int) var->save_result.ulong_value));
4122

4123 4124 4125 4126
  enum Events::enum_opt_event_scheduler
    new_state=
    (enum Events::enum_opt_event_scheduler) var->save_result.ulong_value;

4127
  res= Events::switch_event_scheduler_state(new_state);
4128 4129 4130 4131 4132

  DBUG_RETURN((bool) res);
}


4133
uchar *sys_var_event_scheduler::value_ptr(THD *thd, enum_var_type type,
4134 4135
                                         LEX_STRING *base)
{
4136
  return (uchar *) Events::get_opt_event_scheduler_str();
4137
}
4138
#endif
4139

unknown's avatar
unknown committed
4140 4141 4142 4143
/****************************************************************************
  Used templates
****************************************************************************/

4144
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
unknown's avatar
unknown committed
4145
template class List<set_var_base>;
unknown's avatar
unknown committed
4146
template class List_iterator_fast<set_var_base>;
4147
template class I_List_iterator<NAMED_LIST>;
unknown's avatar
unknown committed
4148
#endif