← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sys_var.h

  • Committer: Monty Taylor
  • Date: 2010-11-08 18:26:08 UTC
  • mto: This revision was merged to the branch mainline in revision 1931.
  • Revision ID: mordred@inaugust.com-20101108182608-lci86acl7r53sbi3
Replaced auto_ptr with scoped_ptr.

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
{
38
37
 
39
38
class sys_var;
 
39
class sys_var_pluginvar; /* opaque */
40
40
class Time_zone;
41
41
typedef struct my_locale_st MY_LOCALE;
42
 
typedef struct st_typelib TYPELIB;
 
42
 
 
43
extern TYPELIB bool_typelib;
43
44
 
44
45
typedef int (*sys_check_func)(Session *,  set_var *);
45
46
typedef bool (*sys_update_func)(Session *, set_var *);
56
57
extern const char *in_left_expr_name;
57
58
extern const char *in_additional_cond;
58
59
extern const char *in_having_cond;
 
60
extern char glob_hostname[FN_REFLEN];
59
61
extern boost::filesystem::path basedir;
60
62
extern boost::filesystem::path pid_file;
61
63
extern boost::filesystem::path secure_file_priv;
 
64
extern char system_time_zone[30];
62
65
extern char *opt_tc_log_file;
63
66
extern uint64_t session_startup_options;
64
67
extern uint32_t global_thread_id;
65
68
extern uint64_t table_cache_size;
 
69
extern uint64_t max_connect_errors;
66
70
extern back_log_constraints back_log;
67
71
extern uint32_t ha_open_options;
68
72
extern char *drizzled_bind_host;
71
75
extern uint32_t volatile thread_running;
72
76
extern uint32_t volatile global_read_lock;
73
77
extern bool opt_readonly;
 
78
extern char *default_tz_name;
74
79
extern const char *opt_scheduler;
75
 
extern size_t transaction_message_threshold;
76
80
 
77
81
uint64_t fix_unsigned(Session *, uint64_t, const struct option *);
78
82
 
79
 
const std::string &getServerHostname();
80
83
int sys_var_init();
81
84
 
82
85
/**
83
86
 * A class which represents a variable, either global or 
84
87
 * session-local.
85
88
 */
86
 
class DRIZZLED_API sys_var
 
89
class sys_var
87
90
{
88
91
protected:
89
92
  std::string name; /**< The name of the variable */
90
 
  sys_check_func check_func;
91
93
  sys_after_update_func after_update; /**< Function pointer triggered after the variable's value is updated */
92
94
  struct option *option_limits; /**< Updated by by sys_var_init() */
93
95
  bool m_allow_empty_value; /**< Does variable allow an empty value? */
94
96
public:
95
 
  sys_var(const std::string &name_arg,
96
 
          sys_after_update_func func= NULL,
97
 
          sys_check_func check_func_arg= NULL)
 
97
  sys_var(const std::string &name_arg, sys_after_update_func func= NULL)
98
98
    :
99
99
    name(name_arg),
100
 
    check_func(check_func_arg),
101
100
    after_update(func),
102
101
    option_limits(NULL),
103
102
    m_allow_empty_value(true)
181
180
  {
182
181
    return 0;
183
182
  }
 
183
  virtual sys_var_pluginvar *cast_pluginvar()
 
184
  {
 
185
    return 0;
 
186
  }
184
187
};
185
188
 
186
189
/**
187
190
 * A base class for all variables that require its access to
188
191
 * be guarded with a mutex.
189
192
 */
190
 
class DRIZZLED_API sys_var_global: public sys_var
 
193
class sys_var_global: public sys_var
191
194
{
192
195
protected:
193
196
  pthread_mutex_t *guard;
201
204
  {}
202
205
};
203
206
 
204
 
class DRIZZLED_API sys_var_uint32_t_ptr :public sys_var
 
207
class sys_var_uint32_t_ptr :public sys_var
205
208
{
206
209
  uint32_t *value;
207
210
public:
222
225
  { return (unsigned char*) value; }
223
226
};
224
227
 
225
 
class DRIZZLED_API sys_var_uint32_t_ptr_readonly :
226
 
  public sys_var_uint32_t_ptr
227
 
{
228
 
public:
229
 
  sys_var_uint32_t_ptr_readonly(const char *name_arg,
230
 
                                uint32_t *value_ptr_arg) :
231
 
    sys_var_uint32_t_ptr(name_arg, value_ptr_arg)
232
 
  {}
233
 
 
234
 
  sys_var_uint32_t_ptr_readonly(const char *name_arg,
235
 
                                uint32_t *value_ptr_arg,
236
 
                                sys_after_update_func func) :
237
 
    sys_var_uint32_t_ptr(name_arg, value_ptr_arg, func)
238
 
  {}
239
 
 
240
 
  bool is_readonly() const
241
 
  {
242
 
    return true;
243
 
  }
244
 
};
245
 
 
246
 
 
247
 
class DRIZZLED_API sys_var_uint64_t_ptr :public sys_var
 
228
 
 
229
class sys_var_uint64_t_ptr :public sys_var
248
230
{
249
231
  uint64_t *value;
250
232
  const uint64_t default_value;
297
279
  { return (unsigned char*) value; }
298
280
};
299
281
 
300
 
class DRIZZLED_API sys_var_size_t_ptr :public sys_var
 
282
class sys_var_size_t_ptr :public sys_var
301
283
{
302
284
  size_t *value;
303
285
public:
315
297
  { return (unsigned char*) value; }
316
298
};
317
299
 
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
329
 
{
330
 
  bool default_value;
 
300
class sys_var_bool_ptr :public sys_var
 
301
{
331
302
public:
332
303
  bool *value;
333
304
  sys_var_bool_ptr(const std::string &name_arg, bool *value_arg,
334
305
                   sys_after_update_func func= NULL) :
335
 
    sys_var(name_arg, func), default_value(*value_arg), value(value_arg)
 
306
    sys_var(name_arg, func), value(value_arg)
336
307
  { }
337
 
  bool check(Session *session, set_var *var);
338
 
  virtual bool check_default(sql_var_t)
 
308
  bool check(Session *session, set_var *var)
339
309
  {
340
 
    return false;
 
310
    return check_enum(session, var, &bool_typelib);
341
311
  }
342
312
  bool update(Session *session, set_var *var);
343
313
  void set_default(Session *session, sql_var_t type);
348
318
  { return 0; }
349
319
};
350
320
 
351
 
class DRIZZLED_API sys_var_bool_ptr_readonly :public sys_var_bool_ptr
 
321
class sys_var_bool_ptr_readonly :public sys_var_bool_ptr
352
322
{
353
323
public:
354
324
  sys_var_bool_ptr_readonly(const char *name_arg,
359
329
};
360
330
 
361
331
 
362
 
class DRIZZLED_API sys_var_str :public sys_var
 
332
class sys_var_str :public sys_var
363
333
{
364
334
public:
365
335
  char *value;                                  // Pointer to allocated string
366
336
  uint32_t value_length;
 
337
  sys_check_func check_func;
367
338
  sys_update_func update_func;
368
339
  sys_set_default_func set_default_func;
369
340
  sys_var_str(const char *name_arg,
370
 
              sys_check_func check_func_arg,
371
 
              sys_update_func update_func_arg,
372
 
              sys_set_default_func set_default_func_arg,
373
 
              char *value_arg) :
374
 
    sys_var(name_arg, NULL, check_func_arg),
375
 
    value(value_arg),
376
 
    update_func(update_func_arg),
377
 
    set_default_func(set_default_func_arg)
 
341
              sys_check_func check_func_arg,
 
342
              sys_update_func update_func_arg,
 
343
              sys_set_default_func set_default_func_arg,
 
344
              char *value_arg)
 
345
    :sys_var(name_arg), value(value_arg), check_func(check_func_arg),
 
346
    update_func(update_func_arg),set_default_func(set_default_func_arg)
378
347
  {  }
379
348
  bool check(Session *session, set_var *var);
380
349
  bool update(Session *session, set_var *var)
397
366
};
398
367
 
399
368
 
400
 
class DRIZZLED_API sys_var_fs_path :
 
369
class sys_var_fs_path :
401
370
  public sys_var
402
371
{
403
372
  const boost::filesystem::path &value;
439
408
  constrained_value<T> &value;
440
409
  T basic_value;
441
410
  T default_value;
 
411
  bool have_default_value;
442
412
public:
443
413
  sys_var_constrained_value(const char *name_arg,
444
414
                            constrained_value<T> &value_arg) :
445
415
    sys_var(name_arg),
446
416
    value(value_arg),
447
 
    default_value(value_arg.get())
448
 
  { }
449
 
 
450
 
  sys_var_constrained_value(const char *name_arg,
451
 
                            constrained_value<T> &value_arg,
452
 
                            sys_after_update_func after_update_func_arg) :
453
 
    sys_var(name_arg, after_update_func_arg),
454
 
    value(value_arg),
455
 
    default_value(value_arg.get())
456
 
  { }
457
 
 
458
 
  sys_var_constrained_value(const char *name_arg,
459
 
                            constrained_value<T> &value_arg,
460
 
                            sys_check_func check_func_arg) :
461
 
    sys_var(name_arg, NULL, check_func_arg),
462
 
    value(value_arg),
463
 
    default_value(value_arg.get())
 
417
    default_value(0),
 
418
    have_default_value(false)
 
419
  { }
 
420
 
 
421
  sys_var_constrained_value(const char *name_arg,
 
422
                            constrained_value<T> &value_arg,
 
423
                            T default_value_arg) :
 
424
    sys_var(name_arg),
 
425
    value(value_arg),
 
426
    default_value(default_value_arg),
 
427
    have_default_value(true)
464
428
  { }
465
429
 
466
430
public:
473
437
 
474
438
  bool update(Session *, set_var *var)
475
439
  {
476
 
    value= uint32_t(var->getInteger());
 
440
    value= var->save_result.uint32_t_value;
477
441
    return false;
478
442
  }
479
443
 
480
444
  bool check_default(sql_var_t)
481
445
  {
482
 
    return false;
 
446
    return not have_default_value;
483
447
  }
484
448
 
485
449
  void set_default(Session *, sql_var_t)
489
453
 
490
454
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
491
455
  {
492
 
    basic_value= value.get();
 
456
    basic_value= T(value);
493
457
    return (unsigned char*)&basic_value;
494
458
  }
495
459
};
509
473
template<>
510
474
inline SHOW_TYPE sys_var_constrained_value<uint32_t>::show_type()
511
475
{
512
 
  return SHOW_INT;
 
476
  return SHOW_LONG;
513
477
}
514
478
 
515
479
template<>
521
485
template<>
522
486
inline bool sys_var_constrained_value<uint64_t>::update(Session *, set_var *var)
523
487
{
524
 
  value= var->getInteger();
 
488
  value= var->save_result.uint64_t_value;
525
489
  return false;
526
490
}
527
491
 
528
492
template<>
529
493
inline bool sys_var_constrained_value<uint32_t>::update(Session *, set_var *var)
530
494
{
531
 
  value= uint32_t(var->getInteger());
 
495
  value= var->save_result.uint32_t_value;
532
496
  return false;
533
497
}
534
498
 
555
519
  }
556
520
};
557
521
 
