← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/set_var.cc

  • Committer: Jay Pipes
  • Date: 2009-09-21 14:33:44 UTC
  • mfrom: (1126.10.26 dtrace-probes)
  • mto: This revision was merged to the branch mainline in revision 1133.
  • Revision ID: jpipes@serialcoder-20090921143344-jnarp7gcn6zmg19c
Merge fixes from Trond and Padraig on dtrace probes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/set_var.cc
29
29
  - If the variable is thread specific, add it to 'system_variables' struct.
30
30
    If not, add it to mysqld.cc and an declaration in 'mysql_priv.h'
31
31
  - If the variable should be changed from the command line, add a definition
32
 
    of it in the option structure list in mysqld.cc
 
32
    of it in the my_option structure list in mysqld.cc
33
33
  - Don't forget to initialize new fields in global_system_variables and
34
34
    max_system_variables!
35
35
 
43
43
    example).
44
44
*/
45
45
 
46
 
#include "config.h"
47
 
#include "drizzled/option.h"
 
46
#include <drizzled/server_includes.h>
 
47
#include <mysys/my_getopt.h>
 
48
#include <plugin/myisam/myisam.h>
48
49
#include <drizzled/error.h>
49
50
#include <drizzled/gettext.h>
50
51
#include <drizzled/tztime.h>
56
57
#include <drizzled/item/uint.h>
57
58
#include <drizzled/item/null.h>
58
59
#include <drizzled/item/float.h>
59
 
#include <drizzled/plugin.h>
60
 
#include "drizzled/version.h"
61
 
#include "drizzled/strfunc.h"
62
 
#include "drizzled/internal/m_string.h"
63
 
#include "drizzled/pthread_globals.h"
64
 
#include "drizzled/charset.h"
65
 
#include "drizzled/transaction_services.h"
 
60
#include <drizzled/sql_plugin.h>
66
61
 
 
62
#include "drizzled/registry.h"
67
63
#include <map>
68
64
#include <algorithm>
69
65
 
70
66
using namespace std;
71
67
 
72
 
namespace drizzled
73
 
{
74
 
 
75
 
namespace internal
76
 
{
77
 
extern bool timed_mutexes;
78
 
}
79
 
 
80
 
extern plugin::StorageEngine *myisam_engine;
81
 
extern bool timed_mutexes;
82
 
 
83
 
extern struct option my_long_options[];
84
68
extern const CHARSET_INFO *character_set_filesystem;
85
69
extern size_t my_thread_stack_size;
86
70
 
87
71
class sys_var_pluginvar;
88
72
static DYNAMIC_ARRAY fixed_show_vars;
89
 
typedef map<string, sys_var *> SystemVariableMap;
90
 
static SystemVariableMap system_variable_map;
 
73
static drizzled::Registry<sys_var *> system_variable_hash;
91
74
extern char *opt_drizzle_tmpdir;
92
75
 
93
 
extern TYPELIB tx_isolation_typelib;
94
 
 
95
76
const char *bool_type_names[]= { "OFF", "ON", NULL };
96
77
TYPELIB bool_typelib=
97
78
{
102
83
static bool set_option_autocommit(Session *session, set_var *var);
103
84
static int  check_pseudo_thread_id(Session *session, set_var *var);
104
85
static int check_tx_isolation(Session *session, set_var *var);
105
 
static void fix_tx_isolation(Session *session, sql_var_t type);
 
86
static void fix_tx_isolation(Session *session, enum_var_type type);
106
87
static int check_completion_type(Session *session, set_var *var);
107
 
static void fix_completion_type(Session *session, sql_var_t type);
108
 
static void fix_max_join_size(Session *session, sql_var_t type);
109
 
static void fix_session_mem_root(Session *session, sql_var_t type);
110
 
static void fix_server_id(Session *session, sql_var_t type);
 
88
static void fix_completion_type(Session *session, enum_var_type type);
 
89
static void fix_max_join_size(Session *session, enum_var_type type);
 
90
static void fix_session_mem_root(Session *session, enum_var_type type);
 
91
static void fix_trans_mem_root(Session *session, enum_var_type type);
 
92
static void fix_server_id(Session *session, enum_var_type type);
 
93
static uint64_t fix_unsigned(Session *, uint64_t, const struct my_option *);
111
94
static bool get_unsigned32(Session *session, set_var *var);
112
95
static bool get_unsigned64(Session *session, set_var *var);
113
96
bool throw_bounds_warning(Session *session, bool fixed, bool unsignd,
129
112
 
130
113
static sys_var_session_uint64_t
131
114
sys_auto_increment_increment(&vars, "auto_increment_increment",
132
 
                             &system_variables::auto_increment_increment);
 
115
                             &SV::auto_increment_increment);
133
116
static sys_var_session_uint64_t
134
117
sys_auto_increment_offset(&vars, "auto_increment_offset",
135
 
                          &system_variables::auto_increment_offset);
 
118
                          &SV::auto_increment_offset);
136
119
 
137
120
static sys_var_const_str       sys_basedir(&vars, "basedir", drizzle_home);
138
121
static sys_var_session_uint64_t sys_bulk_insert_buff_size(&vars, "bulk_insert_buffer_size",
139
 
                                                          &system_variables::bulk_insert_buff_size);
 
122
                                                          &SV::bulk_insert_buff_size);
140
123
static sys_var_session_uint32_t sys_completion_type(&vars, "completion_type",
141
 
                                                    &system_variables::completion_type,
 
124
                                                    &SV::completion_type,
142
125
                                                    check_completion_type,
143
126
                                                    fix_completion_type);
144
127
static sys_var_collation_sv
145
 
sys_collation_server(&vars, "collation_server", &system_variables::collation_server, &default_charset_info);
 
128
sys_collation_server(&vars, "collation_server", &SV::collation_server, &default_charset_info);
146
129
static sys_var_const_str       sys_datadir(&vars, "datadir", drizzle_real_data_home);
147
130
 
148
131
static sys_var_session_uint64_t sys_join_buffer_size(&vars, "join_buffer_size",
149
 
                                                     &system_variables::join_buff_size);
 
132
                                                     &SV::join_buff_size);
 
133
static sys_var_key_buffer_size  sys_key_buffer_size(&vars, "key_buffer_size");
 
134
static sys_var_key_cache_uint32_t  sys_key_cache_block_size(&vars, "key_cache_block_size",
 
135
                                                        offsetof(KEY_CACHE,
 
136
                                                                 param_block_size));
 
137
static sys_var_key_cache_uint32_t       sys_key_cache_division_limit(&vars, "key_cache_division_limit",
 
138
                                                           offsetof(KEY_CACHE,
 
139
                                                                    param_division_limit));
 
140
static sys_var_key_cache_uint32_t  sys_key_cache_age_threshold(&vars, "key_cache_age_threshold",
 
141
                                                           offsetof(KEY_CACHE,
 
142
                                                                    param_age_threshold));
150
143
static sys_var_session_uint32_t sys_max_allowed_packet(&vars, "max_allowed_packet",
151
 
                                                       &system_variables::max_allowed_packet);
 
