← Back to branch summary

~ubuntu-branches/ubuntu/lucid/mysql-dfsg-5.1/lucid

« back to all changes in this revision

Viewing changes to sql/set_var.cc

  • Committer: Bazaar Package Importer
  • Author(s): Mathias Gug
  • Date: 2009-02-10 16:42:05 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20090210164205-ej41ocvm4z1s14nq
Tags: 5.1.31-1ubuntu1
https://launchpad.net/bugs/319843
https://launchpad.net/bugs/316280
https://launchpad.net/bugs/323755
* Merge from debian experimental, remaining changes: 
  - debian/mysql-server-5.1.config: ask for MySQL root password at priority
    high instead of medium so that the password prompt is seen on a default
    install. (LP: #319843)
  - debian/control: 
    + Don't build mysql-server, mysql-client, mysql-common and 
      libmysqlclient15-dev binary packages since they're still provided 
      by mysql-dfsg-5.0.
    + Rename libmysqlclient-dev package to libmysqlclient16-dev (LP: #316280).
      Make it conflict with libmysqlclient15-dev.
    + Make mysql-{client,server}-5.1 packages conflict and
      replace mysql-{client,server}-5.0, but not provide 
      mysql-{client,server}.
    + Depend on a specific version of mysql-common rather than the src 
      version of mysql-dfsg-5.1 since mysql-common is currently part of
      mysql-dfsg-5.0.
  - debian/rules: added -fno-strict-aliasing to CFLAGS to get
    around mysql testsuite build failures.
* debian/patches/92_ssl_test_cert.dpatch: certificate expiration in 
  test suite (LP: #323755).
* Dropped changes:
  - all of the changes made to support both 5.0 and 5.1 installed at the
    same time have been dropped now that amarok doesn't depend on
    mysql-server-5.1 anymore.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/set_var.cc
77
77
extern CHARSET_INFO *character_set_filesystem;
78
78
 
79
79
 
80
 
static DYNAMIC_ARRAY fixed_show_vars;
81
80
static HASH system_variable_hash;
82
81
 
83
82
const char *bool_type_names[]= { "OFF", "ON", NullS };
174
173
static sys_var_bool_ptr sys_automatic_sp_privileges(&vars, "automatic_sp_privileges",
175
174
                                              &sp_automatic_privileges);
176
175
 
177
 
static sys_var_const_str       sys_basedir(&vars, "basedir", mysql_home);
 
176
static sys_var_const            sys_back_log(&vars, "back_log",
 
177
                                             OPT_GLOBAL, SHOW_LONG,
 
178
                                             (uchar*) &back_log);
 
179
static sys_var_const_os_str       sys_basedir(&vars, "basedir", mysql_home);
178
180
static sys_var_long_ptr sys_binlog_cache_size(&vars, "binlog_cache_size",
179
181
                                              &binlog_cache_size);
180
182
static sys_var_thd_binlog_format sys_binlog_format(&vars, "binlog_format",
181
183
                                            &SV::binlog_format);
182
184
static sys_var_thd_ulong        sys_bulk_insert_buff_size(&vars, "bulk_insert_buffer_size",
183
185
                                                  &SV::bulk_insert_buff_size);
 
186
static sys_var_const_os         sys_character_sets_dir(&vars,
 
187
                                                       "character_sets_dir",
 
188
                                                       OPT_GLOBAL, SHOW_CHAR,
 
189
                                                       (uchar*)
 
190
                                                       mysql_charsets_dir);
184
191
static sys_var_character_set_sv
185
192
sys_character_set_server(&vars, "character_set_server",
186
193
                         &SV::collation_server, &default_charset_info, 0,
226
233
                                              &myisam_concurrent_insert);
227
234
static sys_var_long_ptr sys_connect_timeout(&vars, "connect_timeout",
228
235
                                            &connect_timeout);
229
 
static sys_var_const_str       sys_datadir(&vars, "datadir", mysql_real_data_home);
 
236
static sys_var_const_os_str       sys_datadir(&vars, "datadir", mysql_real_data_home);
230
237
#ifndef DBUG_OFF
231
238
static sys_var_thd_dbug        sys_dbug(&vars, "debug");
232
239
#endif
249
256
                                             &expire_logs_days);
250
257
static sys_var_bool_ptr sys_flush(&vars, "flush", &myisam_flush);
251
258
static sys_var_long_ptr sys_flush_time(&vars, "flush_time", &flush_time);
252
 
static sys_var_str             sys_ft_boolean_syntax(&vars, "ft_boolean_syntax",
253
 
                                         sys_check_ftb_syntax,
254
 
                                         sys_update_ftb_syntax,
255
 
                                         sys_default_ftb_syntax,
256
 
                                         ft_boolean_syntax);
 
259
static sys_var_str      sys_ft_boolean_syntax(&vars, "ft_boolean_syntax",
 
260
                                              sys_check_ftb_syntax,
 
261
                                              sys_update_ftb_syntax,
 
262
                                              sys_default_ftb_syntax,
 
263
                                              ft_boolean_syntax);
 
264
static sys_var_const    sys_ft_max_word_len(&vars, "ft_max_word_len",
 
265
                                            OPT_GLOBAL, SHOW_LONG,
 
266
                                            (uchar*) &ft_max_word_len);
 
267
static sys_var_const    sys_ft_min_word_len(&vars, "ft_min_word_len",
 
268
                                            OPT_GLOBAL, SHOW_LONG,
 
269
                                            (uchar*) &ft_min_word_len);
 
270
static sys_var_const    sys_ft_query_expansion_limit(&vars,
 
271
                                                     "ft_query_expansion_limit",
 
272
                                                     OPT_GLOBAL, SHOW_LONG,
 
273
                                                     (uchar*)
 
274
                                                     &ft_query_expansion_limit);
 
275
static sys_var_const    sys_ft_stopword_file(&vars, "ft_stopword_file",
 
276
                                             OPT_GLOBAL, SHOW_CHAR_PTR,
 
277
                                             (uchar*) &ft_stopword_file);
257
278
sys_var_str             sys_init_connect(&vars, "init_connect", 0,
258
279
                                         sys_update_init_connect,
259
280
                                         sys_default_init_connect,0);
 
281
static sys_var_const    sys_init_file(&vars, "init_file",
 
282
                                      OPT_GLOBAL, SHOW_CHAR_PTR,
 
283
                                      (uchar*) &opt_init_file);
260
284
sys_var_str             sys_init_slave(&vars, "init_slave", 0,
261
285
                                       sys_update_init_slave,
262
286
                                       sys_default_init_slave,0);
274
298
static sys_var_key_cache_long  sys_key_cache_age_threshold(&vars, "key_cache_age_threshold",
275
299
                                                     offsetof(KEY_CACHE,
276
300
                                                              param_age_threshold));
 
301
static sys_var_const    sys_language(&vars, "language",
 
302
                                     OPT_GLOBAL, SHOW_CHAR,
 
303
                                     (uchar*) language);
 
304
static sys_var_const    sys_large_files_support(&vars, "large_files_support",
 
305
                                                OPT_GLOBAL, SHOW_BOOL,
 
306
                                                (uchar*) &opt_large_files);
 
307
static sys_var_const    sys_large_page_size(&vars, "large_page_size",
 
308
                                            OPT_GLOBAL, SHOW_INT,
 
309
                                            (uchar*) &opt_large_page_size);
 
310
static sys_var_const    sys_large_pages(&vars, "large_pages",
 
311
                                        OPT_GLOBAL, SHOW_MY_BOOL,
 
312
                                        (uchar*) &opt_large_pages);
277
313
static sys_var_bool_ptr sys_local_infile(&vars, "local_infile",
278
314
                                         &opt_local_infile);
 
315
#ifdef HAVE_MLOCKALL
 
316
static sys_var_const    sys_locked_in_memory(&vars, "locked_in_memory",
 
317
                                             OPT_GLOBAL, SHOW_MY_BOOL,
 
318
                                             (uchar*) &locked_in_memory);
 
319
#endif
 
320
static sys_var_const    sys_log_bin(&vars, "log_bin",
 
321
                                    OPT_GLOBAL, SHOW_BOOL,
 
322
                                    (uchar*) &opt_bin_log);
279
323
static sys_var_trust_routine_creators
280
324
sys_trust_routine_creators(&vars, "log_bin_trust_routine_creators",
281
325
                           &trust_function_creators);
282
326
static sys_var_bool_ptr       
283
327
sys_trust_function_creators(&vars, "log_bin_trust_function_creators",
284
328
                            &trust_function_creators);
 
329
static sys_var_const    sys_log_error(&vars, "log_error",
 
330
                                      OPT_GLOBAL, SHOW_CHAR,
 
331
                                      (uchar*) log_error_file);
285
332
static sys_var_bool_ptr
286
333
  sys_log_queries_not_using_indexes(&vars, "log_queries_not_using_indexes",
287
334
                                    &opt_log_queries_not_using_indexes);
296
343
                                                     &SV::low_priority_updates,
297
344
                                                     fix_low_priority_updates);
298
345
#endif
299
 
static sys_var_thd_ulong        sys_max_allowed_packet(&vars, "max_allowed_packet",
 
346
static sys_var_const    sys_lower_case_file_system(&vars,
 
347
                                                   "lower_case_file_system",
 
348
                                                   OPT_GLOBAL, SHOW_MY_BOOL,
 
349
                                                   (uchar*)
 
350
                                                   &lower_case_file_system);
 
351
static sys_var_const    sys_lower_case_table_names(&vars,
 
352
                                                   "lower_case_table_names",
 
353
                                                   OPT_GLOBAL, SHOW_INT,
 
354
                                                   (uchar*)
 
355
                                                   &lower_case_table_names);
 
356
static sys_var_thd_ulong_session_readonly sys_max_allowed_packet(&vars, "max_allowed_packet",
300
357
                                               &SV::max_allowed_packet);
301
358
static sys_var_long_ptr sys_max_binlog_cache_size(&vars, "max_binlog_cache_size",
302
359
                                                  &max_binlog_cache_size);
359
416
static sys_var_long_ptr sys_myisam_data_pointer_size(&vars, "myisam_data_pointer_size",
360
417
                                                    &myisam_data_pointer_size);
361
418
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);
 
419
static sys_var_const sys_myisam_recover_options(&vars, "myisam_recover_options",
 
420
                                                OPT_GLOBAL, SHOW_CHAR_PTR,
 
421
                                                (uchar*)
 
422
                                                &myisam_recover_options_str);
362
423
static sys_var_thd_ulong       sys_myisam_repair_threads(&vars, "myisam_repair_threads", &SV::myisam_repair_threads);
363
424
static sys_var_thd_ulong        sys_myisam_sort_buffer_size(&vars, "myisam_sort_buffer_size", &SV::myisam_sort_buff_size);
364
425
static sys_var_bool_ptr sys_myisam_use_mmap(&vars, "myisam_use_mmap",
369
430
                                                &myisam_stats_method_typelib,
370
431
                                                NULL);
371
432
 
372
 
static sys_var_thd_ulong        sys_net_buffer_length(&vars, "net_buffer_length",
 
433
#ifdef __NT__
 
434
/* purecov: begin inspected */
 
435
static sys_var_const            sys_named_pipe(&vars, "named_pipe",
 
436
                                               OPT_GLOBAL, SHOW_MY_BOOL,
 
437
                                               (uchar*) &opt_enable_named_pipe);
 
438
/* purecov: end */
 
439
#endif
 
440
static sys_var_thd_ulong_session_readonly sys_net_buffer_length(&vars, "net_buffer_length",
373
441
                                              &SV::net_buffer_length);
374
442
static sys_var_thd_ulong        sys_net_read_timeout(&vars, "net_read_timeout",
375
443
                                             &SV::net_read_timeout,
387
455
sys_var_thd_bool                sys_old_alter_table(&vars, "old_alter_table",
388
456
                                            &SV::old_alter_table);
389
457
sys_var_thd_bool                sys_old_passwords(&vars, "old_passwords", &SV::old_passwords);
 
458
static sys_var_const            sys_open_files_limit(&vars, "open_files_limit",
 
459
                                                     OPT_GLOBAL, SHOW_LONG,
 
460
                                                     (uchar*)
 
461
                                                     &open_files_limit);
390
462
static sys_var_thd_ulong        sys_optimizer_prune_level(&vars, "optimizer_prune_level",
391
463
                                                  &SV::optimizer_prune_level);
392
464
static sys_var_thd_ulong        sys_optimizer_search_depth(&vars, "optimizer_search_depth",
393
465
                                                   &SV::optimizer_search_depth);
 
466
static sys_var_const            sys_pid_file(&vars, "pid_file",
 
467
                                             OPT_GLOBAL, SHOW_CHAR,
 
468
                                             (uchar*) pidfile_name);
 
469
static sys_var_const_os         sys_plugin_dir(&vars, "plugin_dir",
 
470
                                               OPT_GLOBAL, SHOW_CHAR,
 
471
                                               (uchar*) opt_plugin_dir);
 
472
static sys_var_const            sys_port(&vars, "port",
 
473
                                         OPT_GLOBAL, SHOW_INT,
 
474
                                         (uchar*) &mysqld_port);
394
475
static sys_var_thd_ulong        sys_preload_buff_size(&vars, "preload_buffer_size",
395
476
                                              &SV::preload_buff_size);
 
477
static sys_var_const            sys_protocol_version(&vars, "protocol_version",
 
478
                                                     OPT_GLOBAL, SHOW_INT,
 
479
                                                     (uchar*)
 
480
                                                     &protocol_version);
396
481
static sys_var_thd_ulong        sys_read_buff_size(&vars, "read_buffer_size",
397
482
                                           &SV::read_buff_size);
398
483
static sys_var_opt_readonly     sys_readonly(&vars, "read_only", &opt_readonly);
414
499
static sys_var_thd_ulong        sys_query_prealloc_size(&vars, "query_prealloc_size",
415
500
                                                &SV::query_prealloc_size,
416
501
                                                0, fix_thd_mem_root);
417
 
static sys_var_readonly        sys_tmpdir(&vars, "tmpdir", OPT_GLOBAL, SHOW_CHAR, get_tmpdir);
 
502
#ifdef HAVE_SMEM
 
503
/* purecov: begin tested */
 
504
static sys_var_const    sys_shared_memory(&vars, "shared_memory",
 
505
                                          OPT_GLOBAL, SHOW_MY_BOOL,
 
506
                                          (uchar*)
 
507
                                          &opt_enable_shared_memory);
 
508
static sys_var_const    sys_shared_memory_base_name(&vars,
 
509
                                                    "shared_memory_base_name",
 
510
                                                    OPT_GLOBAL, SHOW_CHAR_PTR,
 
511
                                                    (uchar*)
 
512
                                                    &shared_memory_base_name);
 
513
/* purecov: end */
 
514
#endif
 
515
static sys_var_const    sys_skip_external_locking(&vars,
 
516
                                                  "skip_external_locking",
 
517
                                                  OPT_GLOBAL, SHOW_MY_BOOL,
 
518
                                                  (uchar*)
 
519
                                                  &my_disable_locking);
 
520
static sys_var_const    sys_skip_networking(&vars, "skip_networking",
 
521
                                            OPT_GLOBAL, SHOW_BOOL,
 
522
                                            (uchar*) &opt_disable_networking);
 
523
static sys_var_const    sys_skip_show_database(&vars, "skip_show_database",
 
524
                                            OPT_GLOBAL, SHOW_BOOL,
 
525
                                            (uchar*) &opt_skip_show_db);
 
526
#ifdef HAVE_SYS_UN_H
 
527
static sys_var_const    sys_socket(&vars, "socket",
 
528
                                   OPT_GLOBAL, SHOW_CHAR_PTR,
 
529
                                   (uchar*) &mysqld_unix_port);
 
530
#endif
 
531
#ifdef HAVE_THR_SETCONCURRENCY
 
532
/* purecov: begin tested */
 
533
static sys_var_const    sys_thread_concurrency(&vars, "thread_concurrency",
 
534
                                               OPT_GLOBAL, SHOW_LONG,
 
535
                                               (uchar*) &concurrency);
 
536
/* purecov: end */
 
537
#endif
 
538
static sys_var_const    sys_thread_stack(&vars, "thread_stack",
 
539
                                         OPT_GLOBAL, SHOW_LONG,
 
540
                                         (uchar*) &my_thread_stack_size);
 
541
static sys_var_readonly_os      sys_tmpdir(&vars, "tmpdir", OPT_GLOBAL, SHOW_CHAR, get_tmpdir);
418
542
static sys_var_thd_ulong        sys_trans_alloc_block_size(&vars, "transaction_alloc_block_size",
419
543
                                                   &SV::trans_alloc_block_size,
420
544
                                                   0, fix_trans_mem_root);
465
589
#ifdef HAVE_OPENSSL
466
590
extern char *opt_ssl_ca, *opt_ssl_capath, *opt_ssl_cert, *opt_ssl_cipher,
467
591
            *opt_ssl_key;
468
 
static sys_var_const_str_ptr    sys_ssl_ca(&vars, "ssl_ca", &opt_ssl_ca);
469
 
static sys_var_const_str_ptr    sys_ssl_capath(&vars, "ssl_capath", &opt_ssl_capath);
470
 
static sys_var_const_str_ptr    sys_ssl_cert(&vars, "ssl_cert", &opt_ssl_cert);
471
 
static sys_var_const_str_ptr    sys_ssl_cipher(&vars, "ssl_cipher", &opt_ssl_cipher);
472
 
static sys_var_const_str_ptr    sys_ssl_key(&vars, "ssl_key", &opt_ssl_key);
 
592
static sys_var_const_os_str_ptr sys_ssl_ca(&vars, "ssl_ca", &opt_ssl_ca);
 
593
static sys_var_const_os_str_ptr sys_ssl_capath(&vars, "ssl_capath", &opt_ssl_capath);
 
594
static sys_var_const_os_str_ptr sys_ssl_cert(&vars, "ssl_cert", &opt_ssl_cert);
 
595
static sys_var_const_os_str_ptr sys_ssl_cipher(&vars, "ssl_cipher", &opt_ssl_cipher);
 
596
static sys_var_const_os_str_ptr sys_ssl_key(&vars, "ssl_key", &opt_ssl_key);
473
597
#else
474
 
static sys_var_const_str        sys_ssl_ca(&vars, "ssl_ca", NULL);
475
 
static sys_var_const_str        sys_ssl_capath(&vars, "ssl_capath", NULL);
476
 
static sys_var_const_str        sys_ssl_cert(&vars, "ssl_cert", NULL);
477
 
static sys_var_const_str        sys_ssl_cipher(&vars, "ssl_cipher", NULL);
478
 
static sys_var_const_str        sys_ssl_key(&vars, "ssl_key", NULL);
 
598
static sys_var_const_os_str     sys_ssl_ca(&vars, "ssl_ca", NULL);
 
599
static sys_var_const_os_str     sys_ssl_capath(&vars, "ssl_capath", NULL);
 
600
static sys_var_const_os_str     sys_ssl_cert(&vars, "ssl_cert", NULL);
 
601
static sys_var_const_os_str     sys_ssl_cipher(&vars, "ssl_cipher", NULL);
 
602
static sys_var_const_os_str     sys_ssl_key(&vars, "ssl_key", NULL);
479
603
#endif
480
604
static sys_var_thd_enum
481
605
sys_updatable_views_with_limit(&vars, "updatable_views_with_limit",
764
888
                                            &log_output_typelib, 0);
765
889
 
766
890
 
767
 
/*
768
 
  Additional variables (not derived from sys_var class, not accessible as
769
 
  @@varname in SELECT or SET). Sorted in alphabetical order to facilitate
770
 
  maintenance - SHOW VARIABLES will sort its output.
771
 
  TODO: remove this list completely
772
 
*/
773
 
 
774
 
#define FIXED_VARS_SIZE (sizeof(fixed_vars) / sizeof(SHOW_VAR))
775
 
static SHOW_VAR fixed_vars[]= {
776
 
  {"back_log",                (char*) &back_log,                    SHOW_LONG},
777
 
  {"character_sets_dir",      mysql_charsets_dir,                   SHOW_CHAR},
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},
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},
786
 
  {"large_pages",             (char*) &opt_large_pages,             SHOW_MY_BOOL},
787
 
#ifdef HAVE_MLOCKALL
788
 
  {"locked_in_memory",        (char*) &locked_in_memory,            SHOW_MY_BOOL},
789
 
#endif
790
 
  {"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
 
  {"lower_case_table_names",  (char*) &lower_case_table_names,      SHOW_INT},
794
 
  {"myisam_recover_options",  (char*) &myisam_recover_options_str,  SHOW_CHAR_PTR},
795
 
#ifdef __NT__
796
 
  {"named_pipe",              (char*) &opt_enable_named_pipe,       SHOW_MY_BOOL},
797
 
#endif
798
 
  {"open_files_limit",        (char*) &open_files_limit,            SHOW_LONG},
799
 
  {"pid_file",                (char*) pidfile_name,                 SHOW_CHAR},
800
 
  {"plugin_dir",              (char*) opt_plugin_dir,               SHOW_CHAR},
801
 
  {"port",                    (char*) &mysqld_port,                 SHOW_INT},
802
 
  {"protocol_version",        (char*) &protocol_version,            SHOW_INT},
803
 
#ifdef HAVE_SMEM
804
 
  {"shared_memory",           (char*) &opt_enable_shared_memory,    SHOW_MY_BOOL},
805
 
  {"shared_memory_base_name", (char*) &shared_memory_base_name,     SHOW_CHAR_PTR},
806
 
#endif
807
 
  {"skip_external_locking",   (char*) &my_disable_locking,          SHOW_MY_BOOL},
808
 
  {"skip_networking",         (char*) &opt_disable_networking,      SHOW_BOOL},
809
 
  {"skip_show_database",      (char*) &opt_skip_show_db,            SHOW_BOOL},
810
 
#ifdef HAVE_SYS_UN_H
811
 
  {"socket",                  (char*) &mysqld_unix_port,            SHOW_CHAR_PTR},
812
 
#endif
813
 
#ifdef HAVE_THR_SETCONCURRENCY
814
 
  {"thread_concurrency",      (char*) &concurrency,                 SHOW_LONG},
815
 
#endif
816
 
  {"thread_stack",            (char*) &my_thread_stack_size,        SHOW_LONG},
817
 
};
818
 
 
819
 
 
820
891
bool sys_var::check(THD *thd, set_var *var)
821
892
{
822
893
  var->save_result.ulonglong_value= var->value->val_int();
865
936
  old_value= var_str->value;
866
937
  var_str->value= res;
867
938
  var_str->value_length= new_length;
 
939
  var_str->is_os_charset= FALSE;
868
940
  rw_unlock(var_mutex);
869
941
  my_free(old_value, MYF(MY_ALLOW_ZERO_PTR));
870
942
  return 0;
1455
1527
  ulonglong tmp= var->save_result.ulonglong_value;
1456
1528
 
1457
1529
  /* Don't use bigger value than given with --maximum-variable-name=.. */
1458
 
  if ((ulong) tmp > max_system_variables.*offset)
 
1530
  if (tmp > max_system_variables.*offset)
1459
1531
  {
1460
1532
    throw_bounds_warning(thd, TRUE, TRUE, name, (longlong) tmp);
1461
1533
    tmp= max_system_variables.*offset;
1462
1534
  }
1463
1535
 
1464
1536
  if (option_limits)
1465
 
    tmp= (ulong) fix_unsigned(thd, tmp, option_limits);
 
1537
    tmp= fix_unsigned(thd, tmp, option_limits);
1466
1538
#if SIZEOF_LONG < SIZEOF_LONG_LONG
1467
1539
  else if (tmp > ULONG_MAX)
1468
1540
  {
1471
1543
  }
1472
1544
#endif
1473
1545
 
 
1546
  DBUG_ASSERT(tmp <= ULONG_MAX);
1474
1547
  if (var->type == OPT_GLOBAL)
1475
1548
    global_system_variables.*offset= (ulong) tmp;
1476
1549
  else
1734
1807
}
1735
1808
 
1736
1809
 
1737
 
/**
1738
 
  Return an Item for a variable.
1739
 
 
1740
 
  Used with @@[global.]variable_name.
1741
 
 
1742
 
  If type is not given, return local value if exists, else global.
1743
 
*/
1744
 
 
1745
 
Item *sys_var::item(THD *thd, enum_var_type var_type, LEX_STRING *base)
 
1810
CHARSET_INFO *sys_var::charset(THD *thd)
1746
1811
{
1747
 
  if (check_type(var_type))
1748
 
  {
1749
 
    if (var_type != OPT_DEFAULT)
1750
 
    {
1751
 
      my_error(ER_INCORRECT_GLOBAL_LOCAL_VAR, MYF(0),
1752
 
               name, var_type == OPT_GLOBAL ? "SESSION" : "GLOBAL");
1753
 
      return 0;
1754
 
    }
1755
 
    /* As there was no local variable, return the global value */
1756
 
    var_type= OPT_GLOBAL;
1757
 
  }
1758
 
  switch (show_type()) {
1759
 
  case SHOW_INT:
1760
 
  {
1761
 
    uint value;
1762
 
    pthread_mutex_lock(&LOCK_global_system_variables);
1763
 
    value= *(uint*) value_ptr(thd, var_type, base);
1764
 
    pthread_mutex_unlock(&LOCK_global_system_variables);
1765
 
    return new Item_uint((ulonglong) value);
1766
 
  }
1767
 
  case SHOW_LONG:
1768
 
  {
1769
 
    ulong value;
1770
 
    pthread_mutex_lock(&LOCK_global_system_variables);
1771
 
    value= *(ulong*) value_ptr(thd, var_type, base);
1772
 
    pthread_mutex_unlock(&LOCK_global_system_variables);
1773
 
    return new Item_uint((ulonglong) value);
1774
 
  }
1775
 
  case SHOW_LONGLONG:
1776
 
  {
1777
 
    longlong value;
1778
 
    pthread_mutex_lock(&LOCK_global_system_variables);
1779
 
    value= *(longlong*) value_ptr(thd, var_type, base);
1780
 
    pthread_mutex_unlock(&LOCK_global_system_variables);
1781
 
    return new Item_int(value);
1782
 
  }
1783
 
  case SHOW_DOUBLE:
1784
 
  {
1785
 
    double value;
1786
 
    pthread_mutex_lock(&LOCK_global_system_variables);
1787
 
    value= *(double*) value_ptr(thd, var_type, base);
1788
 
    pthread_mutex_unlock(&LOCK_global_system_variables);
1789
 
    /* 6, as this is for now only used with microseconds */
1790
 
    return new Item_float(value, 6);
1791
 
  }
1792
 
  case SHOW_HA_ROWS:
1793
 
  {
1794
 
    ha_rows value;
1795
 
    pthread_mutex_lock(&LOCK_global_system_variables);
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
 
  }
1800
 
  case SHOW_MY_BOOL:
1801
 
  {
1802
 
    int32 value;
1803
 
    pthread_mutex_lock(&LOCK_global_system_variables);
1804
 
    value= *(my_bool*) value_ptr(thd, var_type, base);
1805
 
    pthread_mutex_unlock(&LOCK_global_system_variables);
1806
 
    return new Item_int(value,1);
1807
 
  }
1808
 
  case SHOW_CHAR_PTR:
1809
 
  {
1810
 
    Item *tmp;
1811
 
    pthread_mutex_lock(&LOCK_global_system_variables);
1812
 
    char *str= *(char**) value_ptr(thd, var_type, base);
1813
 
    if (str)
1814
 
    {
1815
 
      uint length= strlen(str);
1816
 
      tmp= new Item_string(thd->strmake(str, length), length,
1817
 
                           system_charset_info, DERIVATION_SYSCONST);
1818
 
    }
1819
 
    else
1820
 
    {
1821
 
      tmp= new Item_null();
1822
 
      tmp->collation.set(system_charset_info, DERIVATION_SYSCONST);
1823
 
    }
1824
 
    pthread_mutex_unlock(&LOCK_global_system_variables);
1825
 
    return tmp;
1826
 
  }
1827
 
  case SHOW_CHAR:
1828
 
  {
1829
 
    Item *tmp;
1830
 
    pthread_mutex_lock(&LOCK_global_system_variables);
1831
 
    char *str= (char*) value_ptr(thd, var_type, base);
1832
 
    if (str)
1833
 
      tmp= new Item_string(str, strlen(str),
1834
 
                           system_charset_info, DERIVATION_SYSCONST);
1835
 
    else
1836
 
    {
1837
 
      tmp= new Item_null();
1838
 
      tmp->collation.set(system_charset_info, DERIVATION_SYSCONST);
1839
 
    }
1840
 
    pthread_mutex_unlock(&LOCK_global_system_variables);
1841
 
    return tmp;
1842
 
  }
1843
 
  default:
1844
 
    my_error(ER_VAR_CANT_BE_READ, MYF(0), name);
1845
 
  }
1846
 
  return 0;
 
1812
  return is_os_charset ? thd->variables.character_set_filesystem : 
 
1813
    system_charset_info;
1847
1814
}
1848
1815
 
1849
1816
 
2847
2814
}
2848
2815
 
2849
2816
 
 
2817
bool sys_var_thd_ulong_session_readonly::check(THD *thd, set_var *var)
 
2818
{
 
2819
  if (var->type != OPT_GLOBAL)
 
2820
  {
 
2821
    my_error(ER_VARIABLE_IS_READONLY, MYF(0), "SESSION", name, "GLOBAL");
 
2822
    return TRUE;
 
2823
  }
 
2824
 
 
2825
  return sys_var_thd_ulong::check(thd, var);
 
2826
}
 
2827
 
 
2828
 
2850
2829
bool sys_var_thd_lc_time_names::check(THD *thd, set_var *var)
2851
2830
{
2852
2831
  MY_LOCALE *locale_match;
3236
3215
SHOW_VAR* enumerate_sys_vars(THD *thd, bool sorted)
3237
3216
{
3238
3217
  int count= system_variable_hash.records, i;
3239
 
  int fixed_count= fixed_show_vars.elements;
3240
 
  int size= sizeof(SHOW_VAR) * (count + fixed_count + 1);
 
3218
  int size= sizeof(SHOW_VAR) * (count + 1);
3241
3219
  SHOW_VAR *result= (SHOW_VAR*) thd->alloc(size);
3242
3220
 
3243
3221
  if (result)
3244
3222
  {
3245
 
    SHOW_VAR *show= result + fixed_count;
3246
 
    memcpy(result, fixed_show_vars.buffer, fixed_count * sizeof(SHOW_VAR));
 
3223
    SHOW_VAR *show= result;
3247
3224
 
3248
3225
    for (i= 0; i < count; i++)
3249
3226
    {
3256
3233
 
3257
3234
    /* sort into order */
3258
3235
    if (sorted)
3259
 
      my_qsort(result, count + fixed_count, sizeof(SHOW_VAR),
 
3236
      my_qsort(result, count, sizeof(SHOW_VAR),
3260
3237
               (qsort_cmp) show_cmp);
3261
3238
    
3262
3239
    /* make last element empty */
3284
3261
  
3285
3262
  for (sys_var *var=vars.first; var; var= var->next, count++);
3286
3263
 
3287
 
  if (my_init_dynamic_array(&fixed_show_vars, sizeof(SHOW_VAR),
3288
 
                            FIXED_VARS_SIZE + 64, 64))
3289
 
    goto error;
3290
 
 
3291
 
  fixed_show_vars.elements= FIXED_VARS_SIZE;
3292
 
  memcpy(fixed_show_vars.buffer, fixed_vars, sizeof(fixed_vars));
3293
 
 
3294
3264
  if (hash_init(&system_variable_hash, system_charset_info, count, 0,
3295
3265
                0, (hash_get_key) get_sys_var_length, 0, HASH_UNIQUE))
3296
3266
    goto error;
3318
3288
void set_var_free()
3319
3289
{
3320
3290
  hash_free(&system_variable_hash);
3321
 
  delete_dynamic(&fixed_show_vars);
3322
 
}
3323
 
 
3324
 
 
3325
 
/*
3326
 
  Add elements to the dynamic list of read-only system variables.
3327
 
  
3328
 
  SYNOPSIS
3329
 
    mysql_append_static_vars()
3330
 
    show_vars   Pointer to start of array
3331
 
    count       Number of elements
3332
 
  
3333
 
  RETURN VALUES
3334
 
    0           SUCCESS
3335
 
    otherwise   FAILURE
3336
 
*/
3337
 
int mysql_append_static_vars(const SHOW_VAR *show_vars, uint count)
3338
 
{
3339
 
  for (; count > 0; count--, show_vars++)
3340
 
    if (insert_dynamic(&fixed_show_vars, (uchar*) show_vars))
3341
 
      return 1;
3342
 
  return 0;
3343
3291
}
3344
3292
 
3345
3293
 
3601
3549
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3602
3550
  if (!user->host.str)
3603
3551
  {
 
3552
    DBUG_ASSERT(thd->security_ctx->priv_host);
3604
3553
    if (*thd->security_ctx->priv_host != 0)
3605
3554
    {
3606
3555
      user->host.str= (char *) thd->security_ctx->priv_host;
3612
3561
      user->host.length= 1;
3613
3562
    }
3614
3563
  }
 
3564
  if (!user->user.str)
 
3565
  {
 
3566
    DBUG_ASSERT(thd->security_ctx->priv_user);
 
3567
    user->user.str= (char *) thd->security_ctx->priv_user;
 
3568
    user->user.length= strlen(thd->security_ctx->priv_user);
 
3569
  }
3615
3570
  /* Returns 1 as the function sends error to client */
3616
3571
  return check_change_password(thd, user->host.str, user->user.str,
3617
3572
                               password, strlen(password)) ? 1 : 0;