← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sys_var.h

  • Committer: Olaf van der Spek
  • Date: 2011-03-29 12:04:36 UTC
  • mto: (2257.1.1 build) (2276.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 2258.
  • Revision ID: olafvdspek@gmail.com-20110329120436-vozkuer8vqgh027p
Always call assert()

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sys_var.h
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#ifndef DRIZZLED_SYS_VAR_H
21
 
#define DRIZZLED_SYS_VAR_H
 
20
#pragma once
22
21
 
23
22
#include <string>
24
23
#include <boost/filesystem.hpp>
25
24
 
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"
34
 
 
35
 
namespace drizzled
36
 
{
37
 
 
38
 
class sys_var;
39
 
class Time_zone;
40
 
typedef struct my_locale_st MY_LOCALE;
41
 
 
42
 
extern TYPELIB bool_typelib;
 
25
#include <drizzled/common_fwd.h>
 
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
#include <drizzled/visibility.h>
 
34
 
 
35
namespace drizzled {
43
36
 
44
37
typedef int (*sys_check_func)(Session *,  set_var *);
45
38
typedef bool (*sys_update_func)(Session *, set_var *);
56
49
extern const char *in_left_expr_name;
57
50
extern const char *in_additional_cond;
58
51
extern const char *in_having_cond;
59
 
extern char glob_hostname[FN_REFLEN];
60
52
extern boost::filesystem::path basedir;
61
53
extern boost::filesystem::path pid_file;
62
54
extern boost::filesystem::path secure_file_priv;
63
 
extern char system_time_zone[30];
64
55
extern char *opt_tc_log_file;
65
56
extern uint64_t session_startup_options;
66
57
extern uint32_t global_thread_id;
67
58
extern uint64_t table_cache_size;
68
 
extern uint64_t max_connect_errors;
69
59
extern back_log_constraints back_log;
70
60
extern uint32_t ha_open_options;
71
61
extern char *drizzled_bind_host;
74
64
extern uint32_t volatile thread_running;
75
65
extern uint32_t volatile global_read_lock;
76
66
extern bool opt_readonly;
77
 
extern char *default_tz_name;
78
67
extern const char *opt_scheduler;
 
68
extern size_t transaction_message_threshold;
79
69
 
80
70
uint64_t fix_unsigned(Session *, uint64_t, const struct option *);
81
71
 
 
72
DRIZZLED_API const std::string &getServerHostname();
82
73
int sys_var_init();
83
74
 
84
75
/**
85
76
 * A class which represents a variable, either global or 
86
77
 * session-local.
87
78
 */
88
 
class sys_var
 
79
class DRIZZLED_API sys_var
89
80
{
90
81
protected:
91
82
  std::string name; /**< The name of the variable */
189
180
 * A base class for all variables that require its access to
190
181
 * be guarded with a mutex.
191
182
 */
192
 
class sys_var_global: public sys_var
 
183
class DRIZZLED_API sys_var_global: public sys_var
193
184
{
194
185
protected:
195
186
  pthread_mutex_t *guard;
203
194
  {}
204
195
};
205
196
 
206
 
class sys_var_uint32_t_ptr :public sys_var
 
197
class DRIZZLED_API sys_var_uint32_t_ptr :public sys_var
207
198
{
208
199
  uint32_t *value;
209
200
public:
224
215
  { return (unsigned char*) value; }
225
216
};
226
217
 
227
 
class sys_var_uint32_t_ptr_readonly :
 
218
class DRIZZLED_API sys_var_uint32_t_ptr_readonly :
228
219
  public sys_var_uint32_t_ptr
229
220
{
230
221
public:
246
237
};
247
238
 
248
239
 
249
 
class sys_var_uint64_t_ptr :public sys_var
 
240
class DRIZZLED_API sys_var_uint64_t_ptr :public sys_var
250
241
{
251
242
  uint64_t *value;
252
243
  const uint64_t default_value;
299
290
  { return (unsigned char*) value; }
300
291
};
301
292
 
302
 
class sys_var_size_t_ptr :public sys_var
 
293
class DRIZZLED_API sys_var_size_t_ptr :public sys_var
303
294
{
304
295
  size_t *value;
305
296
public:
317
308
  { return (unsigned char*) value; }
318
309
};
319
310
 
320
 
class sys_var_bool_ptr :public sys_var
 
311
class DRIZZLED_API sys_var_size_t_ptr_readonly :public sys_var_size_t_ptr
 
312
{
 
313
public:
 
314
  sys_var_size_t_ptr_readonly(const char *name_arg,
 
315
                            size_t *value_arg)
 
316
    :sys_var_size_t_ptr(name_arg, value_arg)
 
317
  {}
 
318
  bool is_readonly() const { return 1; }
 
319
};
 
320
 
 
321
class DRIZZLED_API sys_var_bool_ptr :public sys_var
321
322
{
322
323
  bool default_value;
323
324
public:
326
327
                   sys_after_update_func func= NULL) :
327
328
    sys_var(name_arg, func), default_value(*value_arg), value(value_arg)
328
329
  { }
329
 
  bool check(Session *session, set_var *var)
330
 
  {
331
 
    return check_enum(session, var, &bool_typelib);
332
 
  }
 
330
  bool check(Session *session, set_var *var);
333
331
  virtual bool check_default(sql_var_t)
334
332
  {
335
333
    return false;
343
341
  { return 0; }
344
342
};
345
343
 
346
 
class sys_var_bool_ptr_readonly :public sys_var_bool_ptr
 
344
class DRIZZLED_API sys_var_bool_ptr_readonly :public sys_var_bool_ptr
347
345
{
348
346
public:
349
347
  sys_var_bool_ptr_readonly(const char *name_arg,
354
352
};
355
353
 
356
354
 
357
 
class sys_var_str :public sys_var
 
355
class DRIZZLED_API sys_var_str :public sys_var
358
356
{
359
357
public:
360
358
  char *value;                                  // Pointer to allocated string
392
390
};
393
391
 
394
392
 
395
 
class sys_var_fs_path :
 
393
class DRIZZLED_API sys_var_fs_path :
396
394
  public sys_var
397
395
{
398
396
  const boost::filesystem::path &value;
468
466
 
469
467
  bool update(Session *, set_var *var)
470
468
  {
471
 
    value= var->save_result.uint32_t_value;
 
469
    value= uint32_t(var->getInteger());
472
470
    return false;
473
471
  }
474
472
 
516
514
template<>
517
515
inline bool sys_var_constrained_value<uint64_t>::update(Session *, set_var *var)
518
516
{
519
 
  value= var->save_result.uint64_t_value;
 
517
  value= var->getInteger();
520
518
  return false;
521
519
}
522
520
 
523
521
template<>
524
522
inline bool sys_var_constrained_value<uint32_t>::update(Session *, set_var *var)
525
523
{
526
 
  value= var->save_result.uint32_t_value;
 
524
  value= uint32_t(var->getInteger());
527
525
  return false;
528
526
}
529
527
 
550
548
  }
551
549
};
552
550
 
553
 
class sys_var_std_string :
 
551
class DRIZZLED_API sys_var_std_string :
554
552
  public sys_var
555
553
{
556
554
  std::string &value;
607
605
  bool is_readonly() const { return false; }
608
606
};
609
607
 
610
 
class sys_var_const_string :
 
608
class DRIZZLED_API sys_var_const_string :
611
609
  public sys_var
612
610
{
613
611
  const std::string &value;
642
640
  bool is_readonly() const { return true; }
643
641
};
644
642
 
645
 
class sys_var_const_string_val :
 
643
class DRIZZLED_API sys_var_const_string_val :
646
644
  public sys_var
647
645
{
648
646
  const std::string value;
677
675
  bool is_readonly() const { return true; }
678
676
};
679
677
 
680
 
class sys_var_const_str :public sys_var
 
678
class DRIZZLED_API sys_var_const_str :public sys_var
681
679
{
682
680
  char *value;                                  // Pointer to const value
683
681
public:
712
710
};
713
711
 
714
712
 
715
 
class sys_var_const_str_ptr :public sys_var
 
713
class DRIZZLED_API sys_var_const_str_ptr :public sys_var
716
714
{
717
715
  char **value;                                 // Pointer to const value
718
716
public:
742
740
};
743
741
 
744
742
 
745
 
class sys_var_session :public sys_var
 
743
class DRIZZLED_API sys_var_session :public sys_var
746
744
{
747
745
public:
748
746
  sys_var_session(const char *name_arg,
757
755
  }
758
756
};
759
757
 
760
 
class sys_var_session_uint32_t :public sys_var_session
 
758
class DRIZZLED_API sys_var_session_uint32_t :public sys_var_session
761
759
{
762
760
  sys_check_func check_func;
763
761
public:
778
776
};
779
777
 
780
778
 
781
 
class sys_var_session_ha_rows :public sys_var_session
 
779
class DRIZZLED_API sys_var_session_ha_rows :public sys_var_session
782
780
{
783
781
public:
784
782
  ha_rows drizzle_system_variables::*offset;
799
797
};
800
798
 
801
799
 
802
 
class sys_var_session_uint64_t :public sys_var_session
 
800
class DRIZZLED_API sys_var_session_uint64_t :public sys_var_session
803
801
{
804
802
  sys_check_func check_func;
805
803
public:
840
838
  }
841
839
};
842
840
 
843
 
class sys_var_session_size_t :public sys_var_session
 
841
class DRIZZLED_API sys_var_session_size_t :public sys_var_session
844
842
{
845
843
  sys_check_func check_func;
846
844
public:
881
879
};
882
880
 
883
881
 
884
 
class sys_var_session_bool :public sys_var_session
 
882
class DRIZZLED_API sys_var_session_bool :public sys_var_session
885
883
{
886
884
public:
887
885
  bool drizzle_system_variables::*offset;
897
895
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
898
896
  unsigned char *value_ptr(Session *session, sql_var_t type,
899
897
                           const LEX_STRING *base);
900
 
  bool check(Session *session, set_var *var)
901
 
  {
902
 
    return check_enum(session, var, &bool_typelib);
903
 
  }
 
898
  bool check(Session *session, set_var *var);
904
899
  bool check_update_type(Item_result)
905
900
  { return 0; }
906
901
};
907
902
 
908
903
 
909
 
class sys_var_session_enum :public sys_var_session
 
904
class DRIZZLED_API sys_var_session_enum :public sys_var_session
910
905
{
911
906
protected:
912
907
  uint32_t drizzle_system_variables::*offset;
937
932
};
938
933
 
939
934
 
940
 
class sys_var_session_storage_engine :public sys_var_session
 
935
class DRIZZLED_API sys_var_session_storage_engine :public sys_var_session
941
936
{
942
937
protected:
943
938
  plugin::StorageEngine *drizzle_system_variables::*offset;
946
941
                                 plugin::StorageEngine *drizzle_system_variables::*offset_arg)
947
942
    :sys_var_session(name_arg), offset(offset_arg)
948
943
  {  }
949
 
  bool check(Session *session, set_var *var);
950
944
  SHOW_TYPE show_type() { return SHOW_CHAR; }
951
945
  bool check_update_type(Item_result type)
952
946
  {
958
952
                           const LEX_STRING *base);
959
953
};
960
954
 
961
 
class sys_var_session_bit :public sys_var_session
 
955
class DRIZZLED_API sys_var_session_bit :public sys_var_session
962
956
{
963
957
  sys_check_func check_func;
964
958
  sys_update_func update_func;
983
977
 
984
978
/* some variables that require special handling */
985
979
 
986
 
class sys_var_timestamp :public sys_var
 
980
class DRIZZLED_API sys_var_timestamp :public sys_var
987
981
{
988
982
public:
989
983
  sys_var_timestamp(const char *name_arg)
1000
994
};
1001
995
 
1002
996
 
1003
 
class sys_var_last_insert_id :public sys_var
 
997
class DRIZZLED_API sys_var_last_insert_id :public sys_var
1004
998
{
1005
999
public:
1006
1000
  sys_var_last_insert_id(const char *name_arg)
1014
1008
};
1015
1009
 
1016
1010
 
1017
 
class sys_var_collation :public sys_var_session
 
1011
class DRIZZLED_API sys_var_collation :public sys_var_session
1018
1012
{
1019
1013
public:
1020
1014
  sys_var_collation(const char *name_arg)
1021
1015
    :sys_var_session(name_arg, NULL)
1022
1016
  { }
1023
 
  bool check(Session *session, set_var *var);
1024
1017
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1025
1018
  bool check_update_type(Item_result type)
1026
1019
  {
1030
1023
  virtual void set_default(Session *session, sql_var_t type)= 0;
1031
1024
};
1032
1025
 
1033
 
class sys_var_collation_sv :public sys_var_collation
 
1026
class DRIZZLED_API sys_var_collation_sv :public sys_var_collation
1034
1027
{
1035
 
  const CHARSET_INFO *drizzle_system_variables::*offset;
1036
 
  const CHARSET_INFO **global_default;
 
1028
  const charset_info_st *drizzle_system_variables::*offset;
 
1029
  const charset_info_st **global_default;
1037
1030
public:
1038
1031
  sys_var_collation_sv(const char *name_arg,
1039
 
                       const CHARSET_INFO *drizzle_system_variables::*offset_arg,
1040
 
                       const CHARSET_INFO **global_default_arg)
 
1032
                       const charset_info_st *drizzle_system_variables::*offset_arg,
 
1033
                       const charset_info_st **global_default_arg)
1041
1034
    :sys_var_collation(name_arg),
1042
1035
    offset(offset_arg), global_default(global_default_arg)
1043
1036
  {
1051
1044
 
1052
1045
/* Variable that you can only read from */
1053
1046
 
1054
 
class sys_var_readonly: public sys_var
 
1047
class DRIZZLED_API sys_var_readonly: public sys_var
1055
1048
{
1056
1049
public:
1057
1050
  sql_var_t var_type;
1079
1072
  bool is_readonly(void) const { return 1; }
1080
1073
};
1081
1074
 
1082
 
 
1083
 
class sys_var_session_time_zone :public sys_var_session
1084
 
{
1085
 
public:
1086
 
  sys_var_session_time_zone(const char *name_arg)
1087
 
    :sys_var_session(name_arg, NULL)
1088
 
  {
1089
 
    
1090
 
  }
1091
 
  bool check(Session *session, set_var *var);
1092
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1093
 
  bool check_update_type(Item_result type)
1094
 
  {
1095
 
    return type != STRING_RESULT;               /* Only accept strings */
1096
 
  }
1097
 
  bool check_default(sql_var_t)
1098
 
  { return 0; }
1099
 
  bool update(Session *session, set_var *var);
1100
 
  unsigned char *value_ptr(Session *session, sql_var_t type,
1101
 
                           const LEX_STRING *base);
1102
 
  virtual void set_default(Session *session, sql_var_t type);
1103
 
};
1104
 
 
1105
 
 
1106
 
class sys_var_microseconds :public sys_var_session
 
1075
class DRIZZLED_API sys_var_microseconds :public sys_var_session
1107
1076
{
1108
1077
  uint64_t drizzle_system_variables::*offset;
1109
1078
public:
1121
1090
  }
1122
1091
};
1123
1092
 
1124
 
class sys_var_session_lc_time_names :public sys_var_session
 
1093
class DRIZZLED_API sys_var_session_lc_time_names :public sys_var_session
1125
1094
{
1126
1095
public:
1127
1096
  sys_var_session_lc_time_names(const char *name_arg)
1129
1098
  {
1130
1099
    
1131
1100
  }
1132
 
  bool check(Session *session, set_var *var);
1133
1101
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1134
1102
  bool check_update_type(Item_result type)
1135
1103
  {
1159
1127
drizzle_show_var* enumerate_sys_vars(Session *session);
1160
1128
void add_sys_var_to_list(sys_var *var, struct option *long_options);
1161
1129
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);
1164
 
extern sys_var_session_time_zone sys_time_zone;
 
1130
sys_var *find_sys_var(const std::string &name);
1165
1131
extern sys_var_session_bit sys_autocommit;
1166
 
const CHARSET_INFO *get_old_charset_by_name(const char *old_name);
 
1132
const charset_info_st *get_old_charset_by_name(const char *old_name);
1167
1133
 
1168
1134
extern sys_var_str sys_var_general_log_path, sys_var_slow_log_path;
1169
1135
 
1170
1136
} /* namespace drizzled */
1171
1137
 
1172
 
#endif /* DRIZZLED_SYS_VAR_H */