← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sys_var.h

  • Committer: Stewart Smith
  • Date: 2010-11-03 03:30:27 UTC
  • mto: (1902.1.1 build) (1910.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 1903.
  • Revision ID: stewart@flamingspork.com-20101103033027-lskb6gxwwforfz71
fix docs warning: underline/overline too short for replace.rst

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sys_var.h
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
23
23
#include <string>
24
24
#include <boost/filesystem.hpp>
25
25
 
26
 
#include <drizzled/constrained_value.h>
27
 
#include <drizzled/set_var.h>
28
 
#include <drizzled/show_type.h>
29
 
#include <drizzled/item_result.h>
30
 
#include <drizzled/base.h>
31
 
#include <drizzled/global_charset_info.h>
32
 
#include <drizzled/lex_string.h>
33
 
 
34
 
#include <drizzled/visibility.h>
 
26
/*
 
27
#include "drizzled/function/func.h"
 
28
#include "drizzled/function/set_user_var.h"
 
29
#include "drizzled/item/string.h"
 
30
#include "drizzled/item/field.h"
 
31
*/
 
32
#include "drizzled/constrained_value.h"
 
33
#include "drizzled/set_var.h"
 
34
#include "drizzled/show_type.h"
 
35
#include "drizzled/typelib.h"
 
36
#include "drizzled/item_result.h"
 
37
#include "drizzled/base.h"
 
38
#include "drizzled/global_charset_info.h"
 
39
#include "drizzled/lex_string.h"
35
40
 
36
41
namespace drizzled
37
42
{
38
43
 
39
44
class sys_var;
 
45
class sys_var_pluginvar; /* opaque */
40
46
class Time_zone;
41
47
typedef struct my_locale_st MY_LOCALE;
42
 
typedef struct st_typelib TYPELIB;
 
48
 
 
49
extern TYPELIB bool_typelib;
43
50
 
44
51
typedef int (*sys_check_func)(Session *,  set_var *);
45
52
typedef bool (*sys_update_func)(Session *, set_var *);
56
63
extern const char *in_left_expr_name;
57
64
extern const char *in_additional_cond;
58
65
extern const char *in_having_cond;
 
66
extern char glob_hostname[FN_REFLEN];
59
67
extern boost::filesystem::path basedir;
60
68
extern boost::filesystem::path pid_file;
61
69
extern boost::filesystem::path secure_file_priv;
 
70
extern char system_time_zone[30];
62
71
extern char *opt_tc_log_file;
63
72
extern uint64_t session_startup_options;
64
73
extern uint32_t global_thread_id;
65
74
extern uint64_t table_cache_size;
 
75
extern uint64_t max_connect_errors;
66
76
extern back_log_constraints back_log;
67
77
extern uint32_t ha_open_options;
68
78
extern char *drizzled_bind_host;
71
81
extern uint32_t volatile thread_running;
72
82
extern uint32_t volatile global_read_lock;
73
83
extern bool opt_readonly;
 
84
extern char *default_tz_name;
74
85
extern const char *opt_scheduler;
75
 
extern size_t transaction_message_threshold;
76
86
 
77
87
uint64_t fix_unsigned(Session *, uint64_t, const struct option *);
78
88
 
79
 
const std::string &getServerHostname();
80
89
int sys_var_init();
81
90
 
82
91
/**
83
92
 * A class which represents a variable, either global or 
84
93
 * session-local.
85
94
 */
86
 
class DRIZZLED_API sys_var
 
95
class sys_var
87
96
{
88
97
protected:
89
98
  std::string name; /**< The name of the variable */
90
 
  sys_check_func check_func;
91
99
  sys_after_update_func after_update; /**< Function pointer triggered after the variable's value is updated */
92
100
  struct option *option_limits; /**< Updated by by sys_var_init() */
93
101
  bool m_allow_empty_value; /**< Does variable allow an empty value? */
94
102
public:
95
 
  sys_var(const std::string &name_arg,
96
 
          sys_after_update_func func= NULL,
97
 
          sys_check_func check_func_arg= NULL)
 
103
  sys_var(const std::string name_arg, sys_after_update_func func= NULL)
98
104
    :
99
105
    name(name_arg),
100
 
    check_func(check_func_arg),
101
106
    after_update(func),
102
 
    option_limits(NULL),
103
107
    m_allow_empty_value(true)
104
108
  {}
105
109
  virtual ~sys_var() {}
181
185
  {
182
186
    return 0;
183
187
  }
 
188
  virtual sys_var_pluginvar *cast_pluginvar()
 
189
  {
 
190
    return 0;
 
191
  }
184
192
};
185
193
 
186
194
/**
187
195
 * A base class for all variables that require its access to
188
196
 * be guarded with a mutex.
189
197
 */
190
 
class DRIZZLED_API sys_var_global: public sys_var
 
198
class sys_var_global: public sys_var
191
199
{
192
200
protected:
193
201
  pthread_mutex_t *guard;
201
209
  {}
202
210
};
203
211
 
204
 
class DRIZZLED_API sys_var_uint32_t_ptr :public sys_var
 
212
class sys_var_uint32_t_ptr :public sys_var
205
213
{
206
214
  uint32_t *value;
207
215
public:
222
230
  { return (unsigned char*) value; }
223
231
};
224
232
 
225
 
class DRIZZLED_API sys_var_uint32_t_ptr_readonly :
226
 
  public sys_var_uint32_t_ptr
227
 
{
228
 
public:
229
 
  sys_var_uint32_t_ptr_readonly(const char *name_arg,
230
 
                                uint32_t *value_ptr_arg) :
231
 
    sys_var_uint32_t_ptr(name_arg, value_ptr_arg)
232
 
  {}
233
 
 
234
 
  sys_var_uint32_t_ptr_readonly(const char *name_arg,
235
 
                                uint32_t *value_ptr_arg,
236
 
                                sys_after_update_func func) :
237
 
    sys_var_uint32_t_ptr(name_arg, value_ptr_arg, func)
238
 
  {}
239
 
 
240
 
  bool is_readonly() const
241
 
  {
242
 
    return true;
243
 
  }
244
 
};
245
 
 
246
 
 
247
 
class DRIZZLED_API sys_var_uint64_t_ptr :public sys_var
 
233
 
 
234
class sys_var_uint64_t_ptr :public sys_var
248
235
{
249
236
  uint64_t *value;
250
 
  const uint64_t default_value;
251
 
  bool have_default_value;
252
237
public:
253
 
  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg) :
254
 
    sys_var(name_arg),
255
 
    value(value_ptr_arg),
256
 
    default_value(0),
257
 
    have_default_value(false)
258
 
  {  }
259
 
 
260
 
  sys_var_uint64_t_ptr(const char *name_arg,
261
 
                       uint64_t *value_ptr_arg,
262
 
                       const uint64_t default_value_in) :
263
 
    sys_var(name_arg),
264
 
    value(value_ptr_arg),
265
 
    default_value(default_value_in),
266
 
    have_default_value(true)
267
 
  {  }
268
 
 
269
 
  sys_var_uint64_t_ptr(const char *name_arg,
270
 
                       uint64_t *value_ptr_arg,
271
 
                       sys_after_update_func func) :
272
 
    sys_var(name_arg,func),
273
 
    value(value_ptr_arg),
274
 
    default_value(0),
275
 
    have_default_value(false)
276
 
  {  }
277
 
 
278
 
  sys_var_uint64_t_ptr(const char *name_arg,
279
 
                       uint64_t *value_ptr_arg,
280
 
                       sys_after_update_func func,
281
 
                       const uint64_t default_value_in) :
282
 
    sys_var(name_arg,func),
283
 
    value(value_ptr_arg),
284
 
    default_value(default_value_in),
285
 
    have_default_value(true)
286
 
  {  }
287
 
 
 
238
  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg)
 
239
    :sys_var(name_arg),value(value_ptr_arg)
 
240
  {  }
 
241
  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg,
 
242
                       sys_after_update_func func)
 