558
 
class DRIZZLED_API sys_var_std_string :
559
 
  public sys_var
560
 
{
561
 
  std::string &value;
562
 
  sys_check_func check_func;
563
 
  sys_update_func update_func;
564
 
  sys_set_default_func set_default_func;
565
 
public:
566
 
  sys_var_std_string(const std::string &name_arg,
567
 
                     std::string &value_arg,
568
 
                     sys_check_func check_func_arg= NULL,
569
 
                     sys_update_func update_func_arg= NULL) :
570
 
    sys_var(name_arg),
571
 
    value(value_arg),
572
 
    check_func(check_func_arg),
573
 
    update_func(update_func_arg)
574
 
  {  }
575
 
 
576
 
  inline void set(char *val_in)
577
 
  {
578
 
    value= val_in; 
579
 
  }
580
 
 
581
 
  void set_check_func(sys_check_func check_func_arg= NULL)
582
 
  {
583
 
    check_func= check_func_arg;
584
 
  }
585
 
 
586
 
  void set_update_func(sys_update_func update_func_arg= NULL)
587
 
  {
588
 
    update_func= update_func_arg;
589
 
  }
590
 
 
591
 
  bool check(Session *session, set_var *var);
592
 
    
593
 
  bool update(Session *session, set_var *var)
594
 
  {
595
 
    if (update_func != NULL)
596
 
    {
597
 
      return (*update_func)(session, var);
598
 
    }
599
 
    return false;
600
 
  }
601
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
602
 
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
603
 
  {
604
 
    return (unsigned char*)(value.c_str());
605
 
  }
606
 
  bool check_update_type(Item_result type)
607
 
  {
608
 
    return type != STRING_RESULT;               /* Only accept strings */
609
 
  }
610
 
  bool check_default(sql_var_t)
611
 
  { return true; }
612
 
  bool is_readonly() const { return false; }
613
 
};
614
 
 
615
 
