← Back to branch summary

~patrick-crews/drizzle/dbqp_bug710942

« back to all changes in this revision

Viewing changes to drizzled/sys_var.h

  • Committer: Lee Bieber
  • Date: 2011-01-28 21:08:33 UTC
  • mfrom: (2119.4.3 try-visibility)
  • Revision ID: kalebral@gmail.com-20110128210833-nro17n81etdpcylm
Merge Monty - Enable -fvisibility=hidden

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sys_var.h
32
32
#include "drizzled/global_charset_info.h"
33
33
#include "drizzled/lex_string.h"
34
34
 
 
35
#include "drizzled/visibility.h"
 
36
 
35
37
namespace drizzled
36
38
{
37
39
 
39
41
class Time_zone;
40
42
typedef struct my_locale_st MY_LOCALE;
41
43
 
42
 
extern TYPELIB bool_typelib;
43
 
 
44
44
typedef int (*sys_check_func)(Session *,  set_var *);
45
45
typedef bool (*sys_update_func)(Session *, set_var *);
46
46
typedef void (*sys_after_update_func)(Session *, sql_var_t);
84
84
 * A class which represents a variable, either global or 
85
85
 * session-local.
86
86
 */
87
 
class sys_var
 
87
class DRIZZLED_API sys_var
88
88
{
89
89
protected:
90
90
  std::string name; /**< The name of the variable */
188
188
 * A base class for all variables that require its access to
189
189
 * be guarded with a mutex.
190
190
 */
191
 
class sys_var_global: public sys_var
 
191
class DRIZZLED_API sys_var_global: public sys_var
192
192
{
193
193
protected:
194
194
  pthread_mutex_t *guard;
202
202
  {}
203
203
};
204
204
 
205
 
class sys_var_uint32_t_ptr :public sys_var
 
205
class DRIZZLED_API sys_var_uint32_t_ptr :public sys_var
206
206
{
207
207
  uint32_t *value;
208
208
public:
223
223
  { return (unsigned char*) value; }
224
224
};
225
225
 
226
 
class sys_var_uint32_t_ptr_readonly :
 
226
class DRIZZLED_API sys_var_uint32_t_ptr_readonly :
227
227
  public sys_var_uint32_t_ptr
228
228
{
229
229
public:
245
245
};
246
246
 
247
247
 
248
 
class sys_var_uint64_t_ptr :public sys_var
 
248
class DRIZZLED_API sys_var_uint64_t_ptr :public sys_var
249
249
{
250
250
  uint64_t *value;
251
251
  const uint64_t default_value;
298
298
  { return (unsigned char*) value; }
299
299
};
300
300
 
301
 
class sys_var_size_t_ptr :public sys_var
 
301
class DRIZZLED_API sys_var_size_t_ptr :public sys_var
302
302
{
303
303
  size_t *value;
304
304
public:
316
316
  { return (unsigned char*) value; }
317
317
};
318
318
 
319
 
class sys_var_bool_ptr :public sys_var
 
319
class DRIZZLED_API sys_var_bool_ptr :public sys_var
320
320
{
321
321
  bool default_value;
322
322
public:
325
325
                   sys_after_update_func func= NULL) :
326
326
    sys_var(name_arg, func), default_value(*value_arg), value(value_arg)
327
327
  { }
328
 
  bool check(Session *session, set_var *var)
329
 
  {
330
 
    return check_enum(session, var, &bool_typelib);
331
 
  }
 
328
  bool check(Session *session, set_var *var);
332
329
  virtual bool check_default(sql_var_t)
333
330
  {
334
331
    return false;
342
339
  { return 0; }
343
340
};
344
341
 
345
 
class sys_var_bool_ptr_readonly :public sys_var_bool_ptr
 
342
class DRIZZLED_API sys_var_bool_ptr_readonly :public sys_var_bool_ptr
346
343
{
347
344
public:
348
345
  sys_var_bool_ptr_readonly(const char *name_arg,
353
350
};
354
351
 
355
352
 
356
 
class sys_var_str :public sys_var
 
353
class DRIZZLED_API sys_var_str :public sys_var
357
354
{
358
355
public:
359
356
  char *value;                                  // Pointer to allocated string
391
388
};
392
389
 
393
390
 
394
 
class sys_var_fs_path :
 
391
class DRIZZLED_API sys_var_fs_path :
395
392
  public sys_var
396
393
{
397
394
  const boost::filesystem::path &value;
549
546
  }
550
547
};
551
548
 
552
 
class sys_var_std_string :
 
549
class DRIZZLED_API sys_var_std_string :
553
550
  public sys_var
554
551
{
555
552
  std::string &value;
606
603
  bool is_readonly() const { return false; }
607
604
};
608
605
 
609
 
class sys_var_const_string :
 
606
class DRIZZLED_API sys_var_const_string :
610
607
  public sys_var
611
608
{
612
609
  const std::string &value;
641
638
  bool is_readonly() const { return true; }
642
639
};
643
640
 
644
 
class sys_var_const_string_val :
 
641
class DRIZZLED_API sys_var_const_string_val :
645
642
  public sys_var
646
643
{
647
644
  const std::string value;
676
673
  bool is_readonly() const { return true; }
677
674
};
678
675
 
679
 
class sys_var_const_str :public sys_var
 
676
class DRIZZLED_API sys_var_const_str :public sys_var
680
677
{
681
678
  char *value;                                  // Pointer to const value
682
679
public:
711
708
};
712
709
 
713
710
 
714
 
class sys_var_const_str_ptr :public sys_var
 
711
class DRIZZLED_API sys_var_const_str_ptr :public sys_var
715
712
{
716
713
  char **value;                                 // Pointer to const value
717
714
public:
741
738
};
742
739
 
743
740
 
744
 
class sys_var_session :public sys_var
 
741
class DRIZZLED_API sys_var_session :public sys_var
745
742
{
746
743
public:
747
744
  sys_var_session(const char *name_arg,
756
753
  }
757
754
};
758
755
 
759
 
class sys_var_session_uint32_t :public sys_var_session
 
756
class DRIZZLED_API sys_var_session_uint32_t :public sys_var_session
760
757
{
761
758
  sys_check_func check_func;
762
759
public:
777
774
};
778
775
 
779
776
 
780
 
class sys_var_session_ha_rows :public sys_var_session
 
777
class DRIZZLED_API sys_var_session_ha_rows :public sys_var_session
781
778
{
782
779
public:
783
780
  ha_rows drizzle_system_variables::*offset;
798
795
};
799
796
 
800
797
 
801
 
class sys_var_session_uint64_t :public sys_var_session
 
798
class DRIZZLED_API sys_var_session_uint64_t :public sys_var_session
802
799
{
803
800
  sys_check_func check_func;
804
801
public:
839
836
  }
840
837
};
841
838
 
842
 
class sys_var_session_size_t :public sys_var_session
 
839
class DRIZZLED_API sys_var_session_size_t :public sys_var_session
843
840
{
844
841
  sys_check_func check_func;
845
842
public:
880
877
};
881
878
 
882
879
 
883
 
class sys_var_session_bool :public sys_var_session
 
880
class DRIZZLED_API sys_var_session_bool :public sys_var_session
884
881
{
885
882
public:
886
883
  bool drizzle_system_variables::*offset;
896
893
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
897
894
  unsigned char *value_ptr(Session *session, sql_var_t type,
898
895
                           const LEX_STRING *base);
899
 
  bool check(Session *session, set_var *var)
900
 
  {
901
 
    return check_enum(session, var, &bool_typelib);
902
 
  }
 
896
  bool check(Session *session, set_var *var);
903
897
  bool check_update_type(Item_result)
904
898
  { return 0; }
905
899
};
906
900
 
907
901
 
908
 
class sys_var_session_enum :public sys_var_session
 
902
class DRIZZLED_API sys_var_session_enum :public sys_var_session
909
903
{
910
904
protected:
911
905
  uint32_t drizzle_system_variables::*offset;
936
930
};
937
931
 
938
932
 
939
 
class sys_var_session_storage_engine :public sys_var_session
 
933
class DRIZZLED_API sys_var_session_storage_engine :public sys_var_session
940
934
{
941
935
protected:
942
936
  plugin::StorageEngine *drizzle_system_variables::*offset;
956
950
                           const LEX_STRING *base);
957
951
};
958
952
 