144
                                                       &SV::max_allowed_packet);
152
145
static sys_var_uint64_t_ptr     sys_max_connect_errors(&vars, "max_connect_errors",
153
146
                                               &max_connect_errors);
154
147
static sys_var_session_uint64_t sys_max_error_count(&vars, "max_error_count",
155
 
                                                  &system_variables::max_error_count);
 
148
                                                  &SV::max_error_count);
156
149
static sys_var_session_uint64_t sys_max_heap_table_size(&vars, "max_heap_table_size",
157
 
                                                        &system_variables::max_heap_table_size);
 
150
                                                        &SV::max_heap_table_size);
158
151
static sys_var_session_uint64_t sys_pseudo_thread_id(&vars, "pseudo_thread_id",
159
 
                                              &system_variables::pseudo_thread_id,
 
152
                                              &SV::pseudo_thread_id,
160
153
                                              0, check_pseudo_thread_id);
161
154
static sys_var_session_ha_rows  sys_max_join_size(&vars, "max_join_size",
162
 
                                                  &system_variables::max_join_size,
 
155
                                                  &SV::max_join_size,
163
156
                                                  fix_max_join_size);
164
157
static sys_var_session_uint64_t sys_max_seeks_for_key(&vars, "max_seeks_for_key",
165
 
                                                      &system_variables::max_seeks_for_key);
 
158
                                                      &SV::max_seeks_for_key);
166
159
static sys_var_session_uint64_t   sys_max_length_for_sort_data(&vars, "max_length_for_sort_data",
167
 
                                                               &system_variables::max_length_for_sort_data);
 
160
                                                               &SV::max_length_for_sort_data);
168
161
static sys_var_session_size_t   sys_max_sort_length(&vars, "max_sort_length",
169
 
                                                    &system_variables::max_sort_length);
 
162
                                                    &SV::max_sort_length);
170
163
static sys_var_uint64_t_ptr     sys_max_write_lock_count(&vars, "max_write_lock_count",
171
164
                                                 &max_write_lock_count);
172
165
static sys_var_session_uint64_t sys_min_examined_row_limit(&vars, "min_examined_row_limit",
173
 
                                                           &system_variables::min_examined_row_limit);
 
166
                                                           &SV::min_examined_row_limit);
174
167
 
 
168
static sys_var_session_uint32_t sys_net_buffer_length(&vars, "net_buffer_length",
 
169
                                                      &SV::net_buffer_length);
175
170
/* these two cannot be static */
176
171
static sys_var_session_bool sys_optimizer_prune_level(&vars, "optimizer_prune_level",
177
 
                                                      &system_variables::optimizer_prune_level);
 
172
                                                      &SV::optimizer_prune_level);
178
173
static sys_var_session_uint32_t sys_optimizer_search_depth(&vars, "optimizer_search_depth",
179
 
                                                           &system_variables::optimizer_search_depth);
 
174
                                                           &SV::optimizer_search_depth);
180
175
 
181
176
static sys_var_session_uint64_t sys_preload_buff_size(&vars, "preload_buffer_size",
182
 
                                                      &system_variables::preload_buff_size);
 
177
                                                      &SV::preload_buff_size);
183
178
static sys_var_session_uint32_t sys_read_buff_size(&vars, "read_buffer_size",
184
 
                                                   &system_variables::read_buff_size);
 
179
                                                   &SV::read_buff_size);
185
180
static sys_var_session_uint32_t sys_read_rnd_buff_size(&vars, "read_rnd_buffer_size",
186
 
                                                       &system_variables::read_rnd_buff_size);
 
181
                                                       &SV::read_rnd_buff_size);
187
182
static sys_var_session_uint32_t sys_div_precincrement(&vars, "div_precision_increment",
188
 
                                                      &system_variables::div_precincrement);
 
183
                                                      &SV::div_precincrement);
189
184
 
190
185
static sys_var_session_size_t   sys_range_alloc_block_size(&vars, "range_alloc_block_size",
191
 
                                                           &system_variables::range_alloc_block_size);
 
186
                                                           &SV::range_alloc_block_size);
192
187
static sys_var_session_uint32_t sys_query_alloc_block_size(&vars, "query_alloc_block_size",
193
 
                                                           &system_variables::query_alloc_block_size,
 
188
                                                           &SV::query_alloc_block_size,
194
189
                                                           false, fix_session_mem_root);
195
190
static sys_var_session_uint32_t sys_query_prealloc_size(&vars, "query_prealloc_size",
196
 
                                                        &system_variables::query_prealloc_size,
 
191
                                                        &SV::query_prealloc_size,
197
192
                                                        false, fix_session_mem_root);
198
193
static sys_var_readonly sys_tmpdir(&vars, "tmpdir", OPT_GLOBAL, SHOW_CHAR, get_tmpdir);
 
194
static sys_var_session_uint32_t sys_trans_alloc_block_size(&vars, "transaction_alloc_block_size",
 
195
                                                           &SV::trans_alloc_block_size,
 
196
                                                           false, fix_trans_mem_root);
 
197
static sys_var_session_uint32_t sys_trans_prealloc_size(&vars, "transaction_prealloc_size",
 
198
                                                        &SV::trans_prealloc_size,
 
199
                                                        false, fix_trans_mem_root);
199
200
 
200
201
static sys_var_const_str_ptr sys_secure_file_priv(&vars, "secure_file_priv",
201
202
                                             &opt_secure_file_priv);
203
204
                                           fix_server_id);
204
205
 
205
206
static sys_var_session_size_t   sys_sort_buffer(&vars, "sort_buffer_size",
206
 
                                                &system_variables::sortbuff_size);
 
207
                                                &SV::sortbuff_size);
 
208
static sys_var_session_optimizer_switch   sys_optimizer_switch(&vars, "optimizer_switch",
 
209
                                                               &SV::optimizer_switch);
207
210
 
208
211
static sys_var_session_storage_engine sys_storage_engine(&vars, "storage_engine",
209
 
                                       &system_variables::storage_engine);
 
212
                                       &SV::storage_engine);
210
213
static sys_var_const_str        sys_system_time_zone(&vars, "system_time_zone",
211
214
                                             system_time_zone);
212
 
static sys_var_size_t_ptr       sys_table_def_size(&vars, "table_definition_cache",
213
 
                                             &table_def_size);
 
215
static sys_var_uint64_t_ptr     sys_table_def_size(&vars, "table_definition_cache",
 
216
                                           &table_def_size);
214
217
static sys_var_uint64_t_ptr     sys_table_cache_size(&vars, "table_open_cache",
215
218
                                             &table_cache_size);
216
219
static sys_var_uint64_t_ptr     sys_table_lock_wait_timeout(&vars, "table_lock_wait_timeout",
217
220
                                                    &table_lock_wait_timeout);
218
221
static sys_var_session_enum     sys_tx_isolation(&vars, "tx_isolation",
219
 
                                             &system_variables::tx_isolation,
 
222
                                             &SV::tx_isolation,
220
223
                                             &tx_isolation_typelib,
221
224
                                             fix_tx_isolation,
222
225
                                             check_tx_isolation);