class DRIZZLED_API sys_var_const_string :
 
522
class sys_var_const_string :
616
523
  public sys_var
617
524
{
618
525
  const std::string &value;
647
554
  bool is_readonly() const { return true; }
648
555
};
649
556
 
650
 
class DRIZZLED_API sys_var_const_string_val :
 
557
class sys_var_const_string_val :
651
558
  public sys_var
652
559
{
653
560
  const std::string value;
682
589
  bool is_readonly() const { return true; }
683
590
};
684
591
 
685
 
class DRIZZLED_API sys_var_const_str :public sys_var
 
592
class sys_var_const_str :public sys_var
686
593
{
687
594
  char *value;                                  // Pointer to const value
688
595
public:
717
624
};
718
625
 
719
626
 
720
 
class DRIZZLED_API sys_var_const_str_ptr :public sys_var
 
627
class sys_var_const_str_ptr :public sys_var
721
628
{
722
629
  char **value;                                 // Pointer to const value
723
630
public:
747
654
};
748
655
 
749
656
 
750
 
class DRIZZLED_API sys_var_session :public sys_var
 
657
class sys_var_session :public sys_var
751
658
{
752
659
public:
753
660
  sys_var_session(const char *name_arg,
762
669
  }
763
670
};
764
671
 
765
 
