← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sys_var.h

edit

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sys_var.h
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
{
39
38
class sys_var;
40
39
class Time_zone;
41
40
typedef struct my_locale_st MY_LOCALE;
42
 
typedef struct st_typelib TYPELIB;
 
41
 
 
42
extern TYPELIB bool_typelib;
43
43
 
44
44
typedef int (*sys_check_func)(Session *,  set_var *);
45
45
typedef bool (*sys_update_func)(Session *, set_var *);
56
56
extern const char *in_left_expr_name;
57
57
extern const char *in_additional_cond;
58
58
extern const char *in_having_cond;
 
59
extern char glob_hostname[FN_REFLEN];
59
60
extern boost::filesystem::path basedir;
60
61
extern boost::filesystem::path pid_file;
61
62
extern boost::filesystem::path secure_file_priv;
 
63
extern char system_time_zone[30];
62
64
extern char *opt_tc_log_file;
63
65
extern uint64_t session_startup_options;
64
66
extern uint32_t global_thread_id;
71
73
extern uint32_t volatile thread_running;
72
74
extern uint32_t volatile global_read_lock;
73
75
extern bool opt_readonly;
 
76
extern char *default_tz_name;
74
77
extern const char *opt_scheduler;
75
 
extern size_t transaction_message_threshold;
76
78
 
77
79
uint64_t fix_unsigned(Session *, uint64_t, const struct option *);
78
80
 
79
 
const std::string &getServerHostname();
80
81
int sys_var_init();
81
82
 
82
83
/**
83
84
 * A class which represents a variable, either global or 
84
85
 * session-local.
85
86
 */
86
 
class DRIZZLED_API sys_var
 
87
class sys_var
87
88
{
88
89
protected:
89
90
  std::string name; /**< The name of the variable */
187
188
 * A base class for all variables that require its access to
188
189
 * be guarded with a mutex.
189
190
 */
190
 
class DRIZZLED_API sys_var_global: public sys_var
 
191
class sys_var_global: public sys_var
191
192
{
192
193
protected:
193
194
  pthread_mutex_t *guard;
201
202
  {}
202
203
};
203
204
 
204
 
class DRIZZLED_API sys_var_uint32_t_ptr :public sys_var
 
205
class sys_var_uint32_t_ptr :public sys_var
205
206
{
206
207
  uint32_t *value;
207
208
public:
222
223
  { return (unsigned char*) value; }
223
224
};
224
225
 
225
 
class DRIZZLED_API sys_var_uint32_t_ptr_readonly :
 
226
class sys_var_uint32_t_ptr_readonly :
226
227
  public sys_var_uint32_t_ptr
227
228
{
228
229
public:
244
245
};
245
246
 
246
247
 
247
 
class DRIZZLED_API sys_var_uint64_t_ptr :public sys_var
 
248
class sys_var_uint64_t_ptr :public sys_var
248
249
{
249
250
  uint64_t *value;
250
251
  const uint64_t default_value;
297
298
  { return (unsigned char*) value; }
298
299
};
299
300
 
300
 
class DRIZZLED_API sys_var_size_t_ptr :public sys_var
 
301
class sys_var_size_t_ptr :public sys_var
301
302
{
302
303
  size_t *value;
303
304
public:
315
316
  { return (unsigned char*) value; }
316
317
};
317
318
 
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
 
319
class sys_var_bool_ptr :public sys_var
329
320
{
330
321
  bool default_value;
331
322
public:
334
325
                   sys_after_update_func func= NULL) :
335
326
    sys_var(name_arg, func), default_value(*value_arg), value(value_arg)
336
327
  { }
337
 
  bool check(Session *session, set_var *var);
 
328
  bool check(Session *session, set_var *var)
 
329
  {
 
330
    return check_enum(session, var, &bool_typelib);
 
331
  }
338
332
  virtual bool check_default(sql_var_t)
339
333
  {
340
334
    return false;
348
342
  { return 0; }
349
343
};
350
344
 
351
 
class DRIZZLED_API sys_var_bool_ptr_readonly :public sys_var_bool_ptr
 
345
class sys_var_bool_ptr_readonly :public sys_var_bool_ptr
352
346
{
353
347
public:
354
348
  sys_var_bool_ptr_readonly(const char *name_arg,
359
353
};
360
354
 
361
355
 
362
 
class DRIZZLED_API sys_var_str :public sys_var
 
356
class sys_var_str :public sys_var
363
357
{
364
358
public:
365
359
  char *value;                                  // Pointer to allocated string
397
391
};
398
392
 
399
393
 
400
 
class DRIZZLED_API sys_var_fs_path :
 
394
class sys_var_fs_path :
401
395
  public sys_var
402
396
{
403
397
  const boost::filesystem::path &value;
555
549
  }
556
550
};
557
551
 
558
 
class DRIZZLED_API sys_var_std_string :
 
552
class sys_var_std_string :
559
553
  public sys_var
560
554
{
561
555
  std::string &value;
612
606
  bool is_readonly() const { return false; }
613
607
};
614
608
 
615
 
class DRIZZLED_API sys_var_const_string :
 
609
class sys_var_const_string :
616
610
  public sys_var
617
611
{
618
612
  const std::string &value;
647
641
  bool is_readonly() const { return true; }
648
642
};
649
643
 
650
 
class DRIZZLED_API sys_var_const_string_val :
 
644
class sys_var_const_string_val :
651
645
  public sys_var
652
646
{
653
647
  const std::string value;
682
676
  bool is_readonly() const { return true; }
683
677
};
684
678
 
685
 
class DRIZZLED_API sys_var_const_str :public sys_var
 
679
class sys_var_const_str :public sys_var
686
680
{
687
681
  char *value;                                  // Pointer to const value
688
682
public:
717
711
};
718
712
 
719
713
 
720
 
class DRIZZLED_API sys_var_const_str_ptr :public sys_var
 
714
class sys_var_const_str_ptr :public sys_var
721
715
{
722
716
  char **value;                                 // Pointer to const value
723
717
public:
747
741
};
748
742
 
749
743
 
750
 
class DRIZZLED_API sys_var_session :public sys_var
 
744
class sys_var_session :public sys_var
751
745
{
752
746
public:
753
747
  sys_var_session(const char *name_arg,
762
756
  }
763
757
};
764
758
 
765
 
class DRIZZLED_API sys_var_session_uint32_t :public sys_var_session
 
759
class sys_var_session_uint32_t :public sys_var_session
766
760
{
767
761
  sys_check_func check_func;
768
762
public:
783
777
};
784
778
 
785
779
 
786
 
class DRIZZLED_API sys_var_session_ha_rows :public sys_var_session
 
780
class sys_var_session_ha_rows :public sys_var_session
787
781
{
788
782
public:
789
783
  ha_rows drizzle_system_variables::*offset;
804
798
};
805
799
 
806
800
 
807
 
class DRIZZLED_API sys_var_session_uint64_t :public sys_var_session
 
801
class sys_var_session_uint64_t :public sys_var_session
808
802
{
809
803
  sys_check_func check_func;
810
804
public:
845
839
  }
846
840
};
847
841
 
848
 
class DRIZZLED_API sys_var_session_size_t :public sys_var_session
 
842
class sys_var_session_size_t :public sys_var_session
849
843
{
850
844
  sys_check_func check_func;
851
845
public:
886
880
};
887
881
 
888
882
 
889
 
class DRIZZLED_API sys_var_session_bool :public sys_var_session
 
883
class sys_var_session_bool :public sys_var_session
890
884
{
891
885
public:
892
886
  bool drizzle_system_variables::*offset;
902
896
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
903
897
  unsigned char *value_ptr(Session *session, sql_var_t type,
904
898
                           const LEX_STRING *base);
905
 
  bool check(Session *session, set_var *var);
 
899
  bool check(Session *session, set_var *var)
 
900
  {
 
901
    return check_enum(session, var, &bool_typelib);
 
902
  }
906
903
  bool check_update_type(Item_result)
907
904
  { return 0; }
908
905
};
909
906
 
910
907
 
911
 
class DRIZZLED_API sys_var_session_enum :public sys_var_session
 
908
class sys_var_session_enum :public sys_var_session
912
909
{
913
910
protected:
914
911
  uint32_t drizzle_system_variables::*offset;
939
936
};
940
937
 
941
938
 
942
 
class DRIZZLED_API sys_var_session_storage_engine :public sys_var_session
 
939
class sys_var_session_storage_engine :public sys_var_session
943
940
{
944
941
protected:
945
942
  plugin::StorageEngine *drizzle_system_variables::*offset;
959
956
                           const LEX_STRING *base);
960
957
};
961
958
 