959
 
class sys_var_session_bit :public sys_var_session
 
953
class DRIZZLED_API sys_var_session_bit :public sys_var_session
960
954
{
961
955
  sys_check_func check_func;
962
956
  sys_update_func update_func;
981
975
 
982
976
/* some variables that require special handling */
983
977
 
984
 
class sys_var_timestamp :public sys_var
 
978
class DRIZZLED_API sys_var_timestamp :public sys_var
985
979
{
986
980
public:
987
981
  sys_var_timestamp(const char *name_arg)
998
992
};
999
993
 
1000
994
 
1001
 
class sys_var_last_insert_id :public sys_var
 
995
class DRIZZLED_API sys_var_last_insert_id :public sys_var
1002
996
{
1003
997
public:
1004
998
  sys_var_last_insert_id(const char *name_arg)
1012
1006
};
1013
1007
 
1014
1008
 
1015
 
class sys_var_collation :public sys_var_session
 
1009
class DRIZZLED_API sys_var_collation :public sys_var_session
1016
1010
{
1017
1011
public:
1018
1012
  sys_var_collation(const char *name_arg)
1027
1021
  virtual void set_default(Session *session, sql_var_t type)= 0;
1028
1022
};
1029
1023
 
1030
 
class sys_var_collation_sv :public sys_var_collation
 
1024
class DRIZZLED_API sys_var_collation_sv :public sys_var_collation
1031
1025
{
1032
1026
  const CHARSET_INFO *drizzle_system_variables::*offset;
1033
1027
  const CHARSET_INFO **global_default;
1048
1042
 
1049
1043
/* Variable that you can only read from */
1050
1044
 
1051
 
class sys_var_readonly: public sys_var
 
1045
class DRIZZLED_API sys_var_readonly: public sys_var
1052
1046
{
1053
1047
public:
1054
1048
  sql_var_t var_type;
1077
1071
};
1078
1072
 
1079
1073
 
1080
 
class sys_var_session_time_zone :public sys_var_session
 
1074
class DRIZZLED_API sys_var_session_time_zone :public sys_var_session
1081
1075
{
1082
1076
public:
1083
1077
  sys_var_session_time_zone(const char *name_arg)
1099
1093
};
1100
1094
 
1101
1095
 
1102
 
class sys_var_microseconds :public sys_var_session
 
1096
class DRIZZLED_API sys_var_microseconds :public sys_var_session
1103
1097
{
1104
1098
  uint64_t drizzle_system_variables::*offset;
1105
1099
public:
1117
1111
  }
1118
1112
};
1119
1113
 
1120
 
class sys_var_session_lc_time_names :public sys_var_session
 
1114
class DRIZZLED_API sys_var_session_lc_time_names :public sys_var_session
1121
1115
{
1122
1116
public:
1123
1117
  sys_var_session_lc_time_names(const char *name_arg)