← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sys_var.h

  • Committer: Monty Taylor
  • Date: 2010-12-02 22:51:54 UTC
  • mto: (1975.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 1976.
  • Revision ID: mordred@inaugust.com-20101202225154-h54ifmga9x6cckgs
Refactored syslog module and changed it to use sys_var directly.

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
26
26
#include "drizzled/constrained_value.h"
27
27
#include "drizzled/set_var.h"
28
28
#include "drizzled/show_type.h"
 
29
#include "drizzled/typelib.h"
29
30
#include "drizzled/item_result.h"
30
31
#include "drizzled/base.h"
31
32
#include "drizzled/global_charset_info.h"
32
33
#include "drizzled/lex_string.h"
33
34
 
34
 
#include "drizzled/visibility.h"
35
 
 
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 *);
65
66
extern uint64_t session_startup_options;
66
67
extern uint32_t global_thread_id;
67
68
extern uint64_t table_cache_size;
 
69
extern uint64_t max_connect_errors;
68
70
extern back_log_constraints back_log;
69
71
extern uint32_t ha_open_options;
70
72
extern char *drizzled_bind_host;
75
77
extern bool opt_readonly;
76
78
extern char *default_tz_name;
77
79
extern const char *opt_scheduler;
78
 
extern size_t transaction_message_threshold;
79
80
 
80
81
uint64_t fix_unsigned(Session *, uint64_t, const struct option *);
81
82
 
85
86
 * A class which represents a variable, either global or 
86
87
 * session-local.
87
88
 */
88
 
class DRIZZLED_API sys_var
 
89
class sys_var
89
90
{
90
91
protected:
91
92
  std::string name; /**< The name of the variable */
92
 
  sys_check_func check_func;
93
93
  sys_after_update_func after_update; /**< Function pointer triggered after the variable's value is updated */
94
94
  struct option *option_limits; /**< Updated by by sys_var_init() */
95
95
  bool m_allow_empty_value; /**< Does variable allow an empty value? */
96
96
public:
97
 
  sys_var(const std::string &name_arg,
98
 
          sys_after_update_func func= NULL,
99
 
          sys_check_func check_func_arg= NULL)
 
97
  sys_var(const std::string &name_arg, sys_after_update_func func= NULL)
100
98
    :
101
99
    name(name_arg),
102
 
    check_func(check_func_arg),
103
100
    after_update(func),
104
101
    option_limits(NULL),
105
102
    m_allow_empty_value(true)
183
180
  {
184
181
    return 0;
185
182
  }
 
183
  virtual sys_var_pluginvar *cast_pluginvar()
 
184
  {
 
185
    return 0;
 
186
  }
186
187
};
187
188
 
188
189
/**
189
190
 * A base class for all variables that require its access to
190
191
 * be guarded with a mutex.
191
192
 */
192
 
class DRIZZLED_API sys_var_global: public sys_var
 
193
class sys_var_global: public sys_var
193
194
{
194
195
protected:
195
196
  pthread_mutex_t *guard;
203
204
  {}
204
205
};
205
206
 
206
 
class DRIZZLED_API sys_var_uint32_t_ptr :public sys_var
 
207
class sys_var_uint32_t_ptr :public sys_var
207
208
{
208
209
  uint32_t *value;
209
210
public:
224
225
  { return (unsigned char*) value; }
225
226
};
226
227
 
227
 
class DRIZZLED_API sys_var_uint32_t_ptr_readonly :
228
 
  public sys_var_uint32_t_ptr
229
 
{
230
 
public:
231
 
  sys_var_uint32_t_ptr_readonly(const char *name_arg,
232
 
                                uint32_t *value_ptr_arg) :
233
 
    sys_var_uint32_t_ptr(name_arg, value_ptr_arg)
234
 
  {}
235
 
 
236
 
  sys_var_uint32_t_ptr_readonly(const char *name_arg,
237
 
                                uint32_t *value_ptr_arg,
238
 
                                sys_after_update_func func) :
239
 
    sys_var_uint32_t_ptr(name_arg, value_ptr_arg, func)
240
 
  {}
241
 
 
242
 
  bool is_readonly() const
243
 
  {
244
 
    return true;
245
 
  }
246
 
};
247
 
 
248
 
 
249
 
