← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sys_var.h

  • Committer: Brian Aker
  • Date: 2010-11-12 21:22:46 UTC
  • mto: (1932.2.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 1930.
  • Revision ID: brian@tangent.org-20101112212246-jsn2vgxzgesuv9pt
Test for issues on CONCURRENT to be sure it operates in a single
transaction.

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
#include "drizzled/constrained_value.h"
 
27
#include "drizzled/set_var.h"
 
28
#include "drizzled/show_type.h"
 
29
#include "drizzled/typelib.h"
 
30
#include "drizzled/item_result.h"
 
31
#include "drizzled/base.h"
 
32
#include "drizzled/global_charset_info.h"
 
33
#include "drizzled/lex_string.h"
35
34
 
36
35
namespace drizzled
37
36
{
38
37
 
39
38
class sys_var;
 
39
class sys_var_pluginvar; /* opaque */
40
40
class Time_zone;
41
41
typedef struct my_locale_st MY_LOCALE;
42
 
typedef struct st_typelib TYPELIB;
 
42
 
 
43
extern TYPELIB bool_typelib;
43
44
 
44
45
typedef int (*sys_check_func)(Session *,  set_var *);
45
46
typedef bool (*sys_update_func)(Session *, set_var *);
56
57
extern const char *in_left_expr_name;
57
58
extern const char *in_additional_cond;
58
59
extern const char *in_having_cond;
 
60
extern char glob_hostname[FN_REFLEN];
59
61
extern boost::filesystem::path basedir;
60
62
extern boost::filesystem::path pid_file;
61
63
extern boost::filesystem::path secure_file_priv;
 
64
extern char system_time_zone[30];
62
65
extern char *opt_tc_log_file;
63
66
extern uint64_t session_startup_options;
64
67
extern uint32_t global_thread_id;
65
68
extern uint64_t table_cache_size;
 
69
extern uint64_t max_connect_errors;
66
70
extern back_log_constraints back_log;
67
71
extern uint32_t ha_open_options;
68
72
extern char *drizzled_bind_host;
71
75
extern uint32_t volatile thread_running;
72
76
extern uint32_t volatile global_read_lock;
73
77
extern bool opt_readonly;
 
78
extern char *default_tz_name;
74
79
extern const char *opt_scheduler;
75
 
extern size_t transaction_message_threshold;
76
80
 
77
81
uint64_t fix_unsigned(Session *, uint64_t, const struct option *);
78
82
 
79
 
const std::string &getServerHostname();
80
83
int sys_var_init();
81
84
 
82
85
/**
83
86
 * A class which represents a variable, either global or 
84
87
 * session-local.
85
88
 */
86
 
class DRIZZLED_API sys_var
 
89
class sys_var
87
90
{
88
91
protected:
89
92
  std::string name; /**< The name of the variable */
90
 
  sys_check_func check_func;
91
93
  sys_after_update_func after_update; /**< Function pointer triggered after the variable's value is updated */
92
94
  struct option *option_limits; /**< Updated by by sys_var_init() */
93
95
  bool m_allow_empty_value; /**< Does variable allow an empty value? */
94
96
public:
95
 
  sys_var(const std::string &name_arg,
96
 
          sys_after_update_func func= NULL,
97
 
          sys_check_func check_func_arg= NULL)
 
97
  sys_var(const std::string name_arg, sys_after_update_func func= NULL)
98
98
    :
99
99
    name(name_arg),
100
 
    check_func(check_func_arg),
101
100
    after_update(func),
102
 
    option_limits(NULL),
103
101
    m_allow_empty_value(true)
104
102
  {}
105
103
  virtual ~sys_var() {}
181
179
  {
182
180
    return 0;
183
181
  }
 
182
  virtual sys_var_pluginvar *cast_pluginvar()
 
183
  {
 
184
    return 0;
 
185
  }
184
186
};
185
187
 
186
188
/**
187
189
 * A base class for all variables that require its access to
188
190
 * be guarded with a mutex.
189
191
 */
190
 
class DRIZZLED_API sys_var_global: public sys_var
 
192
class sys_var_global: public sys_var
191
193
{
192
194
protected:
193
195
  pthread_mutex_t *guard;
201
203
  {}
202
204
};
203
205
 
204
 
class DRIZZLED_API sys_var_uint32_t_ptr :public sys_var
 
206
class sys_var_uint32_t_ptr :public sys_var
205
207
{
206
208
  uint32_t *value;
207
209
public:
222
224
  { return (unsigned char*) value; }
223
225
};
224
226
 
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
 
227
 
 
228
class sys_var_uint64_t_ptr :public sys_var
248
229
{
249
230
  uint64_t *value;
250
 
  const uint64_t default_value;
251
 
  bool have_default_value;
252
231
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
 
 
 
232
  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg)
 
233
    :sys_var(name_arg),value(value_ptr_arg)
 
234
  {  }
 
235
  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg,
 
236
                       sys_after_update_func func)
 
237
    :sys_var(name_arg,func), value(value_ptr_arg)
 
238
  {  }
288
239
  bool update(Session *session, set_var *var);
289
240
  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
241
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
295
242
  unsigned char *value_ptr(Session *, sql_var_t,
296
243
                           const LEX_STRING *)
297
244
  { return (unsigned char*) value; }
298
245
};
299
246
 