223
226
static sys_var_session_uint64_t sys_tmp_table_size(&vars, "tmp_table_size",
224
 
                                           &system_variables::tmp_table_size);
225
 
static sys_var_bool_ptr  sys_timed_mutexes(&vars, "timed_mutexes", &internal::timed_mutexes);
226
 
static sys_var_const_str  sys_version(&vars, "version", version().c_str());
227
 
 
 
227
                                           &SV::tmp_table_size);
 
228
static sys_var_bool_ptr  sys_timed_mutexes(&vars, "timed_mutexes", &timed_mutexes);
 
229
static sys_var_const_str        sys_version(&vars, "version", VERSION);
228
230
static sys_var_const_str        sys_version_comment(&vars, "version_comment",
229
231
                                            COMPILATION_COMMENT);
230
232
static sys_var_const_str        sys_version_compile_machine(&vars, "version_compile_machine",
249
251
static sys_var_session_bit      sys_sql_notes(&vars, "sql_notes", 0,
250
252
                                         set_option_bit,
251
253
                                         OPTION_SQL_NOTES);
 
254
static sys_var_session_bit      sys_safe_updates(&vars, "sql_safe_updates", 0,
 
255
                                         set_option_bit,
 
256
                                         OPTION_SAFE_UPDATES);
252
257
static sys_var_session_bit      sys_buffer_results(&vars, "sql_buffer_result", 0,
253
258
                                           set_option_bit,
254
259
                                           OPTION_BUFFER_RESULT);
261
266
/* Local state variables */
262
267
 
263
268
static sys_var_session_ha_rows  sys_select_limit(&vars, "sql_select_limit",
264
 
                                                 &system_variables::select_limit);
 
269
                                                 &SV::select_limit);
265
270
static sys_var_timestamp sys_timestamp(&vars, "timestamp");
266
271
static sys_var_last_insert_id
267
272
sys_last_insert_id(&vars, "last_insert_id");
295
300
                                          get_warning_count);
296
301
 
297
302
sys_var_session_uint64_t sys_group_concat_max_len(&vars, "group_concat_max_len",
298
 
                                                  &system_variables::group_concat_max_len);
 
303
                                                  &SV::group_concat_max_len);
299
304
 
300
305
sys_var_session_time_zone sys_time_zone(&vars, "time_zone");
301
306
 
302
307
/* Global read-only variable containing hostname */
303
308
static sys_var_const_str        sys_hostname(&vars, "hostname", glob_hostname);
304
309
 
 
310
/* Read only variables */
 
311
 
 
312
static sys_var_have_variable sys_have_symlink(&vars, "have_symlink", &have_symlink);
305
313
/*
306
314
  Additional variables (not derived from sys_var class, not accessible as
307
315
  @@varname in SELECT or SET). Sorted in alphabetical order to facilitate
309
317
  TODO: remove this list completely
310
318
*/
311
319
 
312
 
#define FIXED_VARS_SIZE (sizeof(fixed_vars) / sizeof(drizzle_show_var))
313
 
static drizzle_show_var fixed_vars[]= {
314
 
  {"back_log",                (char*) &back_log,                SHOW_INT},
315
 
  {"language",                language,                         SHOW_CHAR},
316
 
  {"pid_file",                (char*) pidfile_name,             SHOW_CHAR},
317
 
  {"plugin_dir",              (char*) opt_plugin_dir,           SHOW_CHAR},
318
 
  {"thread_stack",            (char*) &my_thread_stack_size,    SHOW_INT},
 
320
#define FIXED_VARS_SIZE (sizeof(fixed_vars) / sizeof(SHOW_VAR))
 
321
static SHOW_VAR fixed_vars[]= {
 
322
  {"back_log",                (char*) &back_log,                    SHOW_INT},
 
323
  {"language",                language,                             SHOW_CHAR},
 
324
#ifdef HAVE_MLOCKALL
 
325
  {"locked_in_memory",        (char*) &locked_in_memory,            SHOW_MY_BOOL},
 
326
#endif
 
327
  {"pid_file",                (char*) pidfile_name,                 SHOW_CHAR},
 
328
  {"plugin_dir",              (char*) opt_plugin_dir,               SHOW_CHAR},
 
329
  {"port",                    (char*) &drizzled_tcp_port,           SHOW_INT},
 
330
  {"thread_stack",            (char*) &my_thread_stack_size,        SHOW_INT},
319
331
};
320
332
 
321
333
bool sys_var::check(Session *, set_var *var)
344
356
  Set the OPTION_BIG_SELECTS flag if max_join_size == HA_POS_ERROR.
345
357
*/
346
358
 
347
 
static void fix_max_join_size(Session *session, sql_var_t type)
 
359
static void fix_max_join_size(Session *session, enum_var_type type)
348
360
{
349
361
  if (type != OPT_GLOBAL)
350
362
  {
374
386
  If one doesn't use the SESSION modifier, the isolation level
375
387
  is only active for the next command.
376
388
*/
377
 
static void fix_tx_isolation(Session *session, sql_var_t type)
 
389
static void fix_tx_isolation(Session *session, enum_var_type type)
378
390
{
379
391
  if (type == OPT_SESSION)
380
392
    session->session_tx_isolation= ((enum_tx_isolation)
381
393
                                    session->variables.tx_isolation);
382
394
}
383
395
 
384
 
static void fix_completion_type(Session *, sql_var_t) {}
 
396
static void fix_completion_type(Session *, enum_var_type) {}
385
397
 
386
398
static int check_completion_type(Session *, set_var *var)
387
399
{
389
401
  if (val < 0 || val > 2)
390
402
  {
391
403
    char buf[64];
392
 
    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->var->getName().c_str(), internal::llstr(val, buf));
 
404
    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->var->getName().c_str(), llstr(val, buf));
393
405
    return 1;
394
406
  }
395
407
  return 0;
396
408
}
397
409
 
398
410
 
399
 
static void fix_session_mem_root(Session *session, sql_var_t type)
 
411
static void fix_session_mem_root(Session *session, enum_var_type type)
400
412
{
401
413
  if (type != OPT_GLOBAL)
402
414
    reset_root_defaults(session->mem_root,
405
417
}
406
418
 
407
419
 
408
 
static void fix_server_id(Session *, sql_var_t)
 
420
static void fix_trans_mem_root(Session *session, enum_var_type type)
 
421
{
 
422
  if (type != OPT_GLOBAL)
 
423
    reset_root_defaults(&session->transaction.mem_root,
 
424
                        session->variables.trans_alloc_block_size,
 
425
                        session->variables.trans_prealloc_size);
 
426
}
 
427
 
 
428
 
 
429
static void fix_server_id(Session *, enum_var_type)
409
430
{
410
431
}
411
432
 
418
439
    char buf[22];
419
440
 
420
441
    if (unsignd)
421
 
      internal::ullstr((uint64_t) val, buf);
 
442
      ullstr((uint64_t) val, buf);
422
443
    else
423
 
      internal::llstr(val, buf);
 
444
      llstr(val, buf);
424
445
 
425
446
    push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
426
447
                        ER_TRUNCATED_WRONG_VALUE,
429
450
  return false;
430
451
}
431
452
 
432
 
uint64_t fix_unsigned(Session *session, uint64_t num,
433
 
                              const struct option *option_limits)
 
453
static uint64_t fix_unsigned(Session *session, uint64_t num,
 
454
                              const struct my_option *option_limits)
434
455
{
435
456
  bool fixed= false;
436
457
  uint64_t out= getopt_ull_limit_value(num, option_limits, &fixed);
441
462
 
442
463
 
443
464
static size_t fix_size_t(Session *session, size_t num,
444
 
                           const struct option *option_limits)
 
465
                           const struct my_option *option_limits)
445
466
{
446
467
  bool fixed= false;
447
468
  size_t out= (size_t)getopt_ull_limit_value(num, option_limits, &fixed);
450
471
  return out;
451
472
}
452
473
 
453
 
static bool get_unsigned32(Session *session, set_var *var)
 
474
static bool get_unsigned32(Session *, set_var *var)
454
475
{
455
476
  if (var->value->unsigned_flag)
456
 
    var->save_result.uint32_t_value= 
457
 
      static_cast<uint32_t>(var->value->val_int());
 
477
    var->save_result.uint32_t_value= (uint32_t) var->value->val_int();
458
478
  else
459
479
  {
460
480
    int64_t v= var->value->val_int();
461
 
    if (v > UINT32_MAX)
462
 
      throw_bounds_warning(session, true, true,var->var->getName().c_str(), v);
463
 
    
464
 
    var->save_result.uint32_t_value= 
465
 
      static_cast<uint32_t>((v > UINT32_MAX) ? UINT32_MAX : (v < 0) ? 0 : v);
 
481
    var->save_result.uint32_t_value= (uint32_t) ((v < 0) ? 0 : v);
466
482
  }
467
 
  return false;
 
483
  return 0;
468
484
}
469
485
 
470
486
static bool get_unsigned64(Session *, set_var *var)
514
530
}
515
531
 