class DRIZZLED_API sys_var_uint64_t_ptr :public sys_var
 
228
 
 
229
class sys_var_uint64_t_ptr :public sys_var
250
230
{
251
231
  uint64_t *value;
252
232
  const uint64_t default_value;
299
279
  { return (unsigned char*) value; }
300
280
};
301
281
 
302
 
class DRIZZLED_API sys_var_size_t_ptr :public sys_var
 
282
class sys_var_size_t_ptr :public sys_var
303
283
{
304
284
  size_t *value;
305
285
public:
317
297
  { return (unsigned char*) value; }
318
298
};
319
299
 
320
 
class DRIZZLED_API sys_var_size_t_ptr_readonly :public sys_var_size_t_ptr
321
 
{
322
 
public:
323
 
  sys_var_size_t_ptr_readonly(const char *name_arg,
324
 
                            size_t *value_arg)
325
 
    :sys_var_size_t_ptr(name_arg, value_arg)
326
 
  {}
327
 
  bool is_readonly() const { return 1; }
328
 
};
329
 
 
330
 
class DRIZZLED_API sys_var_bool_ptr :public sys_var
331
 
{
332
 
  bool default_value;
 
300
class sys_var_bool_ptr :public sys_var
 
301
{
333
302
public:
334
303
  bool *value;
335
304
  sys_var_bool_ptr(const std::string &name_arg, bool *value_arg,
336
305
                   sys_after_update_func func= NULL) :
337
 
    sys_var(name_arg, func), default_value(*value_arg), value(value_arg)
 
306
    sys_var(name_arg, func), value(value_arg)
338
307
  { }
339
 
  bool check(Session *session, set_var *var);
340
 
  virtual bool check_default(sql_var_t)
 
308
  bool check(Session *session, set_var *var)
341
309
  {
342
 
    return false;
 
310
    return check_enum(session, var, &bool_typelib);
343
311
  }
344
312
  bool update(Session *session, set_var *var);
345
313
  void set_default(Session *session, sql_var_t type);
350
318
  { return 0; }
351
319
};
352
320
 
353
 
class DRIZZLED_API sys_var_bool_ptr_readonly :public sys_var_bool_ptr
 
321
class sys_var_bool_ptr_readonly :public sys_var_bool_ptr
354
322
{
355
323
public:
356
324
  sys_var_bool_ptr_readonly(const char *name_arg,
361
329
};
362
330
 
363
331
 
364
 
class DRIZZLED_API sys_var_str :public sys_var
 
332
class sys_var_str :public sys_var
365
333
{
366
334
public:
367
335
  char *value;                                  // Pointer to allocated string
368
336
  uint32_t value_length;
 
337
  sys_check_func check_func;
369
338
  sys_update_func update_func;
370
339
  sys_set_default_func set_default_func;
371
340
  sys_var_str(const char *name_arg,
372
341
              sys_check_func check_func_arg,
373
342
              sys_update_func update_func_arg,
374
343
              sys_set_default_func set_default_func_arg,
375
 
              char *value_arg) :
376
 
    sys_var(name_arg, NULL, check_func_arg),
377
 
    value(value_arg),
378
 
    update_func(update_func_arg),
379
 
    set_default_func(set_default_func_arg)
 
344
              char *value_arg)
 
345
    :sys_var(name_arg), value(value_arg), check_func(check_func_arg),
 
346
    update_func(update_func_arg),set_default_func(set_default_func_arg)
380
347
  {  }
381
348
  bool check(Session *session, set_var *var);
382
349
  bool update(Session *session, set_var *var)
399
366
};
400
367
 
401
368
 
402
 
class DRIZZLED_API sys_var_fs_path :
 
369
class sys_var_fs_path :
403
370
  public sys_var
404
371
{
405
372
  const boost::filesystem::path &value;
441
408
  constrained_value<T> &value;
442
409
  T basic_value;
443
410
  T default_value;
 
411
  bool have_default_value;
444
412
public:
445
413
  sys_var_constrained_value(const char *name_arg,
446
414
                            constrained_value<T> &value_arg) :
447
415
    sys_var(name_arg),
448
416
    value(value_arg),
449
 
    default_value(value_arg.get())
 
417
    default_value(0),
 
418
    have_default_value(false)
450
419
  { }
451
420
 
452
421
  sys_var_constrained_value(const char *name_arg,
454
423
                            sys_after_update_func after_update_func_arg) :
455
424
    sys_var(name_arg, after_update_func_arg),
456
425
    value(value_arg),
457
 
    default_value(value_arg.get())
 
426
    default_value(0),
 
427
    have_default_value(false)
458
428
  { }
459
429
 
460
430
  sys_var_constrained_value(const char *name_arg,
461
431
                            constrained_value<T> &value_arg,
462
 
                            sys_check_func check_func_arg) :
463
 
    sys_var(name_arg, NULL, check_func_arg),
 
432
                            T default_value_arg) :
 
433
    sys_var(name_arg),
464
434
    value(value_arg),
465
 
    default_value(value_arg.get())
 
435
    default_value(default_value_arg),
 
436
    have_default_value(true)
466
437
  { }
467
438
 
468
439
public:
475
446
 
476
447
  bool update(Session *, set_var *var)
477
448
  {
478
 
    value= uint32_t(var->getInteger());
 
449
    value= var->save_result.uint32_t_value;
479
450
    return false;
480
451
  }
481
452
 
482
453
  bool check_default(sql_var_t)
483
454
  {
484
 
    return false;
 
455
    return not have_default_value;
485
456
  }
486
457
 
487
458
  void set_default(Session *, sql_var_t)
491
462
 
492
463
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
493
464
  {
494
 
    basic_value= value.get();
 
465
    basic_value= T(value);
495
466
    return (unsigned char*)&basic_value;
496
467
  }
497
468
};
511
482
template<>
512
483
inline SHOW_TYPE sys_var_constrained_value<uint32_t>::show_type()
513
484
{
514
 
  return SHOW_INT;
 
485
  return SHOW_LONG;
515
486
}
516
487
 