300
 
class DRIZZLED_API sys_var_size_t_ptr :public sys_var
 
247
class sys_var_size_t_ptr :public sys_var
301
248
{
302
249
  size_t *value;
303
250
public:
315
262
  { return (unsigned char*) value; }
316
263
};
317
264
 
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;
 
265
class sys_var_bool_ptr :public sys_var
 
266
{
331
267
public:
332
268
  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)
 
269
  sys_var_bool_ptr(const char *name_arg, bool *value_arg)
 
270
    :sys_var(name_arg),value(value_arg)
 
271
  {  }
 
272
  bool check(Session *session, set_var *var)
339
273
  {
340
 
    return false;
 
274
    return check_enum(session, var, &bool_typelib);
341
275
  }
342
276
  bool update(Session *session, set_var *var);
343
277
  void set_default(Session *session, sql_var_t type);
348
282
  { return 0; }
349
283
};
350
284
 
351
 
class DRIZZLED_API sys_var_bool_ptr_readonly :public sys_var_bool_ptr
 
285
class sys_var_bool_ptr_readonly :public sys_var_bool_ptr
352
286
{
353
287
public:
354
288
  sys_var_bool_ptr_readonly(const char *name_arg,
359
293
};
360
294
 
361
295
 
362
 
class DRIZZLED_API sys_var_str :public sys_var
 
296
class sys_var_str :public sys_var
363
297
{
364
298
public:
365
299
  char *value;                                  // Pointer to allocated string
366
300
  uint32_t value_length;
 
301
  sys_check_func check_func;
367
302
  sys_update_func update_func;
368
303
  sys_set_default_func set_default_func;
369
304
  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)
 
305
              sys_check_func check_func_arg,
 
306
              sys_update_func update_func_arg,
 
307
              sys_set_default_func set_default_func_arg,
 
308
              char *value_arg)
 
309
    :sys_var(name_arg), value(value_arg), check_func(check_func_arg),
 
310
    update_func(update_func_arg),set_default_func(set_default_func_arg)
378
311
  {  }
379
312
  bool check(Session *session, set_var *var);
380
313
  bool update(Session *session, set_var *var)
397
330
};
398
331
 
399
332
 
400
 
class DRIZZLED_API sys_var_fs_path :
 
333
class sys_var_fs_path :
401
334
  public sys_var
402
335
{
403
336
  const boost::filesystem::path &value;
439
372
  constrained_value<T> &value;
440
373
  T basic_value;
441
374
  T default_value;
 
375
  bool have_default_value;
442
376
public:
443
377
  sys_var_constrained_value(const char *name_arg,
444
378
                            constrained_value<T> &value_arg) :
445
379
    sys_var(name_arg),
446
380
    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())
 
381
    default_value(0),
 
382
    have_default_value(false)
 
383
  { }
 
384
 
 
385
  sys_var_constrained_value(const char *name_arg,
 
386
                            constrained_value<T> &value_arg,
 
387
                            T default_value_arg) :
 
388
    sys_var(name_arg),
 
389
    value(value_arg),
 
390
    default_value(default_value_arg),
 
391
    have_default_value(true)
464
392
  { }
465
393
 
466
394
public:
473
401
 
474
402
  bool update(Session *, set_var *var)
475
403
  {
476
 
    value= uint32_t(var->getInteger());
 
404
    value= var->save_result.uint32_t_value;
477
405
    return false;
478
406
  }
479
407
 
480
408
  bool check_default(sql_var_t)
481
409
  {
482
 
    return false;
 
410
    return not have_default_value;
483
411
  }
484
412
 
485
413
  void set_default(Session *, sql_var_t)
489
417
 
490
418
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
491
419
  {
492
 
    basic_value= value.get();
 
420
    basic_value= T(value);
493
421
    return (unsigned char*)&basic_value;
494
422
  }
495
423
};
509
437
template<>
510
438
inline SHOW_TYPE sys_var_constrained_value<uint32_t>::show_type()
511
439
{
512
 
  return SHOW_INT;
 
440
  return SHOW_LONG;
513
441
}
514
442
 