516
532
 
517
 
void sys_var_uint32_t_ptr::set_default(Session *, sql_var_t)
 
533
void sys_var_uint32_t_ptr::set_default(Session *, enum_var_type)
518
534
{
519
535
  bool not_used;
520
536
  pthread_mutex_lock(&LOCK_global_system_variables);
541
557
}
542
558
 
543
559
 
544
 
void sys_var_uint64_t_ptr::set_default(Session *, sql_var_t)
 
560
void sys_var_uint64_t_ptr::set_default(Session *, enum_var_type)
545
561
{
546
562
  bool not_used;
547
563
  pthread_mutex_lock(&LOCK_global_system_variables);
564
580
}
565
581
 
566
582
 
567
 
void sys_var_size_t_ptr::set_default(Session *, sql_var_t)
 
583
void sys_var_size_t_ptr::set_default(Session *, enum_var_type)
568
584
{
569
585
  bool not_used;
570
586
  pthread_mutex_lock(&LOCK_global_system_variables);
580
596
}
581
597
 
582
598
 
583
 
void sys_var_bool_ptr::set_default(Session *, sql_var_t)
 
599
void sys_var_bool_ptr::set_default(Session *, enum_var_type)
584
600
{
585
601
  *value= (bool) option_limits->def_value;
586
602
}
587
603
 
588
604
 
 
605
bool sys_var_enum::update(Session *, set_var *var)
 
606
{
 
607
  *value= (uint32_t) var->save_result.uint32_t_value;
 
608
  return 0;
 
609
}
 
610
 
 
611
 
 
612
unsigned char *sys_var_enum::value_ptr(Session *, enum_var_type, const LEX_STRING *)
 
613
{
 
614
  return (unsigned char*) enum_names->type_names[*value];
 
615
}
 
616
 
 
617
 
 
618
unsigned char *sys_var_enum_const::value_ptr(Session *, enum_var_type,
 
619
                                             const LEX_STRING *)
 
620
{
 
621
  return (unsigned char*) enum_names->type_names[global_system_variables.*offset];
 
622
}
 
623
 
589
624
/*
590
625
  32 bit types for session variables
591
626
*/
623
658
 }
624
659
 
625
660
 
626
 
 void sys_var_session_uint32_t::set_default(Session *session, sql_var_t type)
 
661
 void sys_var_session_uint32_t::set_default(Session *session, enum_var_type type)