class DRIZZLED_API sys_var_session_uint32_t :public sys_var_session
 
672
class sys_var_session_uint32_t :public sys_var_session
766
673
{
767
674
  sys_check_func check_func;
768
675
public:
783
690
};
784
691
 
785
692
 
786
 
class DRIZZLED_API sys_var_session_ha_rows :public sys_var_session
 
693
class sys_var_session_ha_rows :public sys_var_session
787
694
{
788
695
public:
789
696
  ha_rows drizzle_system_variables::*offset;
804
711
};
805
712
 
806
713
 
807
 
class DRIZZLED_API sys_var_session_uint64_t :public sys_var_session
 
714
class sys_var_session_uint64_t :public sys_var_session
808
715
{
809
716
  sys_check_func check_func;
810
717
public:
845
752
  }
846
753
};
847
754
 
848
 
class DRIZZLED_API sys_var_session_size_t :public sys_var_session
 
755
class sys_var_session_size_t :public sys_var_session
849
756
{
850
757
  sys_check_func check_func;
851
758
public:
886
793
};
887
794
 
888
795
 
889
 
class DRIZZLED_API sys_var_session_bool :public sys_var_session
 
796
class sys_var_session_bool :public sys_var_session
890
797
{
891
798
public:
892
799
  bool drizzle_system_variables::*offset;
902
809
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
903
810
  unsigned char *value_ptr(Session *session, sql_var_t type,
904
811
                           const LEX_STRING *base);
905
 
  bool check(Session *session, set_var *var);
 
812
  bool check(Session *session, set_var *var)
 
813
  {
 
814
    return check_enum(session, var, &bool_typelib);
 
815
  }
906
816
  bool check_update_type(Item_result)
907
817
  { return 0; }
908
818
};
909
819
 
910
820
 
911
 
class DRIZZLED_API sys_var_session_enum :public sys_var_session
 
821
class sys_var_session_enum :public sys_var_session
912
822
{
913
823
protected:
914
824
  uint32_t drizzle_system_variables::*offset;
939
849
};
940
850
 
941
851
 
942
 
class DRIZZLED_API sys_var_session_storage_engine :public sys_var_session
 
852
class sys_var_session_storage_engine :public sys_var_session
943
853
{
944
854
protected:
945
855
  plugin::StorageEngine *drizzle_system_variables::*offset;
948
858
                                 plugin::StorageEngine *drizzle_system_variables::*offset_arg)
949
859
    :sys_var_session(name_arg), offset(offset_arg)
950
860
  {  }
 
861
  bool check(Session *session, set_var *var);
951
862
  SHOW_TYPE show_type() { return SHOW_CHAR; }
952
863
  bool check_update_type(Item_result type)
953
864
  {
959
870
                           const LEX_STRING *base);
960
871
};
961
872
 
962
 
class DRIZZLED_API sys_var_session_bit :public sys_var_session
 
