← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sys_var.h

Merge with trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sys_var.h
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"
30
29
#include "drizzled/item_result.h"
31
30
#include "drizzled/base.h"
32
31
#include "drizzled/global_charset_info.h"
33
32
#include "drizzled/lex_string.h"
34
33
 
 
34
#include "drizzled/visibility.h"
 
35
 
35
36
namespace drizzled
36
37
{
37
38
 
38
39
class sys_var;
39
40
class Time_zone;
40
41
typedef struct my_locale_st MY_LOCALE;
41
 
 
42
 
extern TYPELIB bool_typelib;
 
42
typedef struct st_typelib TYPELIB;
43
43
 
44
44
typedef int (*sys_check_func)(Session *,  set_var *);
45
45
typedef bool (*sys_update_func)(Session *, set_var *);
65
65
extern uint64_t session_startup_options;
66
66
extern uint32_t global_thread_id;
67
67
extern uint64_t table_cache_size;
68
 
extern uint64_t max_connect_errors;
69
68
extern back_log_constraints back_log;
70
69
extern uint32_t ha_open_options;
71
70
extern char *drizzled_bind_host;
76
75
extern bool opt_readonly;
77
76
extern char *default_tz_name;
78
77
extern const char *opt_scheduler;
 
78
extern size_t transaction_message_threshold;
79
79
 
80
80
uint64_t fix_unsigned(Session *, uint64_t, const struct option *);
81
81
 
85
85
 * A class which represents a variable, either global or 
86
86
 * session-local.
87
87
 */
88
 
class sys_var
 
88
class DRIZZLED_API sys_var
89
89
{
90
90
protected:
91
91
  std::string name; /**< The name of the variable */
189
189
 * A base class for all variables that require its access to
190
190
 * be guarded with a mutex.
191
191
 */
192
 
class sys_var_global: public sys_var
 
192
class DRIZZLED_API sys_var_global: public sys_var
193
193
{
194
194
protected:
195
195
  pthread_mutex_t *guard;
203
203
  {}
204
204
};
205
205
 
206
 
class sys_var_uint32_t_ptr :public sys_var
 
206
class DRIZZLED_API sys_var_uint32_t_ptr :public sys_var
207
207
{
208
208
  uint32_t *value;
209
209
public:
224
224
  { return (unsigned char*) value; }
225
225
};
226
226
 
227
 
class sys_var_uint32_t_ptr_readonly :
 
227
class DRIZZLED_API sys_var_uint32_t_ptr_readonly :
228
228
  public sys_var_uint32_t_ptr
229
229
{
230
230
public:
246
246
};
247
247
 
248
248
 
249
 
class sys_var_uint64_t_ptr :public sys_var
 
249
class DRIZZLED_API sys_var_uint64_t_ptr :public sys_var
250
250
{
251
251
  uint64_t *value;
252
252
  const uint64_t default_value;
299
299
  { return (unsigned char*) value; }
300
300
};
301
301
 
302
 
class sys_var_size_t_ptr :public sys_var
 
302
class DRIZZLED_API sys_var_size_t_ptr :public sys_var
303
303
{
304
304
  size_t *value;
305
305
public:
317
317
  { return (unsigned char*) value; }
318
318
};
319
319
 
320
 
class sys_var_bool_ptr :public sys_var
 
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
321
331
{
322
332
  bool default_value;
323
333
public:
326
336
                   sys_after_update_func func= NULL) :
327
337
    sys_var(name_arg, func), default_value(*value_arg), value(value_arg)
328
338
  { }
329
 
  bool check(Session *session, set_var *var)
330
 
  {
331
 
    return check_enum(session, var, &bool_typelib);
332
 
  }
 
339
  bool check(Session *session, set_var *var);
333
340
  virtual bool check_default(sql_var_t)
334
341
  {
335
342
    return false;
343
350
  { return 0; }
344
351
};
345
352
 
346
 
class sys_var_bool_ptr_readonly :public sys_var_bool_ptr
 
353
class DRIZZLED_API sys_var_bool_ptr_readonly :public sys_var_bool_ptr
347
354
{
348
355
public:
349
356
  sys_var_bool_ptr_readonly(const char *name_arg,
354
361
};
355
362
 
356
363
 
357
 
class sys_var_str :public sys_var
 
364
class DRIZZLED_API sys_var_str :public sys_var
358
365
{
359
366
public:
360
367
  char *value;                                  // Pointer to allocated string
392
399
};
393
400
 
394
401
 
395
 
class sys_var_fs_path :
 
402
class DRIZZLED_API sys_var_fs_path :
396
403
  public sys_var
397
404
{
398
405
  const boost::filesystem::path &value;
468
475
 
469
476
  bool update(Session *, set_var *var)
470
477
  {
471
 
    value= var->save_result.uint32_t_value;
 
478
    value= uint32_t(var->getInteger());
472
479
    return false;
473
480
  }
474
481
 
516
523
template<>
517
524
inline bool sys_var_constrained_value<uint64_t>::update(Session *, set_var *var)
518
525
{
519
 
  value= var->save_result.uint64_t_value;
 
526
  value= var->getInteger();
520
527
  return false;
521
528
}
522
529
 
523
530
template<>
524
531
inline bool sys_var_constrained_value<uint32_t>::update(Session *, set_var *var)
525
532
{
526
 
  value= var->save_result.uint32_t_value;
 
533
  value= uint32_t(var->getInteger());
527
534
  return false;
528
535
}
529
536
 
550
557
  }
551
558
};
552
559
 
553
 
class sys_var_std_string :
 
560
class DRIZZLED_API sys_var_std_string :
554
561
  public sys_var
555
562
{
556
563
  std::string &value;
607
614
  bool is_readonly() const { return false; }
608
615
};
609
616
 
610
 
class sys_var_const_string :
 
617
class DRIZZLED_API sys_var_const_string :
611
618
  public sys_var
612
619
{
613
620
  const std::string &value;
642
649
  bool is_readonly() const { return true; }
643
650
};
644
651
 
645
 
class sys_var_const_string_val :
 
652
class DRIZZLED_API sys_var_const_string_val :
646
653
  public sys_var
647
654
{
648
655
  const std::string value;
677
684
  bool is_readonly() const { return true; }
678
685
};
679
686
 
680
 
class sys_var_const_str :public sys_var
 
687
class DRIZZLED_API sys_var_const_str :public sys_var
681
688
{
682
689
  char *value;                                  // Pointer to const value
683
690
public:
712
719
};
713
720
 
714
721
 
715
 
class sys_var_const_str_ptr :public sys_var
 
722
class DRIZZLED_API sys_var_const_str_ptr :public sys_var
716
723
{
717
724
  char **value;                                 // Pointer to const value
718
725
public:
742
749
};
743
750
 
744
751
 
745
 
class sys_var_session :public sys_var
 
752
class DRIZZLED_API sys_var_session :public sys_var
746
753
{
747
754
public:
748
755
  sys_var_session(const char *name_arg,
757
764
  }
758
765
};
759
766
 
760
 
class sys_var_session_uint32_t :public sys_var_session
 
767
class DRIZZLED_API sys_var_session_uint32_t :public sys_var_session
761
768
{
762
769
  sys_check_func check_func;
763
770
public:
778
785
};
779
786
 
780
787
 
781
 
class sys_var_session_ha_rows :public sys_var_session
 
788
class DRIZZLED_API sys_var_session_ha_rows :public sys_var_session
782
789
{
783
790
public:
784
791
  ha_rows drizzle_system_variables::*offset;
799
806
};
800
807
 
801
808
 
802
 
class sys_var_session_uint64_t :public sys_var_session
 
809
class DRIZZLED_API sys_var_session_uint64_t :public sys_var_session
803
810
{
804
811
  sys_check_func check_func;
805
812
public:
840
847
  }
841
848
};
842
849
 
843
 
class sys_var_session_size_t :public sys_var_session
 
850
class DRIZZLED_API sys_var_session_size_t :public sys_var_session
844
851
{
845
852
  sys_check_func check_func;
846
853
public:
881
888
};
882
889
 
883
890
 
884
 
class sys_var_session_bool :public sys_var_session
 
891
class DRIZZLED_API sys_var_session_bool :public sys_var_session
885
892
{
886
893
public:
887
894
  bool drizzle_system_variables::*offset;
897
904
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
898
905
  unsigned char *value_ptr(Session *session, sql_var_t type,
899
906
                           const LEX_STRING *base);
900
 
  bool check(Session *session, set_var *var)
901
 
  {
902
 
    return check_enum(session, var, &bool_typelib);
903
 
  }
 
907
  bool check(Session *session, set_var *var);
904
908
  bool check_update_type(Item_result)
905
909
  { return 0; }
906
910
};
907
911
 
908
912
 
909
 
class sys_var_session_enum :public sys_var_session
 
913
class DRIZZLED_API sys_var_session_enum :public sys_var_session
910
914
{
911
915
protected:
912
916
  uint32_t drizzle_system_variables::*offset;
937
941
};
938
942
 
939
943
 
940
 
class sys_var_session_storage_engine :public sys_var_session
 
944
class DRIZZLED_API sys_var_session_storage_engine :public sys_var_session
941
945
{
942
946
protected:
943
947
  plugin::StorageEngine *drizzle_system_variables::*offset;
946
950
                                 plugin::StorageEngine *drizzle_system_variables::*offset_arg)
947
951
    :sys_var_session(name_arg), offset(offset_arg)
948
952
  {  }
949
 
  bool check(Session *session, set_var *var);
950
953
  SHOW_TYPE show_type() { return SHOW_CHAR; }
951
954
  bool check_update_type(Item_result type)
952
955
  {
958
961
                           const LEX_STRING *base);
959
962
};
960
963
 