517
488
template<>
523
494
template<>
524
495
inline bool sys_var_constrained_value<uint64_t>::update(Session *, set_var *var)
525
496
{
526
 
  value= var->getInteger();
 
497
  value= var->save_result.uint64_t_value;
527
498
  return false;
528
499
}
529
500
 
530
501
template<>
531
502
inline bool sys_var_constrained_value<uint32_t>::update(Session *, set_var *var)
532
503
{
533
 
  value= uint32_t(var->getInteger());
 
504
  value= var->save_result.uint32_t_value;
534
505
  return false;
535
506
}
536
507
 
557
528
  }
558
529
};
559
530
 
560
 
class DRIZZLED_API sys_var_std_string :
 
531
class sys_var_std_string :
561
532
  public sys_var
562
533
{
563
534
  std::string &value;
614
585
  bool is_readonly() const { return false; }
615
586
};
616
587
 
617
 
class DRIZZLED_API sys_var_const_string :
 
588
class sys_var_const_string :
618
589
  public sys_var
619
590
{
620
591
  const std::string &value;
649
620
  bool is_readonly() const { return true; }
650
621
};
651
622
 
652
 
class DRIZZLED_API sys_var_const_string_val :
 
623
class sys_var_const_string_val :
653
624
  public sys_var
654
625
{
655
626
  const std::string value;
684
655
  bool is_readonly() const { return true; }
685
656
};
686
657
 
687
 
class DRIZZLED_API sys_var_const_str :public sys_var
 