515
443
template<>
521
449
template<>
522
450
inline bool sys_var_constrained_value<uint64_t>::update(Session *, set_var *var)
523
451
{
524
 
  value= var->getInteger();
 
452
  value= var->save_result.uint64_t_value;
525
453
  return false;
526
454
}
527
455
 
528
456
template<>
529
457
inline bool sys_var_constrained_value<uint32_t>::update(Session *, set_var *var)
530
458
{
531
 
  value= uint32_t(var->getInteger());
 
459
  value= var->save_result.uint32_t_value;
532
460
  return false;
533
461
}
534
462
 
555
483
  }
556
484
};
557
485
 
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 :
 
486
class sys_var_const_string :
616
487
  public sys_var
617
488
{
618
489
  const std::string &value;
647
518
  bool is_readonly() const { return true; }
648
519
};
649
520
 
650
 
class DRIZZLED_API sys_var_const_string_val :
 
521
class sys_var_const_string_val :
651
522
  public sys_var
652
523
{
653
524
  const std::string value;
682
553
  bool is_readonly() const { return true; }
683
554
};
684
555
 
685
 
class DRIZZLED_API sys_var_const_str :public sys_var
 
556
class sys_var_const_str :public sys_var
686
557
{
687
558
  char *value;                                  // Pointer to const value
688
559
public:
717
588
};
718
589
 
719
590
 
720
 
class DRIZZLED_API sys_var_const_str_ptr :public sys_var
 
591
class sys_var_const_str_ptr :public sys_var
721
592
{
722
593
  char **value;                                 // Pointer to const value
723
594
public:
747
618
};
748
619
 
749
620
 
750
 
class DRIZZLED_API sys_var_session :public sys_var
 
621
class sys_var_session :public sys_var
751
622
{
752
623
public:
753
624
  sys_var_session(const char *name_arg,
762
633
  }
763
634
};
764
635
 
765
 
class DRIZZLED_API sys_var_session_uint32_t :public sys_var_session
 
636
class sys_var_session_uint32_t :public sys_var_session
766
637
{
767
638
  sys_check_func check_func;
768
639
public:
783
654
};
784
655
 
785
656
 
786
 
class DRIZZLED_API sys_var_session_ha_rows :public sys_var_session
 
657
class sys_var_session_ha_rows :public sys_var_session
787
658
{
788
659
public:
789
660
  ha_rows drizzle_system_variables::*offset;
804
675
};
805
676
 
806
677
 
807
 
class DRIZZLED_API sys_var_session_uint64_t :public sys_var_session
 
678
class sys_var_session_uint64_t :public sys_var_session
808
679
{
809
680
  sys_check_func check_func;
810
681
public:
845
716
  }
846
717
};
847
718
 
848
 
class DRIZZLED_API sys_var_session_size_t :public sys_var_session
 
719
class sys_var_session_size_t :public sys_var_session
849
720
{
850
721
  sys_check_func check_func;
851
722
public:
886
757
};
887
758
 
888
759
 
889
 
class DRIZZLED_API sys_var_session_bool :public sys_var_session
 
760
class sys_var_session_bool :public sys_var_session
890
761
{
891
762
public:
892
763
  bool drizzle_system_variables::*offset;
902
773
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
903
774
  unsigned char *value_ptr(Session *session, sql_var_t type,
904
775
                           const LEX_STRING *base);
905
 
  bool check(Session *session, set_var *var);
 
776
  bool check(Session *session, set_var *var)
 
777
  {
 
778
    return check_enum(session, var, &bool_typelib);
 
779
  }
906
780
  bool check_update_type(Item_result)
907
781
  { return 0; }
908
782
};
909
783
 
910
784
 
911
 
class DRIZZLED_API sys_var_session_enum :public sys_var_session
 
785
class sys_var_session_enum :public sys_var_session
912
786
{
913
787
protected:
914
788
  uint32_t drizzle_system_variables::*offset;
939
813
};
940
814
 
941
815
 
942
 
class DRIZZLED_API sys_var_session_storage_engine :public sys_var_session
 
816
class sys_var_session_storage_engine :public sys_var_session
943
817
{
944
818
protected:
945
819
  plugin::StorageEngine *drizzle_system_variables::*offset;
948
822
                                 plugin::StorageEngine *drizzle_system_variables::*offset_arg)
949
823
    :sys_var_session(name_arg), offset(offset_arg)
950
824
  {  }
 
825
  bool check(Session *session, set_var *var);
951
826
  SHOW_TYPE show_type() { return SHOW_CHAR; }
952
827
  bool check_update_type(Item_result type)
953
828
  {
959
834
                           const LEX_STRING *base);
960
835
};
961
836
 
962
 
class DRIZZLED_API sys_var_session_bit :public sys_var_session
 
