← 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-24 00:16:14 UTC
  • mto: This revision was merged to the branch mainline in revision 2251.
  • Revision ID: olafvdspek@gmail.com-20110324001614-wvmgc6eg52oq2321
Remove const_reference and reference from Session

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
 
 
 
25
#include <drizzled/constrained_value.h>
 
26
#include <drizzled/set_var.h>
 
27
#include <drizzled/show_type.h>
 
28
#include <drizzled/item_result.h>
 
29
#include <drizzled/base.h>
 
30
#include <drizzled/global_charset_info.h>
 
31
#include <drizzled/lex_string.h>
 
32
#include <drizzled/visibility.h>
 
33
 
 
34
namespace drizzled {
 
35
 
 
36
class Session;
38
37
class sys_var;
39
38
class Time_zone;
40
39
typedef struct my_locale_st MY_LOCALE;
41
 
 
42
 
extern TYPELIB bool_typelib;
 
40
typedef struct st_typelib TYPELIB;
43
41
 
44
42
typedef int (*sys_check_func)(Session *,  set_var *);
45
43
typedef bool (*sys_update_func)(Session *, set_var *);
56
54
extern const char *in_left_expr_name;
57
55
extern const char *in_additional_cond;
58
56
extern const char *in_having_cond;
59
 
extern char glob_hostname[FN_REFLEN];
60
57
extern boost::filesystem::path basedir;
61
58
extern boost::filesystem::path pid_file;
62
59
extern boost::filesystem::path secure_file_priv;
63
 
extern char system_time_zone[30];
64
60
extern char *opt_tc_log_file;
65
61
extern uint64_t session_startup_options;
66
62
extern uint32_t global_thread_id;
67
63
extern uint64_t table_cache_size;
68
 
extern uint64_t max_connect_errors;
69
64
extern back_log_constraints back_log;
70
65
extern uint32_t ha_open_options;
71
66
extern char *drizzled_bind_host;
74
69
extern uint32_t volatile thread_running;
75
70
extern uint32_t volatile global_read_lock;
76
71
extern bool opt_readonly;
77
 
extern char *default_tz_name;
78
72
extern const char *opt_scheduler;
 
73
extern size_t transaction_message_threshold;
79
74
 
80
75
uint64_t fix_unsigned(Session *, uint64_t, const struct option *);
81
76
 
 
77
DRIZZLED_API const std::string &getServerHostname();
82
78
int sys_var_init();
83
79
 
84
80
/**
85
81
 * A class which represents a variable, either global or 
86
82
 * session-local.
87
83
 */
88
 
class sys_var
 
84
class DRIZZLED_API sys_var
89
85
{
90
86
protected:
91
87
  std::string name; /**< The name of the variable */
189
185
 * A base class for all variables that require its access to
190
186
 * be guarded with a mutex.
191
187
 */
192
 
class sys_var_global: public sys_var
 
188
class DRIZZLED_API sys_var_global: public sys_var
193
189
{
194
190
protected:
195
191
  pthread_mutex_t *guard;
203
199
  {}
204
200
};
205
201
 
206
 
class sys_var_uint32_t_ptr :public sys_var
 
202
class DRIZZLED_API sys_var_uint32_t_ptr :public sys_var
207
203
{
208
204
  uint32_t *value;
209
205
public:
224
220
  { return (unsigned char*) value; }
225
221
};
226
222
 
227
 
class sys_var_uint32_t_ptr_readonly :
 
223
class DRIZZLED_API sys_var_uint32_t_ptr_readonly :
228
224
  public sys_var_uint32_t_ptr
229
225
{
230
226
public:
246
242
};
247
243
 
248
244
 
249
 
class sys_var_uint64_t_ptr :public sys_var
 
245
class DRIZZLED_API sys_var_uint64_t_ptr :public sys_var
250
246
{
251
247
  uint64_t *value;
252
248
  const uint64_t default_value;
299
295
  { return (unsigned char*) value; }
300
296
};
301
297
 
302
 
class sys_var_size_t_ptr :public sys_var
 
298
class DRIZZLED_API sys_var_size_t_ptr :public sys_var
303
299
{
304
300
  size_t *value;
305
301
public:
317
313
  { return (unsigned char*) value; }
318
314
};
319
315
 
320
 
class sys_var_bool_ptr :public sys_var
 
316
class DRIZZLED_API sys_var_size_t_ptr_readonly :public sys_var_size_t_ptr
 
317
{
 
318
public:
 
319
  sys_var_size_t_ptr_readonly(const char *name_arg,
 
320
                            size_t *value_arg)
 
321
    :sys_var_size_t_ptr(name_arg, value_arg)
 
322
  {}
 
323
  bool is_readonly() const { return 1; }
 
324
};
 
325
 
 
326
class DRIZZLED_API sys_var_bool_ptr :public sys_var
321
327
{
322
328
  bool default_value;
323
329
public:
326
332
                   sys_after_update_func func= NULL) :
327
333
    sys_var(name_arg, func), default_value(*value_arg), value(value_arg)
328
334
  { }
329
 
  bool check(Session *session, set_var *var)
330
 
  {
331
 
    return check_enum(session, var, &bool_typelib);
332
 
  }
 
335
  bool check(Session *session, set_var *var);
333
336
  virtual bool check_default(sql_var_t)
334
337
  {
335
338
    return false;
343
346
  { return 0; }
344
347
};
345
348
 
346
 
class sys_var_bool_ptr_readonly :public sys_var_bool_ptr
 
349
class DRIZZLED_API sys_var_bool_ptr_readonly :public sys_var_bool_ptr
347
350
{
348
351
public:
349
352
  sys_var_bool_ptr_readonly(const char *name_arg,
354
357
};
355
358
 
356
359
 
357
 
class sys_var_str :public sys_var
 
360
class DRIZZLED_API sys_var_str :public sys_var
358
361
{
359
362
public:
360
363
  char *value;                                  // Pointer to allocated string
392
395
};
393
396
 
394
397
 
395
 
class sys_var_fs_path :
 
398
class DRIZZLED_API sys_var_fs_path :
396
399
  public sys_var
397
400
{
398
401
  const boost::filesystem::path &value;
468
471
 
469
472
  bool update(Session *, set_var *var)
470
473
  {
471
 
    value= var->save_result.uint32_t_value;
 
474
    value= uint32_t(var->getInteger());
472
475
    return false;
473
476
  }
474
477
 
516
519
template<>
517
520
inline bool sys_var_constrained_value<uint64_t>::update(Session *, set_var *var)
518
521
{
519
 
  value= var->save_result.uint64_t_value;
 
522
  value= var->getInteger();
520
523
  return false;
521
524
}
522
525
 
523
526
template<>
524
527
inline bool sys_var_constrained_value<uint32_t>::update(Session *, set_var *var)
525
528
{
526
 
  value= var->save_result.uint32_t_value;
 
529
  value= uint32_t(var->getInteger());
527
530
  return false;
528
531
}
529
532
 
550
553
  }
551
554
};
552
555
 
553
 
class sys_var_std_string :
 
556
class DRIZZLED_API sys_var_std_string :
554
557
  public sys_var
555
558
{
556
559
  std::string &value;
607
610
  bool is_readonly() const { return false; }
608
611
};
609
612
 
610
 
class sys_var_const_string :
 
613
class DRIZZLED_API sys_var_const_string :
611
614
  public sys_var
612
615
{
613
616
  const std::string &value;
642
645
  bool is_readonly() const { return true; }
643
646
};
644
647
 
645
 
class sys_var_const_string_val :
 
648
class DRIZZLED_API sys_var_const_string_val :
646
649
  public sys_var
647
650
{
648
651
  const std::string value;
677
680
  bool is_readonly() const { return true; }
678
681
};
679
682
 
680
 
class sys_var_const_str :public sys_var
 
683
class DRIZZLED_API sys_var_const_str :public sys_var
681
684
{
682
685
  char *value;                                  // Pointer to const value
683
686
public:
712
715
};
713
716
 
714
717
 
715
 
class sys_var_const_str_ptr :public sys_var
 
718
class DRIZZLED_API sys_var_const_str_ptr :public sys_var
716
719
{
717
720
  char **value;                                 // Pointer to const value
718
721
public:
742
745
};
743
746
 
744
747
 
745
 
class sys_var_session :public sys_var
 
748
class DRIZZLED_API sys_var_session :public sys_var
746
749
{
747
750
public:
748
751
  sys_var_session(const char *name_arg,
757
760
  }
758
761
};
759
762
 
760
 
class sys_var_session_uint32_t :public sys_var_session
 
763
class DRIZZLED_API sys_var_session_uint32_t :public sys_var_session
761
764
{
762
765
  sys_check_func check_func;
763
766
public:
778
781
};
779
782
 
780
783
 
781
 
class sys_var_session_ha_rows :public sys_var_session
 
784
class DRIZZLED_API sys_var_session_ha_rows :public sys_var_session
782
785
{
783
786
public:
784
787
  ha_rows drizzle_system_variables::*offset;
799
802
};
800
803
 
801
804
 
802
 
class sys_var_session_uint64_t :public sys_var_session
 
805
class DRIZZLED_API sys_var_session_uint64_t :public sys_var_session
803
806
{
804
807
  sys_check_func check_func;
805
808
public:
840
843
  }
841
844
};
842
845
 
843
 
class sys_var_session_size_t :public sys_var_session
 
846
class DRIZZLED_API sys_var_session_size_t :public sys_var_session
844
847
{
845
848
  sys_check_func check_func;
846
849
public:
881
884
};
882
885
 
883
886
 
884
 
class sys_var_session_bool :public sys_var_session
 
887
class DRIZZLED_API sys_var_session_bool :public sys_var_session
885
888
{
886
889
public:
887
890
  bool drizzle_system_variables::*offset;
897
900
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
898
901
  unsigned char *value_ptr(Session *session, sql_var_t type,
899
902
                           const LEX_STRING *base);
900
 
  bool check(Session *session, set_var *var)
901
 
  {
902
 
    return check_enum(session, var, &bool_typelib);
903
 
  }
 
903
  bool check(Session *session, set_var *var);
904
904
  bool check_update_type(Item_result)
905
905
  { return 0; }
906
906
};
907
907
 
908
908
 
909
 
class sys_var_session_enum :public sys_var_session
 
909
class DRIZZLED_API sys_var_session_enum :public sys_var_session
910
910
{
911
911
protected:
912
912
  uint32_t drizzle_system_variables::*offset;
937
937
};
938
938
 
939
939
 
940
 
class sys_var_session_storage_engine :public sys_var_session
 
940
class DRIZZLED_API sys_var_session_storage_engine :public sys_var_session
941
941
{
942
942
protected:
943
943
  plugin::StorageEngine *drizzle_system_variables::*offset;
946
946
                                 plugin::StorageEngine *drizzle_system_variables::*offset_arg)
947
947
    :sys_var_session(name_arg), offset(offset_arg)
948
948
  {  }
949
 