243
    :sys_var(name_arg,func), value(value_ptr_arg)
 
244
  {  }
288
245
  bool update(Session *session, set_var *var);
289
246
  void set_default(Session *session, sql_var_t type);
290
 
  virtual bool check_default(sql_var_t)
291
 
  {
292
 
    return (not have_default_value) && option_limits == 0;
293
 
  }
294
247
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
295
248
  unsigned char *value_ptr(Session *, sql_var_t,
296
249
                           const LEX_STRING *)
297
250
  { return (unsigned char*) value; }
298
251
};
299
252
 
300
 
class DRIZZLED_API sys_var_size_t_ptr :public sys_var
 
253
class sys_var_size_t_ptr :public sys_var
301
254
{
302
255
  size_t *value;
303
256
public:
315
268
  { return (unsigned char*) value; }
316
269
};
317
270
 
318
 
class DRIZZLED_API sys_var_size_t_ptr_readonly :public sys_var_size_t_ptr
319
 
{
320
 
public:
321
 
  sys_var_size_t_ptr_readonly(const char *name_arg,
322
 
                            size_t *value_arg)
323
 
    :sys_var_size_t_ptr(name_arg, value_arg)
324
 
  {}
325
 
  bool is_readonly() const { return 1; }
326
 
};
327
 
 
328
 