873
class sys_var_session_bit :public sys_var_session
963
874
{
964
875
  sys_check_func check_func;
965
876
  sys_update_func update_func;
984
895
 
985
896
/* some variables that require special handling */
986
897
 
987
 
class DRIZZLED_API sys_var_timestamp :public sys_var
 
898
class sys_var_timestamp :public sys_var
988
899
{
989
900
public:
990
901
  sys_var_timestamp(const char *name_arg)
1001
912
};
1002
913
 
1003
914
 
1004
 
class DRIZZLED_API sys_var_last_insert_id :public sys_var
 
915
class sys_var_last_insert_id :public sys_var
1005
916
{
1006
917
public:
1007
918
  sys_var_last_insert_id(const char *name_arg)
1015
926
};
1016
927
 
1017
928
 
1018
 
class DRIZZLED_API sys_var_collation :public sys_var_session
 
929
class sys_var_collation :public sys_var_session
1019
930
{
1020
931
public:
1021
932
  sys_var_collation(const char *name_arg)
1022
933
    :sys_var_session(name_arg, NULL)
1023
934
  { }
 
935
  bool check(Session *session, set_var *var);
1024
936
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1025
937
  bool check_update_type(Item_result type)
1026
938
  {
1030
942
  virtual void set_default(Session *session, sql_var_t type)= 0;
1031
943
};
1032
944
 
1033
 
class DRIZZLED_API sys_var_collation_sv :public sys_var_collation
 
945
class sys_var_collation_sv :public sys_var_collation
1034
946
{
1035
947
  const CHARSET_INFO *drizzle_system_variables::*offset;
1036
948
  const CHARSET_INFO **global_default;
1051
963
 
1052
964
/* Variable that you can only read from */
1053
965
 
1054
 
class DRIZZLED_API sys_var_readonly: public sys_var
 
966
class sys_var_readonly: public sys_var
1055
967
{
1056
968
public:
1057
969
  sql_var_t var_type;
1079
991
  bool is_readonly(void) const { return 1; }
1080
992
};
1081
993
 
1082
 
class DRIZZLED_API sys_var_microseconds :public sys_var_session
 
994
 
 
995
class sys_var_session_time_zone :public sys_var_session
 
996
{
 
997
public:
 
998
  sys_var_session_time_zone(const char *name_arg)
 
999
    :sys_var_session(name_arg, NULL)
 
1000
  {
 
1001
    
 
1002
  }
 
1003
  bool check(Session *session, set_var *var);
 
1004
  SHOW_TYPE show_type() { return SHOW_CHAR; }
 
1005
  bool check_update_type(Item_result type)
 
1006
  {
 
1007
    return type != STRING_RESULT;               /* Only accept strings */
 
1008
  }
 
1009
  bool check_default(sql_var_t)
 
1010
  { return 0; }
 
1011
  bool update(Session *session, set_var *var);
 
1012
  unsigned char *value_ptr(Session *session, sql_var_t type,
 
1013
                           const LEX_STRING *base);
 
1014
  virtual void set_default(Session *session, sql_var_t type);
 
1015
};
 
1016
 
 
1017
 
 
1018
class sys_var_microseconds :public sys_var_session
1083
1019
{
1084
1020
  uint64_t drizzle_system_variables::*offset;
1085
1021
public:
1097
1033
  }
1098
1034
};
1099
1035
 
1100
 
class DRIZZLED_API sys_var_session_lc_time_names :public sys_var_session
 
1036
class sys_var_session_lc_time_names :public sys_var_session
1101
1037
{
1102
1038
public:
1103
1039
  sys_var_session_lc_time_names(const char *name_arg)
1105
1041
  {
1106
1042
    
1107
1043
  }
 
1044
  bool check(Session *session, set_var *var);
1108
1045
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1109
1046
  bool check_update_type(Item_result type)
1110
1047
  {
1132
1069
*/
1133
1070
 
1134
1071
drizzle_show_var* enumerate_sys_vars(Session *session);
 
1072
void drizzle_add_plugin_sysvar(sys_var_pluginvar *var);
 
1073
void drizzle_del_plugin_sysvar();
1135
1074
void add_sys_var_to_list(sys_var *var, struct option *long_options);
1136
1075
void add_sys_var_to_list(sys_var *var);
1137
 
sys_var *find_sys_var(const std::string &name);
 
1076
sys_var *find_sys_var(Session *session, const char *str, uint32_t length=0);
 
1077
bool not_all_support_one_shot(List<set_var_base> *var_list);
 
1078
extern sys_var_session_time_zone sys_time_zone;
1138
1079
extern sys_var_session_bit sys_autocommit;
1139
1080
const CHARSET_INFO *get_old_charset_by_name(const char *old_name);
1140
1081