← 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: 2010-12-17 00:08:06 UTC
  • mfrom: (2002.1.4 clean)
  • Revision ID: brian@tangent.org-20101217000806-fa6kmggjnhsl4q85
Rollup for field encapsulation, monty fix for bzrignore, and Andrew bug
fixes.

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