658
class sys_var_const_str :public sys_var
688
659
{
689
660
  char *value;                                  // Pointer to const value
690
661
public:
719
690
};
720
691
 
721
692
 
722
 
class DRIZZLED_API sys_var_const_str_ptr :public sys_var
 
693
class sys_var_const_str_ptr :public sys_var
723
694
{
724
695
  char **value;                                 // Pointer to const value
725
696
public:
749
720
};
750
721
 
751
722
 
752
 
class DRIZZLED_API sys_var_session :public sys_var
 
723
class sys_var_session :public sys_var
753
724
{
754
725
public:
755
726
  sys_var_session(const char *name_arg,
764
735
  }
765
736
};
766
737
 
767
 
class DRIZZLED_API sys_var_session_uint32_t :public sys_var_session
 
738
class sys_var_session_uint32_t :public sys_var_session
768
739
{
769
740
  sys_check_func check_func;
770
741
public:
785
756
};
786
757
 
787
758
 
788
 
class DRIZZLED_API sys_var_session_ha_rows :public sys_var_session
 
759
class sys_var_session_ha_rows :public sys_var_session
789
760
{
790
761
public:
791
762
  ha_rows drizzle_system_variables::*offset;
806
777
};
807
778
 
808
779
 
809
 
class DRIZZLED_API sys_var_session_uint64_t :public sys_var_session
 
780
class sys_var_session_uint64_t :public sys_var_session
810
781
{
811
782
  sys_check_func check_func;
812
783
public:
847
818
  }
848
819
};
849
820
 
850
 
class DRIZZLED_API sys_var_session_size_t :public sys_var_session
 
821
class sys_var_session_size_t :public sys_var_session
851
822
{
852
823
  sys_check_func check_func;
853
824
public:
888
859
};
889
860
 
890
861
 
891
 
class DRIZZLED_API sys_var_session_bool :public sys_var_session
 
862
class sys_var_session_bool :public sys_var_session
892
863
{
893
864
public:
894
865
  bool drizzle_system_variables::*offset;
904
875
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
905
876
  unsigned char *value_ptr(Session *session, sql_var_t type,
906
877
                           const LEX_STRING *base);
907
 
  bool check(Session *session, set_var *var);
 
878
  bool check(Session *session, set_var *var)
 
879
  {
 
880
    return check_enum(session, var, &bool_typelib);
 
881
  }
908
882
  bool check_update_type(Item_result)
909
883
  { return 0; }
910
884
};
911
885
 
912
886
 
913
 
class DRIZZLED_API sys_var_session_enum :public sys_var_session
 
887
class sys_var_session_enum :public sys_var_session
914
888
{
915
889
protected:
916
890
  uint32_t drizzle_system_variables::*offset;
941
915
};
942
916
 
943
917
 
944
 
class DRIZZLED_API sys_var_session_storage_engine :public sys_var_session
 
918
class sys_var_session_storage_engine :public sys_var_session
945
919
{
946
920
protected:
947
921
  plugin::StorageEngine *drizzle_system_variables::*offset;
950
924
                                 plugin::StorageEngine *drizzle_system_variables::*offset_arg)
951
925
    :sys_var_session(name_arg), offset(offset_arg)
952
926
  {  }
 
927
  bool check(Session *session, set_var *var);
953
928
  SHOW_TYPE show_type() { return SHOW_CHAR; }
954
929
  bool check_update_type(Item_result type)
955
930
  {
961
936
                           const LEX_STRING *base);
962
937
};
963
938
 
964
 
class DRIZZLED_API sys_var_session_bit :public sys_var_session
 