class DRIZZLED_API sys_var_bool_ptr :public sys_var
329
 
{
330
 
  bool default_value;
 
271
class sys_var_bool_ptr :public sys_var
 
272
{
331
273
public:
332
274
  bool *value;
333
 
  sys_var_bool_ptr(const std::string &name_arg, bool *value_arg,
334
 
                   sys_after_update_func func= NULL) :
335
 
    sys_var(name_arg, func), default_value(*value_arg), value(value_arg)
336
 
  { }
337
 
  bool check(Session *session, set_var *var);
338
 
  virtual bool check_default(sql_var_t)
 
275
  sys_var_bool_ptr(const char *name_arg, bool *value_arg)
 
276
    :sys_var(name_arg),value(value_arg)
 
277
  {  }
 
278
  bool check(Session *session, set_var *var)
339
279
  {
340
 
    return false;
 
280
    return check_enum(session, var, &bool_typelib);
341
281
  }
342
282
  bool update(Session *session, set_var *var);
343
283
  void set_default(Session *session, sql_var_t type);
348
288
  { return 0; }
349
289
};
350
290
 
351
 
class DRIZZLED_API sys_var_bool_ptr_readonly :public sys_var_bool_ptr
 
291
class sys_var_bool_ptr_readonly :public sys_var_bool_ptr
352
292
{
353
293
public:
354
294
  sys_var_bool_ptr_readonly(const char *name_arg,
359
299
};
360
300
 
361
301
 
362
 
class DRIZZLED_API sys_var_str :public sys_var
 
302
class sys_var_str :public sys_var
363
303
{
364
304
public:
365
305
  char *value;                                  // Pointer to allocated string
366
306
  uint32_t value_length;
 
307
  sys_check_func check_func;
367
308
  sys_update_func update_func;
368
309
  sys_set_default_func set_default_func;
369
310
  sys_var_str(const char *name_arg,
370
 
              sys_check_func check_func_arg,
371
 
              sys_update_func update_func_arg,
372
 
              sys_set_default_func set_default_func_arg,
373
 
              char *value_arg) :
374
 
    sys_var(name_arg, NULL, check_func_arg),
375
 
    value(value_arg),
376
 
    update_func(update_func_arg),
377
 
    set_default_func(set_default_func_arg)
 
311
              sys_check_func check_func_arg,
 
312
              sys_update_func update_func_arg,
 
313
              sys_set_default_func set_default_func_arg,
 
314
              char *value_arg)
 
315
    :sys_var(name_arg), value(value_arg), check_func(check_func_arg),
 
316
    update_func(update_func_arg),set_default_func(set_default_func_arg)
378
317
  {  }
379
318
  bool check(Session *session, set_var *var);
380
319
  bool update(Session *session, set_var *var)
397
336
};
398
337
 
399
338
 
400
 
class DRIZZLED_API sys_var_fs_path :
 
339
class sys_var_fs_path :
401
340
  public sys_var
402
341
{
403
342
  const boost::filesystem::path &value;
439
378
  constrained_value<T> &value;
440
379
  T basic_value;
441
380
  T default_value;
 
381
  bool have_default_value;
442
382
public:
443
383
  sys_var_constrained_value(const char *name_arg,
444
384
                            constrained_value<T> &value_arg) :
445
385
    sys_var(name_arg),
446
386
    value(value_arg),
447
 
    default_value(value_arg.get())
448
 
  { }
449
 
 
450
 
  sys_var_constrained_value(const char *name_arg,
451
 
                            constrained_value<T> &value_arg,
452
 
                            sys_after_update_func after_update_func_arg) :
453
 
    sys_var(name_arg, after_update_func_arg),
454
 
    value(value_arg),
455
 
    default_value(value_arg.get())
456
 
  { }
457
 
 
458
 
  sys_var_constrained_value(const char *name_arg,
459
 
                            constrained_value<T> &value_arg,
460
 
                            sys_check_func check_func_arg) :
461
 
    sys_var(name_arg, NULL, check_func_arg),
462
 
    value(value_arg),
463
 
    default_value(value_arg.get())
 
387
    default_value(0),
 
388
    have_default_value(false)
 
389
  { }
 
390
 
 
391
  sys_var_constrained_value(const char *name_arg,
 
392
                            constrained_value<T> &value_arg,
 
393
                            T default_value_arg) :
 
394
    sys_var(name_arg),
 
395
    value(value_arg),
 
396
    default_value(default_value_arg),
 
397
    have_default_value(true)
464
398
  { }
465
399
 
466
400
public:
473
407
 
474
408
  bool update(Session *, set_var *var)
475
409
  {
476
 
    value= uint32_t(var->getInteger());
 
410
    value= var->save_result.uint32_t_value;
477
411
    return false;
478
412
  }
479
413
 
480
414
  bool check_default(sql_var_t)
481
415
  {
482
 
    return false;
 
416
    return not have_default_value;
483
417
  }
484
418
 
485
419
  void set_default(Session *, sql_var_t)
489
423
 
490
424
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
491
425
  {
492
 
    basic_value= value.get();
 
426
    basic_value= T(value);
493
427
    return (unsigned char*)&basic_value;
494
428
  }
495
429
};
496
430
 
497
431
template<>
 
432
inline bool sys_var_constrained_value<const uint64_t>::is_readonly() const
 
433
{
 
434
  return true;
 
435
}
 
436
 
 
437
template<>
 
438
inline bool sys_var_constrained_value<const uint32_t>::is_readonly() const
 
439
{
 
440
  return true;
 
441
}
 
442
 
 
443
template<>
498
444
inline SHOW_TYPE sys_var_constrained_value<uint64_t>::show_type()
499
445
{
500
446
  return SHOW_LONGLONG;
509
455
template<>
510
456
inline SHOW_TYPE sys_var_constrained_value<uint32_t>::show_type()
511
457
{
512
 
  return SHOW_INT;
 
458
  return SHOW_LONG;
513
459
}
514
460
 
515
461
template<>
521
467
template<>
522
468
inline bool sys_var_constrained_value<uint64_t>::update(Session *, set_var *var)
523
469
{
524
 
  value= var->getInteger();
 
470
  value= var->save_result.uint64_t_value;
525
471
  return false;
526
472
}
527
473
 
528
474
template<>
529
475
inline bool sys_var_constrained_value<uint32_t>::update(Session *, set_var *var)
530
476
{
531
 
  value= uint32_t(var->getInteger());
 
477
  value= var->save_result.uint32_t_value;
532
478
  return false;
533
479
}
534
480
 
535
 
template<class T>
536
 
class sys_var_constrained_value_readonly :
537
 
  public sys_var_constrained_value<T>
538
 
{
539
 
public:
540
 
  sys_var_constrained_value_readonly(const char *name_arg,
541
 
                                     constrained_value<T> &value_arg) :
542
 
    sys_var_constrained_value<T>(name_arg, value_arg)
543
 
  { }
544
 
 
545
 
  sys_var_constrained_value_readonly(const char *name_arg,
546
 
                                     constrained_value<T> &value_arg,
547
 
                                     T default_value_arg) :
548
 
    sys_var_constrained_value<T>(name_arg, value_arg, default_value_arg)
549
 
  { }
550
 
 
551
 
public:
552
 
  bool is_readonly() const
553
 
  {
554
 
    return true;
555
 
  }
556
 
};
557
 
 
558
 
class DRIZZLED_API sys_var_std_string :
559
 
  public sys_var
560
 
{
561
 
  std::string &value;
562
 
  sys_check_func check_func;
563
 
  sys_update_func update_func;
564
 
  sys_set_default_func set_default_func;
565
 
public:
566
 
  sys_var_std_string(const std::string &name_arg,
567
 
                     std::string &value_arg,
568
 
                     sys_check_func check_func_arg= NULL,
569
 
                     sys_update_func update_func_arg= NULL) :
570
 
    sys_var(name_arg),
571
 
    value(value_arg),
572
 
    check_func(check_func_arg),
573
 
    update_func(update_func_arg)
574
 
  {  }
575
 
 
576
 
  inline void set(char *val_in)
577
 
  {
578
 
    value= val_in; 
579
 
  }
580
 
 
581
 
  void set_check_func(sys_check_func check_func_arg= NULL)
582
 
  {
583
 
    check_func= check_func_arg;
584
 
  }
585
 
 
586
 
  void set_update_func(sys_update_func update_func_arg= NULL)
587
 
  {
588
 
    update_func= update_func_arg;
589
 
  }
590
 
 
591
 
  bool check(Session *session, set_var *var);
592
 
    
593
 
  bool update(Session *session, set_var *var)
594
 
  {
595
 
    if (update_func != NULL)
596
 
    {
597
 
      return (*update_func)(session, var);
598
 
    }
599
 
    return false;
600
 
  }
601
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
602
 
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
603
 
  {
604
 
    return (unsigned char*)(value.c_str());
605
 
  }
606
 
  bool check_update_type(Item_result type)
607
 
  {
608
 
    return type != STRING_RESULT;               /* Only accept strings */
609
 
  }
610
 
  bool check_default(sql_var_t)
611
 
  { return true; }
612
 
  bool is_readonly() const { return false; }
613
 
};
614
 
 
615
 
class DRIZZLED_API sys_var_const_string :
 
481
template<>
 
482
inline unsigned char *sys_var_constrained_value<const uint64_t>::value_ptr(Session *, sql_var_t, const LEX_STRING *)
 
483
{
 
484
  return (unsigned char*)&basic_value;
 
485
}
 
486
 
 
487
template<>
 
488
inline unsigned char *sys_var_constrained_value<const uint32_t>::value_ptr(Session *, sql_var_t, const LEX_STRING *)
 
489
{
 
490
  return (unsigned char*)&basic_value;
 
491
}
 
492
 
 
493
class sys_var_const_string :
616
494
  public sys_var
617
495
{
618
496
  const std::string &value;
647
525
  bool is_readonly() const { return true; }
648
526
};
649
527
 
650
 
class DRIZZLED_API sys_var_const_string_val :
 
528
class sys_var_const_string_val :
651
529
  public sys_var
652
530
{
653
531
  const std::string value;
682
560
  bool is_readonly() const { return true; }
683
561
};
684
562
 
685
 
class DRIZZLED_API sys_var_const_str :public sys_var
 
563
class sys_var_const_str :public sys_var
686
564
{
687
565
  char *value;                                  // Pointer to const value
688
566
public:
717
595
};
718
596
 
719
597
 
720
 
class DRIZZLED_API sys_var_const_str_ptr :public sys_var
 
598
class sys_var_const_str_ptr :public sys_var
721
599
{
722
600
  char **value;                                 // Pointer to const value
723
601
public:
747
625
};
748
626
 
749
627
 
750
 
class DRIZZLED_API sys_var_session :public sys_var
 
628
class sys_var_session :public sys_var
751
629
{
752
630
public:
753
631
  sys_var_session(const char *name_arg,
762
640
  }
763
641
};
764
642
 
765
 
class DRIZZLED_API sys_var_session_uint32_t :public sys_var_session
 
643
class sys_var_session_uint32_t :public sys_var_session
766
644
{
767
645
  sys_check_func check_func;
768
646
public:
783
661
};
784
662
 
785
663
 
786
 
class DRIZZLED_API sys_var_session_ha_rows :public sys_var_session
 
664
class sys_var_session_ha_rows :public sys_var_session
787
665
{
788
666
public:
789
667
  ha_rows drizzle_system_variables::*offset;
804
682
};
805
683
 
806
684
 
807
 
class DRIZZLED_API sys_var_session_uint64_t :public sys_var_session
 
685
class sys_var_session_uint64_t :public sys_var_session
808
686
{
809
687
  sys_check_func check_func;
810
688
public:
845
723
  }
846
724
};
847
725
 
848
 
class DRIZZLED_API sys_var_session_size_t :public sys_var_session
 
726
class sys_var_session_size_t :public sys_var_session
849
727
{
850
728
  sys_check_func check_func;
851
729
public:
886
764
};
887
765
 
888
766
 
889
 
class DRIZZLED_API sys_var_session_bool :public sys_var_session
 
767
class sys_var_session_bool :public sys_var_session
890
768
{
891
769
public:
892
770
  bool drizzle_system_variables::*offset;
902
780
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
903
781
  unsigned char *value_ptr(Session *session, sql_var_t type,
904
782
                           const LEX_STRING *base);
905
 
  bool check(Session *session, set_var *var);
 
783
  bool check(Session *session, set_var *var)
 
784
  {
 
785
    return check_enum(session, var, &bool_typelib);
 
786
  }
906
787
  bool check_update_type(Item_result)
907
788
  { return 0; }
908
789
};
909
790
 
910
791
 
911
 
class DRIZZLED_API sys_var_session_enum :public sys_var_session
 
792
class sys_var_session_enum :public sys_var_session
912
793
{
913
794
protected:
914
795
  uint32_t drizzle_system_variables::*offset;
939
820
};
940
821
 
941
822
 
942
 
class DRIZZLED_API sys_var_session_storage_engine :public sys_var_session
 
823
class sys_var_session_storage_engine :public sys_var_session
943
824
{
944
825
protected:
945
826
  plugin::StorageEngine *drizzle_system_variables::*offset;
948
829
                                 plugin::StorageEngine *drizzle_system_variables::*offset_arg)
949
830
    :sys_var_session(name_arg), offset(offset_arg)
950
831
  {  }
 
832
  bool check(Session *session, set_var *var);
951
833
  SHOW_TYPE show_type() { return SHOW_CHAR; }
952
834
  bool check_update_type(Item_result type)
953
835
  {
959
841
                           const LEX_STRING *base);
960
842
};
961
843
 