962
 
class DRIZZLED_API sys_var_session_bit :public sys_var_session
 
959
class sys_var_session_bit :public sys_var_session
963
960
{
964
961
  sys_check_func check_func;
965
962
  sys_update_func update_func;
984
981
 
985
982
/* some variables that require special handling */
986
983
 
987
 
class DRIZZLED_API sys_var_timestamp :public sys_var
 
984
class sys_var_timestamp :public sys_var
988
985
{
989
986
public:
990
987
  sys_var_timestamp(const char *name_arg)
1001
998
};
1002
999
 
1003
1000
 
1004
 
class DRIZZLED_API sys_var_last_insert_id :public sys_var
 
1001
class sys_var_last_insert_id :public sys_var
1005
1002
{
1006
1003
public:
1007
1004
  sys_var_last_insert_id(const char *name_arg)
1015
1012
};
1016
1013
 
1017
1014
 
1018
 
class DRIZZLED_API sys_var_collation :public sys_var_session
 
1015
class sys_var_collation :public sys_var_session
1019
1016
{
1020
1017
public:
1021
1018
  sys_var_collation(const char *name_arg)
1030
1027
  virtual void set_default(Session *session, sql_var_t type)= 0;
1031
1028
};
1032
1029
 
1033
 
class DRIZZLED_API sys_var_collation_sv :public sys_var_collation
 
1030
class sys_var_collation_sv :public sys_var_collation
1034
1031
{
1035
1032
  const CHARSET_INFO *drizzle_system_variables::*offset;
1036
1033
  const CHARSET_INFO **global_default;
1051
1048
 
1052
1049
/* Variable that you can only read from */
1053
1050
 
1054
 
class DRIZZLED_API sys_var_readonly: public sys_var
 
1051
class sys_var_readonly: public sys_var
1055
1052
{
1056
1053
public:
1057
1054
  sql_var_t var_type;
1079
1076
  bool is_readonly(void) const { return 1; }
1080
1077
};
1081
1078
 
1082
 
class DRIZZLED_API sys_var_microseconds :public sys_var_session
 
1079
 
 
1080
class sys_var_session_time_zone :public sys_var_session
 
1081
{
 
1082
public:
 
1083
  sys_var_session_time_zone(const char *name_arg)
 
1084
    :sys_var_session(name_arg, NULL)
 
1085
  {
 
1086
    
 
1087
  }
 
1088
  SHOW_TYPE show_type() { return SHOW_CHAR; }
 
1089
  bool check_update_type(Item_result type)
 
1090
  {
 
1091
    return type != STRING_RESULT;               /* Only accept strings */
 
1092
  }
 
1093
  bool check_default(sql_var_t)
 
1094
  { return 0; }
 
1095
  bool update(Session *session, set_var *var);
 
1096
  unsigned char *value_ptr(Session *session, sql_var_t type,
 
1097
                           const LEX_STRING *base);
 
1098
  virtual void set_default(Session *session, sql_var_t type);
 
1099
};
 
1100
 
 
1101
 
 
1102
class sys_var_microseconds :public sys_var_session
1083
1103
{
1084
1104
  uint64_t drizzle_system_variables::*offset;
1085
1105
public:
1097
1117
  }
1098
1118
};
1099
1119
 
1100
 
class DRIZZLED_API sys_var_session_lc_time_names :public sys_var_session
 
1120
class sys_var_session_lc_time_names :public sys_var_session
1101
1121
{
1102
1122
public:
1103
1123
  sys_var_session_lc_time_names(const char *name_arg)
1135
1155
void add_sys_var_to_list(sys_var *var, struct option *long_options);
1136
1156
void add_sys_var_to_list(sys_var *var);
1137
1157
sys_var *find_sys_var(const std::string &name);
 
1158
extern sys_var_session_time_zone sys_time_zone;
1138
1159
extern sys_var_session_bit sys_autocommit;
1139
1160
const CHARSET_INFO *get_old_charset_by_name(const char *old_name);
1140
1161