627
662
 {
628
663
   if (type == OPT_GLOBAL)
629
664
   {
639
674
 
640
675
 
641
676
unsigned char *sys_var_session_uint32_t::value_ptr(Session *session,
642
 
                                                sql_var_t type,
 
677
                                                enum_var_type type,
643
678
                                                const LEX_STRING *)
644
679
{
645
680
  if (type == OPT_GLOBAL)
671
706
}
672
707
 
673
708
 
674
 
void sys_var_session_ha_rows::set_default(Session *session, sql_var_t type)
 
709
void sys_var_session_ha_rows::set_default(Session *session, enum_var_type type)
675
710
{
676
711
  if (type == OPT_GLOBAL)
677
712
  {
689
724
 
690
725
 
691
726
unsigned char *sys_var_session_ha_rows::value_ptr(Session *session,
692
 
                                                  sql_var_t type,
 
727
                                                  enum_var_type type,
693
728
                                                  const LEX_STRING *)
694
729
{
695
730
  if (type == OPT_GLOBAL)
708
743
  uint64_t tmp= var->save_result.uint64_t_value;
709
744
 
710
745
  if (tmp > max_system_variables.*offset)
711
 
  {
712
 
    throw_bounds_warning(session, true, true, getName(), (int64_t) tmp);
713
746
    tmp= max_system_variables.*offset;
714
 
  }
715
747
 
716
748
  if (option_limits)
717
749
    tmp= fix_unsigned(session, tmp, option_limits);
728
760
}
729
761
 
730
762
 
731
 
void sys_var_session_uint64_t::set_default(Session *session, sql_var_t type)
 
763
void sys_var_session_uint64_t::set_default(Session *session, enum_var_type type)
732
764
{
733
765
  if (type == OPT_GLOBAL)
734
766
  {
745
777
 
746
778
 
747
779
unsigned char *sys_var_session_uint64_t::value_ptr(Session *session,
748
 
                                                   sql_var_t type,
 
780
                                                   enum_var_type type,
749
781
                                                   const LEX_STRING *)
750
782
{
751
783
  if (type == OPT_GLOBAL)
781
813
}
782
814
 
783
815
 
784
 
void sys_var_session_size_t::set_default(Session *session, sql_var_t type)
 
816
void sys_var_session_size_t::set_default(Session *session, enum_var_type type)
785
817
{
786
818
  if (type == OPT_GLOBAL)
787
819
  {
798
830
 
799
831
 
800
832
unsigned char *sys_var_session_size_t::value_ptr(Session *session,
801
 
                                                 sql_var_t type,
 
833
                                                 enum_var_type type,
802
834
                                                 const LEX_STRING *)
803
835
{
804
836
  if (type == OPT_GLOBAL)
817
849
}
818
850
 
819
851
 
820
 
void sys_var_session_bool::set_default(Session *session,  sql_var_t type)
 
852
void sys_var_session_bool::set_default(Session *session,  enum_var_type type)
821
853
{
822
854
  if (type == OPT_GLOBAL)
823
855
    global_system_variables.*offset= (bool) option_limits->def_value;
827
859
 
828
860
 
829
861
unsigned char *sys_var_session_bool::value_ptr(Session *session,
830
 
                                               sql_var_t type,
 
862
                                               enum_var_type type,
831
863
                                               const LEX_STRING *)
832
864
{
833
865
  if (type == OPT_GLOBAL)
860
892
    uint64_t tmp=var->value->val_int();
861
893
    if (tmp >= enum_names->count)
862
894
    {
863
 
      internal::llstr(tmp,buff);
 
895
      llstr(tmp,buff);
864
896
      value=buff;                               // Wrong value is here
865
897
      goto err;
866
898
    }
874
906
}
875
907
 
876
908
 
 
909
bool sys_var::check_set(Session *, set_var *var, TYPELIB *enum_names)
 
910
{
 
911
  bool not_used;
 
912
  char buff[STRING_BUFFER_USUAL_SIZE], *error= 0;
 
913
  uint32_t error_len= 0;
 
914
  String str(buff, sizeof(buff), system_charset_info), *res;
 
915
 
 
916
  if (var->value->result_type() == STRING_RESULT)
 
917
  {
 
918
    if (!(res= var->value->val_str(&str)))
 
919
    {
 
920
      strcpy(buff, "NULL");
 
921
      goto err;
 
922
    }
 
923
 
 
924
    if (! m_allow_empty_value && res->length() == 0)
 
925
    {
 
926
      buff[0]= 0;
 
927
      goto err;
 
928
    }
 
929
 
 
930
    var->save_result.uint32_t_value= ((uint32_t)
 
931
                                      find_set(enum_names, res->c_ptr(),
 
932
                                               res->length(),
 
933
                                               NULL,
 
934
                                               &error, &error_len,
 
935
                                               &not_used));
 
936
    if (error_len)
 
937
    {
 
938
      size_t len = min((uint32_t)(sizeof(buff) - 1), error_len);
 
939
      strncpy(buff, error, len);
 
940
      buff[len]= '\0';
 
941
      goto err;
 
942
    }
 
943
  }
 
944
  else
 
945
  {
 
946
    uint64_t tmp= var->value->val_int();
 
947
 
 
948
    if (! m_allow_empty_value && tmp == 0)
 
949
    {
 
950
      buff[0]= '0';
 
951
      buff[1]= 0;
 
952
      goto err;
 
953
    }
 
954
 
 
955
    /*
 
956
      For when the enum is made to contain 64 elements, as 1ULL<<64 is
 
957
      undefined, we guard with a "count<64" test.
 
958
    */
 
959
    if (unlikely((tmp >= ((1UL) << enum_names->count)) &&
 
960
                 (enum_names->count < 64)))
 
961
    {
 
962
      llstr(tmp, buff);
 
963
      goto err;
 
964
    }
 
965
    var->save_result.uint32_t_value= (uint32_t) tmp;  // Save for update
 
966
  }
 
967
  return 0;
 
968
 
 
969
err:
 
970
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name.c_str(), buff);
 
971
  return 1;
 
972
}
 
973
 
 
974
 
877
975
/**
878
976
  Return an Item for a variable.
879
977
 
882
980
  If type is not given, return local value if exists, else global.
883
981
*/
884
982
 
885
 
Item *sys_var::item(Session *session, sql_var_t var_type, const LEX_STRING *base)
 
983
Item *sys_var::item(Session *session, enum_var_type var_type, const LEX_STRING *base)
886
984
{
887
985
  if (check_type(var_type))
888
986
  {
998
1096
}
999
1097
 
1000
1098
 
1001
 
void sys_var_session_enum::set_default(Session *session, sql_var_t type)
 
1099
void sys_var_session_enum::set_default(Session *session, enum_var_type type)
1002
1100
{
1003
1101
  if (type == OPT_GLOBAL)
1004
1102
    global_system_variables.*offset= (uint32_t) option_limits->def_value;
1008
1106
 
1009
1107
 
1010
1108
unsigned char *sys_var_session_enum::value_ptr(Session *session,
1011
 
                                               sql_var_t type,
 
1109
                                               enum_var_type type,
1012
1110
                                               const LEX_STRING *)
1013
1111
{
1014
1112
  uint32_t tmp= ((type == OPT_GLOBAL) ?
1030
1128
}
1031
1129
 
1032
1130
 
1033
 
unsigned char *sys_var_session_bit::value_ptr(Session *session, sql_var_t,
 
1131
unsigned char *sys_var_session_bit::value_ptr(Session *session, enum_var_type,
1034
1132
                                              const LEX_STRING *)
1035
1133
{
1036
1134
  /*
1073
1171
    if (!(tmp=get_charset((int) var->value->val_int())))
1074
1172
    {
1075
1173
      char buf[20];
1076
 
      internal::int10_to_str((int) var->value->val_int(), buf, -10);
 
1174
      int10_to_str((int) var->value->val_int(), buf, -10);
1077
1175
      my_error(ER_UNKNOWN_COLLATION, MYF(0), buf);
1078
1176
      return 1;
1079
1177
    }
1095
1193
}
1096
1194
 
1097
1195
 
1098
 
void sys_var_collation_sv::set_default(Session *session, sql_var_t type)
 
1196
void sys_var_collation_sv::set_default(Session *session, enum_var_type type)
1099
1197
{
1100
1198
  if (type == OPT_GLOBAL)
1101
1199
    global_system_variables.*offset= *global_default;
1107
1205
 
1108
1206
 
1109
1207
unsigned char *sys_var_collation_sv::value_ptr(Session *session,
1110
 
                                               sql_var_t type,
 
1208
                                               enum_var_type type,
1111
1209
                                               const LEX_STRING *)
1112
1210
{
1113
1211
  const CHARSET_INFO *cs= ((type == OPT_GLOBAL) ?
1116
1214
  return cs ? (unsigned char*) cs->name : (unsigned char*) "NULL";
1117
1215
}
1118
1216
 
 
1217
 
 
1218
unsigned char *sys_var_key_cache_param::value_ptr(Session *, enum_var_type,
 
1219
                                                  const LEX_STRING *)
 
1220
{
 
1221
  return (unsigned char*) dflt_key_cache + offset ;
 
1222
}
 
1223
 
 
1224
/**
 
1225
  Resize key cache.
 
1226
*/
 
1227
static int resize_key_cache_with_lock(KEY_CACHE *key_cache)
 
1228
{
 
1229
  assert(key_cache->key_cache_inited);
 
1230
 
 
1231
  pthread_mutex_lock(&LOCK_global_system_variables);
 
1232
  long tmp_buff_size= (long) key_cache->param_buff_size;
 
1233
  long tmp_block_size= (long) key_cache->param_block_size;
 
1234
  uint32_t division_limit= key_cache->param_division_limit;
 
1235
  uint32_t age_threshold=  key_cache->param_age_threshold;
 
1236
  pthread_mutex_unlock(&LOCK_global_system_variables);
 
1237
 
 
1238
  return(!resize_key_cache(key_cache, tmp_block_size,
 
1239
                           tmp_buff_size,
 
1240
                           division_limit, age_threshold));
 
1241
}
 
1242
 
 
1243
 
 
1244
 
 
1245
bool sys_var_key_buffer_size::update(Session *session, set_var *var)
 
1246
{
 
1247
  uint64_t tmp= var->save_result.uint64_t_value;
 
1248
  KEY_CACHE *key_cache;
 
1249
  bool error= 0;
 
1250
 
 
1251
  pthread_mutex_lock(&LOCK_global_system_variables);
 
1252
  key_cache= dflt_key_cache;
 
1253
 
 
1254
  /*
 
1255
    Abort if some other thread is changing the key cache
 
1256
    TODO: This should be changed so that we wait until the previous
 
1257
    assignment is done and then do the new assign
 
1258
  */
 
1259
  if (key_cache->in_init)
 
1260
    goto end;
 
1261
 
 
1262
  if (tmp == 0)                                 // Zero size means delete
 
1263
  {
 
1264
    push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
1265
                        ER_WARN_CANT_DROP_DEFAULT_KEYCACHE,
 
1266
                        ER(ER_WARN_CANT_DROP_DEFAULT_KEYCACHE));
 
1267
    goto end;                                   // Ignore default key cache
 
1268
  }
 
1269
 
 
1270
  key_cache->param_buff_size=
 
1271
    (uint64_t) fix_unsigned(session, tmp, option_limits);
 
1272
 
 
1273
  /* If key cache didn't existed initialize it, else resize it */
 
1274
  key_cache->in_init= 1;
 
1275
  pthread_mutex_unlock(&LOCK_global_system_variables);
 
1276
 
 
1277
  error= (bool)(resize_key_cache_with_lock(key_cache));
 
1278
 
 
1279
  pthread_mutex_lock(&LOCK_global_system_variables);
 
1280
  key_cache->in_init= 0;
 
1281
 
 
1282
end:
 
1283
  pthread_mutex_unlock(&LOCK_global_system_variables);
 
1284
  return error;
 
1285
}
 
1286
 
 
1287
 
 
1288
/**
 
1289
  @todo
 
1290
  Abort if some other thread is changing the key cache.
 
1291
  This should be changed so that we wait until the previous
 
1292
  assignment is done and then do the new assign
 
1293
*/
 
1294
bool sys_var_key_cache_uint32_t::update(Session *session, set_var *var)
 
1295
{
 
1296
  uint64_t tmp= (uint64_t) var->value->val_int();
 
1297
  bool error= 0;
 
1298
 
 
1299
  pthread_mutex_lock(&LOCK_global_system_variables);
 
1300
 
 
1301
  /*
 
1302
    Abort if some other thread is changing the key cache
 
1303
    TODO: This should be changed so that we wait until the previous
 
1304
    assignment is done and then do the new assign
 
1305
  */
 
1306
  if (dflt_key_cache->in_init)
 
1307
    goto end;
 
1308
 
 
1309
  *((uint32_t*) (((char*) dflt_key_cache) + offset))=
 
1310
    (uint32_t) fix_unsigned(session, tmp, option_limits);
 
1311
 
 
1312
  /*
 
1313
    Don't create a new key cache if it didn't exist
 
1314
    (key_caches are created only when the user sets block_size)
 
1315
  */
 
1316
  dflt_key_cache->in_init= 1;
 
1317
 
 
1318
  pthread_mutex_unlock(&LOCK_global_system_variables);
 
1319
 
 
1320
  error= (bool) (resize_key_cache_with_lock(dflt_key_cache));
 
1321
 
 
1322
  pthread_mutex_lock(&LOCK_global_system_variables);
 
1323
  dflt_key_cache->in_init= 0;
 
1324
 
 
1325
end:
 
1326
  pthread_mutex_unlock(&LOCK_global_system_variables);
 
1327
  return error;
 
1328
}
 
1329
 
 
1330
 
1119
1331
/****************************************************************************/
1120
1332
 
1121
1333
bool sys_var_timestamp::update(Session *session,  set_var *var)
1125
1337
}
1126
1338
 
1127
1339
 
1128
 
void sys_var_timestamp::set_default(Session *session, sql_var_t)
 
1340
void sys_var_timestamp::set_default(Session *session, enum_var_type)
1129
1341
{
1130
1342
  session->user_time=0;
1131
1343
}
1132
1344
 
1133
1345
 
1134
 
unsigned char *sys_var_timestamp::value_ptr(Session *session, sql_var_t,
 
1346
unsigned char *sys_var_timestamp::value_ptr(Session *session, enum_var_type,
1135
1347
                                            const LEX_STRING *)
1136
1348
{
1137
1349
  session->sys_var_tmp.int32_t_value= (int32_t) session->start_time;
1148
1360
 
1149
1361
 
1150
1362
unsigned char *sys_var_last_insert_id::value_ptr(Session *session,
1151
 
                                                 sql_var_t,
 
1363
                                                 enum_var_type,
1152
1364
                                                 const LEX_STRING *)
1153
1365
{
1154
1366
  /*
1192
1404
 
1193
1405
 
1194
1406
unsigned char *sys_var_session_time_zone::value_ptr(Session *session,
1195
 
                                                    sql_var_t type,
 
1407
                                                    enum_var_type type,
1196
1408
                                                    const LEX_STRING *)
1197
1409
{
1198
1410
  /*
1216
1428
}
1217
1429
 
1218
1430
 
1219
 
void sys_var_session_time_zone::set_default(Session *session, sql_var_t type)
 
1431
void sys_var_session_time_zone::set_default(Session *session, enum_var_type type)
1220
1432
{
1221
1433
 pthread_mutex_lock(&LOCK_global_system_variables);
1222
1434
 if (type == OPT_GLOBAL)
1248
1460
    if (!(locale_match= my_locale_by_number((uint32_t) var->value->val_int())))
1249
1461
    {
1250
1462
      char buf[20];
1251
 
      internal::int10_to_str((int) var->value->val_int(), buf, -10);
 
1463
      int10_to_str((int) var->value->val_int(), buf, -10);
1252
1464
      my_printf_error(ER_UNKNOWN_ERROR, "Unknown locale: '%s'", MYF(0), buf);
1253
1465
      return 1;
1254
1466
    }
1287
1499
 
1288
1500
 
1289
1501
unsigned char *sys_var_session_lc_time_names::value_ptr(Session *session,
1290
 
                                                        sql_var_t type,
 
1502
                                                        enum_var_type type,
1291
1503
                                                        const LEX_STRING *)
1292
1504
{
1293
1505
  return type == OPT_GLOBAL ?
1296
1508
}
1297
1509
 
1298
1510
 
1299
 
void sys_var_session_lc_time_names::set_default(Session *session, sql_var_t type)
 
1511
void sys_var_session_lc_time_names::set_default(Session *session, enum_var_type type)
1300
1512
{
1301
1513
  if (type == OPT_GLOBAL)
1302
1514
    global_system_variables.lc_time_names= my_default_lc_time_names;
1334
1546
}
1335
1547
 
1336
1548
 
1337
 
void sys_var_microseconds::set_default(Session *session, sql_var_t type)
 
1549
void sys_var_microseconds::set_default(Session *session, enum_var_type type)
1338
1550
{
1339
1551
  int64_t microseconds= (int64_t) (option_limits->def_value * 1000000.0);
1340
1552
  if (type == OPT_GLOBAL)
1378
1590
    if ((org_options & OPTION_NOT_AUTOCOMMIT))
1379
1591
    {
1380
1592
      /* We changed to auto_commit mode */
1381
 
      session->options&= ~(uint64_t) (OPTION_BEGIN);
 
1593
      session->options&= ~(uint64_t) (OPTION_BEGIN | OPTION_KEEP_LOG);
 
1594
      session->transaction.all.modified_non_trans_table= false;
1382
1595
      session->server_status|= SERVER_STATUS_AUTOCOMMIT;
1383
 
      TransactionServices &transaction_services= TransactionServices::singleton();
1384
 
      if (transaction_services.ha_commit_trans(session, true))
1385
 
        return 1;
 
1596
      if (ha_commit(session))
 
1597
        return 1;
1386
1598
    }
1387
1599
    else
1388
1600
    {
 
1601
      session->transaction.all.modified_non_trans_table= false;
1389
1602
      session->server_status&= ~SERVER_STATUS_AUTOCOMMIT;
1390
1603
    }
1391
1604
  }
1455
1668
    ptr         pointer to option structure
1456
1669
*/
1457
1670
 
1458
 
static struct option *find_option(struct option *opt, const char *name)
 
1671
static struct my_option *find_option(struct my_option *opt, const char *name)
1459
1672
{
1460
1673
  uint32_t length=strlen(name);
1461
1674
  for (; opt->name; opt++)
1488
1701
*/
1489
1702
 
1490
1703
 
1491
 
int mysql_add_sys_var_chain(sys_var *first, struct option *long_options)
 
1704
int mysql_add_sys_var_chain(sys_var *first, struct my_option *long_options)
1492
1705
{
1493
1706
  sys_var *var;
1494
1707
  /* A write lock should be held on LOCK_system_variables_hash */
1496
1709
  for (var= first; var; var= var->getNext())
1497
1710
  {
1498
1711
 
1499
 
    string lower_name(var->getName());
1500
 
    transform(lower_name.begin(), lower_name.end(),
1501
 
              lower_name.begin(), ::tolower);
1502
 
 
1503
1712
    /* this fails if there is a conflicting variable name. */
1504
 
    if (system_variable_map.find(lower_name) != system_variable_map.end())
 
1713
    if (system_variable_hash.add(var))
1505
1714
    {
1506
 
      errmsg_printf(ERRMSG_LVL_ERROR, _("Variable named %s already exists!\n"),
1507
 
                    var->getName().c_str());
1508
1715
      return 1;
1509
1716
    } 
1510
 
 
1511
 
    pair<SystemVariableMap::iterator, bool> ret= 
1512
 
      system_variable_map.insert(make_pair(lower_name, var));
1513
 
    if (ret.second == false)
1514
 
    {
1515
 
      errmsg_printf(ERRMSG_LVL_ERROR, _("Could not add Variable: %s\n"),
1516
 
                    var->getName().c_str());
1517
 
      return 1;
1518
 
    }
1519
 
 
1520
1717
    if (long_options)
1521
1718
      var->setOptionLimits(find_option(long_options, var->getName().c_str()));
1522
1719
  }
1539
1736
 
1540
1737
int mysql_del_sys_var_chain(sys_var *first)
1541
1738
{
 
1739
  int result= 0;
1542
1740
 
1543
1741
  /* A write lock should be held on LOCK_system_variables_hash */
1544
1742
  for (sys_var *var= first; var; var= var->getNext())
1545
1743
  {
1546
 
    string lower_name(var->getName());
1547
 
    transform(lower_name.begin(), lower_name.end(),
1548
 
              lower_name.begin(), ::tolower);
1549
 
    system_variable_map.erase(lower_name);
 
1744
    system_variable_hash.remove(var);
1550
1745
  }
1551
 
  return 0;
 
1746
  return result;
1552
1747
}
1553
1748
 
1554
1749
 
1562
1757
    sorted      If TRUE, the system variables should be sorted
1563
1758
 
1564
1759
  RETURN VALUES
1565
 
    pointer     Array of drizzle_show_var elements for display
 
1760
    pointer     Array of SHOW_VAR elements for display
1566
1761
    NULL        FAILURE
1567
1762
*/
1568
1763
 
1569
 
drizzle_show_var* enumerate_sys_vars(Session *session, bool)
 
1764
SHOW_VAR* enumerate_sys_vars(Session *session, bool)
1570
1765
{
1571
1766
  int fixed_count= fixed_show_vars.elements;
1572
 
  int size= sizeof(drizzle_show_var) * (system_variable_map.size() + fixed_count + 1);
1573
 
  drizzle_show_var *result= (drizzle_show_var*) session->alloc(size);
 
1767
  int size= sizeof(SHOW_VAR) * (system_variable_hash.size() + fixed_count + 1);
 
1768
  SHOW_VAR *result= (SHOW_VAR*) session->alloc(size);
1574
1769
 
1575
1770
  if (result)
1576
1771
  {
1577
 
    drizzle_show_var *show= result + fixed_count;
1578
 
    memcpy(result, fixed_show_vars.buffer, fixed_count * sizeof(drizzle_show_var));
 
1772
    SHOW_VAR *show= result + fixed_count;
 
1773
    memcpy(result, fixed_show_vars.buffer, fixed_count * sizeof(SHOW_VAR));
1579
1774
 
1580
 
    SystemVariableMap::const_iterator iter= system_variable_map.begin();
1581
 
    while (iter != system_variable_map.end())
 
1775
    drizzled::Registry<sys_var *>::const_iterator iter;
 
1776
    for(iter= system_variable_hash.begin();
 
1777
        iter != system_variable_hash.end();
 
1778
        iter++)
1582
1779
    {
1583
 
      sys_var *var= (*iter).second;
 
1780
      sys_var *var= *iter;
1584
1781
      show->name= var->getName().c_str();
1585
1782
      show->value= (char*) var;
1586
1783
      show->type= SHOW_SYS;
1587
1784
      show++;
1588
 
      ++iter;
1589
1785
    }
1590
1786
 
1591
1787
    /* make last element empty */
1592
 
    memset(show, 0, sizeof(drizzle_show_var));
 
1788
    memset(show, 0, sizeof(SHOW_VAR));
1593
1789
  }
1594
1790
  return result;
1595
1791
}
1612
1808
 
1613
1809
  for (sys_var *var= vars.first; var; var= var->getNext(), count++) {};
1614
1810
 
1615
 
  if (my_init_dynamic_array(&fixed_show_vars, sizeof(drizzle_show_var),
 
1811
  if (my_init_dynamic_array(&fixed_show_vars, sizeof(SHOW_VAR),
1616
1812
                            FIXED_VARS_SIZE + 64, 64))
1617
1813
    goto error;
1618
1814
 
1637
1833
}
1638
1834
 
1639
1835
 
 
1836
/*
 
1837
  Add elements to the dynamic list of read-only system variables.
 
1838
 
 
1839
  SYNOPSIS
 
1840
    mysql_append_static_vars()
 
1841
    show_vars   Pointer to start of array
 
1842
    count       Number of elements
 
1843
 
 
1844
  RETURN VALUES
 
1845
    0           SUCCESS
 
1846
    otherwise   FAILURE
 
1847
*/
 
1848
int mysql_append_static_vars(const SHOW_VAR *show_vars, uint32_t count)
 
1849
{
 
1850
  for (; count > 0; count--, show_vars++)
 
1851
    if (insert_dynamic(&fixed_show_vars, (unsigned char*) show_vars))
 
1852
      return 1;
 
1853
  return 0;
 
1854
}
 
1855
 
 
1856
 
1640
1857
/**
1641
1858
  Find a user set-table variable.
1642
1859
 
1653
1870
 
1654
1871
sys_var *intern_find_sys_var(const char *str, uint32_t, bool no_error)
1655
1872
{
1656
 
  string lower_name(str);
1657
 
  transform(lower_name.begin(), lower_name.end(),
1658
 
            lower_name.begin(), ::tolower);
1659
 
 
1660
 
  sys_var *result= NULL;
1661
 
 
1662
 
  SystemVariableMap::iterator iter= system_variable_map.find(lower_name);
1663
 
  if (iter != system_variable_map.end())
1664
 
  {
1665
 
    result= (*iter).second;
1666
 
  } 
1667
 
 
1668
1873
  /*
1669
1874
    This function is only called from the sql_plugin.cc.
1670
1875
    A lock on LOCK_system_variable_hash should be held
1671
1876
  */
 
1877
  sys_var *result= system_variable_hash.find(str);
1672
1878
  if (result == NULL)
1673
1879
  {
1674
1880
    if (no_error)
1842
2048
    else
1843
2049
    {
1844
2050
      const std::string engine_name(res->ptr());
1845
 
      plugin::StorageEngine *engine;
1846
 
      var->save_result.storage_engine= plugin::StorageEngine::findByName(*session, engine_name);
 
2051
      StorageEngine *engine;
 
2052
      var->save_result.storage_engine= ha_resolve_by_name(session, engine_name);
1847
2053
      if (var->save_result.storage_engine == NULL)
1848
2054
      {
1849
2055
        value= res->c_ptr();
1862
2068
 
1863
2069
 
1864
2070
unsigned char *sys_var_session_storage_engine::value_ptr(Session *session,
1865
 
                                                         sql_var_t type,
 
2071
                                                         enum_var_type type,
1866
2072
                                                         const LEX_STRING *)
1867
2073
{
1868
2074
  unsigned char* result;
1869
2075
  string engine_name;
1870
 
  plugin::StorageEngine *engine= session->variables.*offset;
 
2076
  StorageEngine *engine= session->variables.*offset;
1871
2077
  if (type == OPT_GLOBAL)
1872
2078
    engine= global_system_variables.*offset;
1873
2079
  engine_name= engine->getName();
1877
2083
}
1878
2084
 
1879
2085
 
1880
 
void sys_var_session_storage_engine::set_default(Session *session, sql_var_t type)
 
2086
void sys_var_session_storage_engine::set_default(Session *session, enum_var_type type)
1881
2087
{
1882
 
  plugin::StorageEngine *old_value, *new_value, **value;
 
2088
  StorageEngine *old_value, *new_value, **value;
1883
2089
  if (type == OPT_GLOBAL)
1884
2090
  {
1885
2091
    value= &(global_system_variables.*offset);
1898
2104
 
1899
2105
bool sys_var_session_storage_engine::update(Session *session, set_var *var)
1900
2106
{
1901
 
  plugin::StorageEngine **value= &(global_system_variables.*offset), *old_value;
 
2107
  StorageEngine **value= &(global_system_variables.*offset), *old_value;
1902
2108
   if (var->type != OPT_GLOBAL)
1903
2109
     value= &(session->variables.*offset);
1904
2110
  old_value= *value;
1909
2115
  return 0;
1910
2116
}
1911
2117
 
1912
 
} /* namespace drizzled */
 
2118
bool
 
2119
sys_var_session_optimizer_switch::
 
2120
symbolic_mode_representation(Session *session, uint32_t val, LEX_STRING *rep)
 
2121
{
 
2122
  char buff[STRING_BUFFER_USUAL_SIZE*8];
 
2123
  String tmp(buff, sizeof(buff), &my_charset_utf8_general_ci);
 
2124
 
 
2125
  tmp.length(0);
 
2126
 
 
2127
  for (uint32_t i= 0; val; val>>= 1, i++)
 
2128
  {
 
2129
    if (val & 1)
 
2130
    {
 
2131
      tmp.append(optimizer_switch_typelib.type_names[i],
 
2132
                 optimizer_switch_typelib.type_lengths[i]);
 
2133
      tmp.append(',');
 
2134
    }
 
2135
  }
 
2136
 
 
2137
  if (tmp.length())
 
2138
    tmp.length(tmp.length() - 1); /* trim the trailing comma */
 
2139
 
 
2140
  rep->str= session->strmake(tmp.ptr(), tmp.length());
 
2141
 
 
2142
  rep->length= rep->str ? tmp.length() : 0;
 
2143
 
 
2144
  return rep->length != tmp.length();
 
2145
}
 
2146
 
 
2147
 
 
2148
unsigned char *sys_var_session_optimizer_switch::value_ptr(Session *session,
 
2149
                                                           enum_var_type type,
 
2150
                                                           const LEX_STRING *)
 
2151
{
 
2152
  LEX_STRING opts;
 
2153
  uint32_t val= ((type == OPT_GLOBAL) ? global_system_variables.*offset :
 
2154
                  session->variables.*offset);
 
2155
  (void) symbolic_mode_representation(session, val, &opts);
 
2156
  return (unsigned char *) opts.str;
 
2157
}
 
2158
 
 
2159
 
 
2160
void sys_var_session_optimizer_switch::set_default(Session *session, enum_var_type type)
 
2161
{
 
2162
  if (type == OPT_GLOBAL)
 
2163
    global_system_variables.*offset= 0;
 
2164
  else
 
2165
    session->variables.*offset= global_system_variables.*offset;
 
2166
}
 
2167
 
 
2168
 
 
2169
/****************************************************************************
 
2170
  Used templates
 
2171
****************************************************************************/
 
2172
 
 
2173
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
 
2174
template class List<set_var_base>;
 
2175
template class List_iterator_fast<set_var_base>;
 
2176
template class I_List_iterator<NAMED_LIST>;
 
2177
#endif