  bool check(Session *session, set_var *var);
950
949
  SHOW_TYPE show_type() { return SHOW_CHAR; }
951
950
  bool check_update_type(Item_result type)
952
951
  {
958
957
                           const LEX_STRING *base);
959
958
};
960
959
 
961
 
class sys_var_session_bit :public sys_var_session
 
960
class DRIZZLED_API sys_var_session_bit :public sys_var_session
962
961
{
963
962
  sys_check_func check_func;
964
963
  sys_update_func update_func;
983
982
 
984
983
/* some variables that require special handling */
985
984
 
986
 
class sys_var_timestamp :public sys_var
 
985
class DRIZZLED_API sys_var_timestamp :public sys_var
987
986
{
988
987
public:
989
988
  sys_var_timestamp(const char *name_arg)
1000
999
};
1001
1000
 
1002
1001
 
1003
 
class sys_var_last_insert_id :public sys_var
 
1002
class DRIZZLED_API sys_var_last_insert_id :public sys_var
1004
1003
{
1005
1004
public:
1006
1005
  sys_var_last_insert_id(const char *name_arg)
1014
1013
};
1015
1014
 
1016
1015
 
1017
 
class sys_var_collation :public sys_var_session
 
1016
class DRIZZLED_API sys_var_collation :public sys_var_session
1018
1017
{
1019
1018
public:
1020
1019
  sys_var_collation(const char *name_arg)
1021
1020
    :sys_var_session(name_arg, NULL)
1022
1021
  { }
1023
 
  bool check(Session *session, set_var *var);
1024
1022
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1025
1023
  bool check_update_type(Item_result type)
1026
1024
  {
1030
1028
  virtual void set_default(Session *session, sql_var_t type)= 0;
1031
1029
};
1032
1030
 
1033
 
class sys_var_collation_sv :public sys_var_collation
 
1031
class DRIZZLED_API sys_var_collation_sv :public sys_var_collation
1034
1032
{
1035
1033
  const CHARSET_INFO *drizzle_system_variables::*offset;
1036
1034
  const CHARSET_INFO **global_default;
1051
1049
 
1052
1050
/* Variable that you can only read from */
1053
1051
 
1054
 
class sys_var_readonly: public sys_var
 
1052
class DRIZZLED_API sys_var_readonly: public sys_var
1055
1053
{
1056
1054
public:
1057
1055
  sql_var_t var_type;
1079
1077
  bool is_readonly(void) const { return 1; }
1080
1078
};
1081
1079
 
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
 
1080
class DRIZZLED_API sys_var_microseconds :public sys_var_session
1107
1081
{
1108
1082
  uint64_t drizzle_system_variables::*offset;
1109
1083
public:
1121
1095
  }
1122
1096
};
1123
1097
 
1124
 
class sys_var_session_lc_time_names :public sys_var_session
 
1098
class DRIZZLED_API sys_var_session_lc_time_names :public sys_var_session
1125
1099
{
1126
1100
public:
1127
1101
  sys_var_session_lc_time_names(const char *name_arg)
1129
1103
  {
1130
1104
    
1131
1105
  }
1132
 
  bool check(Session *session, set_var *var);
1133
1106
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1134
1107
  bool check_update_type(Item_result type)
1135
1108
  {
1159
1132
drizzle_show_var* enumerate_sys_vars(Session *session);
1160
1133
void add_sys_var_to_list(sys_var *var, struct option *long_options);
1161
1134
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;
 
1135
sys_var *find_sys_var(const std::string &name);
1165
1136
extern sys_var_session_bit sys_autocommit;
1166
1137
const CHARSET_INFO *get_old_charset_by_name(const char *old_name);
1167
1138
 
1169
1140
 
1170
1141
} /* namespace drizzled */
1171
1142
 
1172
 
#endif /* DRIZZLED_SYS_VAR_H */