837
class sys_var_session_bit :public sys_var_session
963
838
{
964
839
  sys_check_func check_func;
965
840
  sys_update_func update_func;
984
859
 
985
860
/* some variables that require special handling */
986
861
 
987
 
class DRIZZLED_API sys_var_timestamp :public sys_var
 
862
class sys_var_timestamp :public sys_var
988
863
{
989
864
public:
990
865
  sys_var_timestamp(const char *name_arg)
1001
876
};
1002
877
 
1003
878
 
1004
 
class DRIZZLED_API sys_var_last_insert_id :public sys_var
 
879
class sys_var_last_insert_id :public sys_var
1005
880
{
1006
881
public:
1007
882
  sys_var_last_insert_id(const char *name_arg)
1015
890
};
1016
891
 
1017
892
 
1018
 
class DRIZZLED_API sys_var_collation :public sys_var_session
 
893
class sys_var_collation :public sys_var_session
1019
894
{
1020
895
public:
1021
896
  sys_var_collation(const char *name_arg)
1022
897
    :sys_var_session(name_arg, NULL)
1023
898
  { }
 
899
  bool check(Session *session, set_var *var);
1024
900
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1025
901
  bool check_update_type(Item_result type)
1026
902
  {
1030
906
  virtual void set_default(Session *session, sql_var_t type)= 0;
1031
907
};
1032
908
 
1033
 
class DRIZZLED_API sys_var_collation_sv :public sys_var_collation
 
909
class sys_var_collation_sv :public sys_var_collation
1034
910
{
1035
911
  const CHARSET_INFO *drizzle_system_variables::*offset;
1036
912
  const CHARSET_INFO **global_default;
1051
927
 
1052
928
/* Variable that you can only read from */
1053
929
 
1054
 
class DRIZZLED_API sys_var_readonly: public sys_var
 
930
class sys_var_readonly: public sys_var
1055
931
{
1056
932
public:
1057
933
  sql_var_t var_type;
1079
955
  bool is_readonly(void) const { return 1; }
1080
956
};
1081
957
 
1082
 
class DRIZZLED_API sys_var_microseconds :public sys_var_session
 
958
 
 
959
class sys_var_session_time_zone :public sys_var_session
 
960
{
 
961
public:
 
962
  sys_var_session_time_zone(const char *name_arg)
 
963
    :sys_var_session(name_arg, NULL)
 
964
  {
 
965
    
 
966
  }
 
967
  bool check(Session *session, set_var *var);
 
968
  SHOW_TYPE show_type() { return SHOW_CHAR; }
 
969
  bool check_update_type(Item_result type)
 
970
  {
 
971
    return type != STRING_RESULT;               /* Only accept strings */
 
972
  }
 
973
  bool check_default(sql_var_t)
 
974
  { return 0; }
 
975
  bool update(Session *session, set_var *var);
 
976
  unsigned char *value_ptr(Session *session, sql_var_t type,
 
977
                           const LEX_STRING *base);
 
978
  virtual void set_default(Session *session, sql_var_t type);
 
979
};
 
980
 
 
981
 
 
982
class sys_var_microseconds :public sys_var_session
1083
983
{
1084
984
  uint64_t drizzle_system_variables::*offset;
1085
985
public:
1097
997
  }
1098
998
};
1099
999
 
1100
 
class DRIZZLED_API sys_var_session_lc_time_names :public sys_var_session
 
1000
class sys_var_session_lc_time_names :public sys_var_session
1101
1001
{
1102
1002
public:
1103
1003
  sys_var_session_lc_time_names(const char *name_arg)
1105
1005
  {
1106
1006
    
1107
1007
  }
 
1008
  bool check(Session *session, set_var *var);
1108
1009
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1109
1010
  bool check_update_type(Item_result type)
1110
1011
  {
1132
1033
*/
1133
1034
 
1134
1035
drizzle_show_var* enumerate_sys_vars(Session *session);
 
1036
void drizzle_add_plugin_sysvar(sys_var_pluginvar *var);
 
1037
void drizzle_del_plugin_sysvar();
1135
1038
void add_sys_var_to_list(sys_var *var, struct option *long_options);
1136
1039
void add_sys_var_to_list(sys_var *var);
1137
 
sys_var *find_sys_var(const std::string &name);
 
1040
sys_var *find_sys_var(Session *session, const char *str, uint32_t length=0);
 
1041
bool not_all_support_one_shot(List<set_var_base> *var_list);
 
1042
extern sys_var_session_time_zone sys_time_zone;
1138
1043
extern sys_var_session_bit sys_autocommit;
1139
1044
const CHARSET_INFO *get_old_charset_by_name(const char *old_name);
1140
1045