← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sys_var.h

  • Committer: Brian Aker
  • Date: 2011-02-21 17:37:00 UTC
  • mto: (2192.1.1 drizzle-staging)
  • mto: This revision was merged to the branch mainline in revision 2193.
  • Revision ID: brian@tangent.org-20110221173700-6wdfbxm60zq9q9se
Merge in change from REPLICATION to REPLICATE as keyword.

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