961
 
class sys_var_session_bit :public sys_var_session
 
964
class DRIZZLED_API sys_var_session_bit :public sys_var_session
962
965
{
963
966
  sys_check_func check_func;
964
967
  sys_update_func update_func;
983
986
 
984
987
/* some variables that require special handling */
985
988
 
986
 
class sys_var_timestamp :public sys_var
 
989
class DRIZZLED_API sys_var_timestamp :public sys_var
987
990
{
988
991
public:
989
992
  sys_var_timestamp(const char *name_arg)
1000
1003
};
1001
1004
 
1002
1005
 
1003
 
class sys_var_last_insert_id :public sys_var
 
1006
class DRIZZLED_API sys_var_last_insert_id :public sys_var
1004
1007
{
1005
1008
public:
1006
1009
  sys_var_last_insert_id(const char *name_arg)
1014
1017
};
1015
1018
 
1016
1019
 
1017
 
class sys_var_collation :public sys_var_session
 
1020
class DRIZZLED_API sys_var_collation :public sys_var_session
1018
1021
{
1019
1022
public:
1020
1023
  sys_var_collation(const char *name_arg)
1021
1024
    :sys_var_session(name_arg, NULL)
1022
1025
  { }
1023
 
  bool check(Session *session, set_var *var);
1024
1026
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1025
1027
  bool check_update_type(Item_result type)
1026
1028
  {
1030
1032
  virtual void set_default(Session *session, sql_var_t type)= 0;
1031
1033
};
1032
1034
 
1033
 
class sys_var_collation_sv :public sys_var_collation
 
1035
class DRIZZLED_API sys_var_collation_sv :public sys_var_collation
1034
1036
{
1035
1037
  const CHARSET_INFO *drizzle_system_variables::*offset;
1036
1038
  const CHARSET_INFO **global_default;
1051
1053
 
1052
1054
/* Variable that you can only read from */
1053
1055
 
1054
 
class sys_var_readonly: public sys_var
 
1056
class DRIZZLED_API sys_var_readonly: public sys_var
1055
1057
{
1056
1058
public:
1057
1059
  sql_var_t var_type;
1080
1082
};
1081
1083
 
1082
1084
 
1083
 
class sys_var_session_time_zone :public sys_var_session
 
1085
class DRIZZLED_API sys_var_session_time_zone :public sys_var_session
1084
1086
{
1085
1087
public:
1086
1088
  sys_var_session_time_zone(const char *name_arg)
1088
1090
  {
1089
1091
    
1090
1092
  }
1091
 
  bool check(Session *session, set_var *var);
1092
1093
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1093
1094
  bool check_update_type(Item_result type)
1094
1095
  {
1103
1104
};
1104
1105
 
1105
1106
 
1106
 
class sys_var_microseconds :public sys_var_session
 
1107
class DRIZZLED_API sys_var_microseconds :public sys_var_session
1107
1108
{
1108
1109
  uint64_t drizzle_system_variables::*offset;
1109
1110
public:
1121
1122
  }
1122
1123
};
1123
1124
 
1124
 
class sys_var_session_lc_time_names :public sys_var_session
 
1125
class DRIZZLED_API sys_var_session_lc_time_names :public sys_var_session
1125
1126
{
1126
1127
public:
1127
1128
  sys_var_session_lc_time_names(const char *name_arg)
1129
1130
  {
1130
1131
    
1131
1132
  }
1132
 
  bool check(Session *session, set_var *var);
1133
1133
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1134
1134
  bool check_update_type(Item_result type)
1135
1135
  {
1159
1159
drizzle_show_var* enumerate_sys_vars(Session *session);
1160
1160
void add_sys_var_to_list(sys_var *var, struct option *long_options);
1161
1161
void add_sys_var_to_list(sys_var *var);
1162
 
sys_var *find_sys_var(const char *str, uint32_t length=0);
1163
 
bool not_all_support_one_shot(List<set_var_base> *var_list);
 
1162
sys_var *find_sys_var(const std::string &name);
1164
1163
extern sys_var_session_time_zone sys_time_zone;
1165
1164
extern sys_var_session_bit sys_autocommit;
1166
1165
const CHARSET_INFO *get_old_charset_by_name(const char *old_name);