939
class sys_var_session_bit :public sys_var_session
965
940
{
966
941
  sys_check_func check_func;
967
942
  sys_update_func update_func;
986
961
 
987
962
/* some variables that require special handling */
988
963
 
989
 
class DRIZZLED_API sys_var_timestamp :public sys_var
 
964
class sys_var_timestamp :public sys_var
990
965
{
991
966
public:
992
967
  sys_var_timestamp(const char *name_arg)
1003
978
};
1004
979
 
1005
980
 
1006
 
class DRIZZLED_API sys_var_last_insert_id :public sys_var
 
981
class sys_var_last_insert_id :public sys_var
1007
982
{
1008
983
public:
1009
984
  sys_var_last_insert_id(const char *name_arg)
1017
992
};
1018
993
 
1019
994
 
1020
 
class DRIZZLED_API sys_var_collation :public sys_var_session
 
995
class sys_var_collation :public sys_var_session
1021
996
{
1022
997
public:
1023
998
  sys_var_collation(const char *name_arg)
1024
999
    :sys_var_session(name_arg, NULL)
1025
1000
  { }
 
1001
  bool check(Session *session, set_var *var);
1026
1002
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1027
1003
  bool check_update_type(Item_result type)
1028
1004
  {
1032
1008
  virtual void set_default(Session *session, sql_var_t type)= 0;
1033
1009
};
1034
1010
 
1035
 
class DRIZZLED_API sys_var_collation_sv :public sys_var_collation
 
1011
class sys_var_collation_sv :public sys_var_collation
1036
1012
{
1037
1013
  const CHARSET_INFO *drizzle_system_variables::*offset;
1038
1014
  const CHARSET_INFO **global_default;
1053
1029
 
1054
1030
/* Variable that you can only read from */
1055
1031
 
1056
 
class DRIZZLED_API sys_var_readonly: public sys_var
 
1032
class sys_var_readonly: public sys_var
1057
1033
{
1058
1034
public:
1059
1035
  sql_var_t var_type;
1082
1058
};
1083
1059
 
1084
1060
 
1085
 
class DRIZZLED_API sys_var_session_time_zone :public sys_var_session
 
1061
class sys_var_session_time_zone :public sys_var_session
1086
1062
{
1087
1063
public:
1088
1064
  sys_var_session_time_zone(const char *name_arg)
1090
1066
  {
1091
1067
    
1092
1068
  }
 
1069
  bool check(Session *session, set_var *var);
1093
1070
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1094
1071
  bool check_update_type(Item_result type)
1095
1072
  {
1104
1081
};
1105
1082
 
1106
1083
 
1107
 
class DRIZZLED_API sys_var_microseconds :public sys_var_session
 
1084
class sys_var_microseconds :public sys_var_session
1108
1085
{
1109
1086
  uint64_t drizzle_system_variables::*offset;
1110
1087
public:
1122
1099
  }
1123
1100
};
1124
1101
 
1125
 
class DRIZZLED_API sys_var_session_lc_time_names :public sys_var_session
 
1102
class sys_var_session_lc_time_names :public sys_var_session
1126
1103
{
1127
1104
public:
1128
1105
  sys_var_session_lc_time_names(const char *name_arg)
1130
1107
  {
1131
1108
    
1132
1109
  }
 
1110
  bool check(Session *session, set_var *var);
1133
1111
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1134
1112
  bool check_update_type(Item_result type)
1135
1113
  {
1157
1135
*/
1158
1136
 
1159
1137
drizzle_show_var* enumerate_sys_vars(Session *session);
 
1138
void drizzle_add_plugin_sysvar(sys_var_pluginvar *var);
 
1139
void drizzle_del_plugin_sysvar();
1160
1140
void add_sys_var_to_list(sys_var *var, struct option *long_options);
1161
1141
void add_sys_var_to_list(sys_var *var);
1162
 
sys_var *find_sys_var(const std::string &name);
 
1142
sys_var *find_sys_var(Session *session, const char *str, uint32_t length=0);
 
1143
bool not_all_support_one_shot(List<set_var_base> *var_list);
1163
1144
extern sys_var_session_time_zone sys_time_zone;
1164
1145
extern sys_var_session_bit sys_autocommit;
1165
1146
const CHARSET_INFO *get_old_charset_by_name(const char *old_name);