962
 
class DRIZZLED_API sys_var_session_bit :public sys_var_session
 
844
class sys_var_session_bit :public sys_var_session
963
845
{
964
846
  sys_check_func check_func;
965
847
  sys_update_func update_func;
984
866
 
985
867
/* some variables that require special handling */
986
868
 
987
 
class DRIZZLED_API sys_var_timestamp :public sys_var
 
869
class sys_var_timestamp :public sys_var
988
870
{
989
871
public:
990
872
  sys_var_timestamp(const char *name_arg)
1001
883
};
1002
884
 
1003
885
 
1004
 
class DRIZZLED_API sys_var_last_insert_id :public sys_var
 
886
class sys_var_last_insert_id :public sys_var
1005
887
{
1006
888
public:
1007
889
  sys_var_last_insert_id(const char *name_arg)
1015
897
};
1016
898
 
1017
899
 
1018
 
class DRIZZLED_API sys_var_collation :public sys_var_session
 
900
class sys_var_collation :public sys_var_session
1019
901
{
1020
902
public:
1021
903
  sys_var_collation(const char *name_arg)
1022
904
    :sys_var_session(name_arg, NULL)
1023
905
  { }
 
906
  bool check(Session *session, set_var *var);
1024
907
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1025
908
  bool check_update_type(Item_result type)
1026
909
  {
1030
913
  virtual void set_default(Session *session, sql_var_t type)= 0;
1031
914
};
1032
915
 
1033
 
class DRIZZLED_API sys_var_collation_sv :public sys_var_collation
 
916
class sys_var_collation_sv :public sys_var_collation
1034
917
{
1035
918
  const CHARSET_INFO *drizzle_system_variables::*offset;
1036
919
  const CHARSET_INFO **global_default;
1051
934
 
1052
935
/* Variable that you can only read from */
1053
936
 
1054
 
class DRIZZLED_API sys_var_readonly: public sys_var
 
937
class sys_var_readonly: public sys_var
1055
938
{
1056
939
public:
1057
940
  sql_var_t var_type;
1079
962
  bool is_readonly(void) const { return 1; }
1080
963
};
1081
964
 
1082
 
class DRIZZLED_API sys_var_microseconds :public sys_var_session
 
965
 
 
966
class sys_var_session_time_zone :public sys_var_session
 
967
{
 
968
public:
 
969
  sys_var_session_time_zone(const char *name_arg)
 
970
    :sys_var_session(name_arg, NULL)
 
971
  {
 
972
    
 
973
  }
 
974
  bool check(Session *session, set_var *var);
 
975
  SHOW_TYPE show_type() { return SHOW_CHAR; }
 
976
  bool check_update_type(Item_result type)
 
977
  {
 
978
    return type != STRING_RESULT;               /* Only accept strings */
 
979
  }
 
980
  bool check_default(sql_var_t)
 
981
  { return 0; }
 
982
  bool update(Session *session, set_var *var);
 
983
  unsigned char *value_ptr(Session *session, sql_var_t type,
 
984
                           const LEX_STRING *base);
 
985
  virtual void set_default(Session *session, sql_var_t type);
 
986
};
 
987
 
 
988
 
 
989
class sys_var_microseconds :public sys_var_session
1083
990
{
1084
991
  uint64_t drizzle_system_variables::*offset;
1085
992
public:
1097
1004
  }
1098
1005
};
1099
1006
 
1100
 
class DRIZZLED_API sys_var_session_lc_time_names :public sys_var_session
 
1007
class sys_var_session_lc_time_names :public sys_var_session
1101
1008
{
1102
1009
public:
1103
1010
  sys_var_session_lc_time_names(const char *name_arg)
1105
1012
  {
1106
1013
    
1107
1014
  }
 
1015
  bool check(Session *session, set_var *var);
1108
1016
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1109
1017
  bool check_update_type(Item_result type)
1110
1018
  {
1132
1040
*/
1133
1041
 
1134
1042
drizzle_show_var* enumerate_sys_vars(Session *session);
 
1043
void drizzle_add_plugin_sysvar(sys_var_pluginvar *var);
 
1044
void drizzle_del_plugin_sysvar();
1135
1045
void add_sys_var_to_list(sys_var *var, struct option *long_options);
1136
1046
void add_sys_var_to_list(sys_var *var);
1137
 
sys_var *find_sys_var(const std::string &name);
 
1047
sys_var *find_sys_var(Session *session, const char *str, uint32_t length=0);
 
1048
bool not_all_support_one_shot(List<set_var_base> *var_list);
 
1049
extern sys_var_session_time_zone sys_time_zone;
1138
1050
extern sys_var_session_bit sys_autocommit;
1139
1051
const CHARSET_INFO *get_old_charset_by_name(const char *old_name);
1140
1052