~thomir-deactivatedaccount/drizzle/drizzle-fix-bug653747

« back to all changes in this revision

Viewing changes to drizzled/set_var.h

  • Committer: Monty Taylor
  • Date: 2010-10-15 05:16:32 UTC
  • mto: This revision was merged to the branch mainline in revision 1856.
  • Revision ID: mordred@inaugust.com-20101015051632-1faw8fksacdj7qia
Removed sys_var_chain.

Show diffs side-by-side

added added

removed removed

Lines of Context:
87
87
 
88
88
uint64_t fix_unsigned(Session *, uint64_t, const struct option *);
89
89
 
90
 
struct sys_var_chain
91
 
{
92
 
  sys_var *first;
93
 
  sys_var *last;
94
 
};
 
90
void init_sys_var();
95
91
 
96
92
/**
97
93
 * A class which represents a variable, either global or 
104
100
  sys_after_update_func after_update; /**< Function pointer triggered after the variable's value is updated */
105
101
  struct option *option_limits; /**< Updated by by set_var_init() */
106
102
  bool m_allow_empty_value; /**< Does variable allow an empty value? */
107
 
  sys_var *next;
108
103
public:
109
104
  sys_var(const std::string name_arg, sys_after_update_func func= NULL)
110
105
    :
113
108
    m_allow_empty_value(true)
114
109
  {}
115
110
  virtual ~sys_var() {}
116
 
  void chain_sys_var(sys_var_chain *chain_arg)
117
 
  {
118
 
    if (chain_arg->last)
119
 
      chain_arg->last->next= this;
120
 
    else
121
 
      chain_arg->first= this;
122
 
    chain_arg->last= this;
123
 
  }
124
111
 
125
112
  /** 
126
113
   * Returns the name of the variable.
142
129
    return empty_aliases;
143
130
  }
144
131
  /**
145
 
   * Returns a pointer to the next sys_var, or NULL if none.
146
 
   */
147
 
  inline sys_var *getNext() const
148
 
  {
149
 
    return next;
150
 
  }
151
 
  /**
152
 
   * Sets the pointer to the next sys_var.
153
 
   *
154
 
   * @param Pointer to the next sys_var, or NULL if you set the tail...
155
 
   */
156
 
  inline void setNext(sys_var *in_next)
157
 
  {
158
 
    next= in_next;
159
 
  }
160
 
  /**
161
132
   * Returns a pointer to the variable's option limits
162
133
   */
163
134
  inline struct option *getOptionLimits() const
238
209
{
239
210
  uint32_t *value;
240
211
public:
241
 
  sys_var_uint32_t_ptr(sys_var_chain *chain, const char *name_arg,
 
212
  sys_var_uint32_t_ptr(const char *name_arg,
242
213
                       uint32_t *value_ptr_arg)
243
214
    :sys_var(name_arg),value(value_ptr_arg)
244
 
  { chain_sys_var(chain); }
245
 
  sys_var_uint32_t_ptr(sys_var_chain *chain, const char *name_arg,
 
215
  {  }
 
216
  sys_var_uint32_t_ptr(const char *name_arg,
246
217
                       uint32_t *value_ptr_arg,
247
218
                       sys_after_update_func func)
248
219
    :sys_var(name_arg,func), value(value_ptr_arg)
249
 
  { chain_sys_var(chain); }
 
220
  {  }
250
221
  bool check(Session *session, set_var *var);
251
222
  bool update(Session *session, set_var *var);
252
223
  void set_default(Session *session, sql_var_t type);
260
231
{
261
232
  uint64_t *value;
262
233
public:
263
 
  sys_var_uint64_t_ptr(sys_var_chain *chain, const char *name_arg, uint64_t *value_ptr_arg)
 
234
  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg)
264
235
    :sys_var(name_arg),value(value_ptr_arg)
265
 
  { chain_sys_var(chain); }
266
 
  sys_var_uint64_t_ptr(sys_var_chain *chain, const char *name_arg, uint64_t *value_ptr_arg,
 
236
  {  }
 
237
  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg,
267
238
                       sys_after_update_func func)
268
239
    :sys_var(name_arg,func), value(value_ptr_arg)
269
 
  { chain_sys_var(chain); }
 
240
  {  }
270
241
  bool update(Session *session, set_var *var);
271
242
  void set_default(Session *session, sql_var_t type);
272
243
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
279
250
{
280
251
  size_t *value;
281
252
public:
282
 
  sys_var_size_t_ptr(sys_var_chain *chain, const char *name_arg, size_t *value_ptr_arg)
 
253
  sys_var_size_t_ptr(const char *name_arg, size_t *value_ptr_arg)
283
254
    :sys_var(name_arg),value(value_ptr_arg)
284
 
  { chain_sys_var(chain); }
285
 
  sys_var_size_t_ptr(sys_var_chain *chain, const char *name_arg, size_t *value_ptr_arg,
 
255
  {  }
 
256
  sys_var_size_t_ptr(const char *name_arg, size_t *value_ptr_arg,
286
257
                     sys_after_update_func func)
287
258
    :sys_var(name_arg,func), value(value_ptr_arg)
288
 
  { chain_sys_var(chain); }
 
259
  {  }
289
260
  bool update(Session *session, set_var *var);
290
261
  void set_default(Session *session, sql_var_t type);
291
262
  SHOW_TYPE show_type() { return SHOW_SIZE; }
297
268
{
298
269
public:
299
270
  bool *value;
300
 
  sys_var_bool_ptr(sys_var_chain *chain, const char *name_arg, bool *value_arg)
 
271
  sys_var_bool_ptr(const char *name_arg, bool *value_arg)
301
272
    :sys_var(name_arg),value(value_arg)
302
 
  { chain_sys_var(chain); }
 
273
  {  }
303
274
  bool check(Session *session, set_var *var)
304
275
  {
305
276
    return check_enum(session, var, &bool_typelib);
316
287
class sys_var_bool_ptr_readonly :public sys_var_bool_ptr
317
288
{
318
289
public:
319
 
  sys_var_bool_ptr_readonly(sys_var_chain *chain, const char *name_arg,
 
290
  sys_var_bool_ptr_readonly(const char *name_arg,
320
291
                            bool *value_arg)
321
 
    :sys_var_bool_ptr(chain, name_arg, value_arg)
 
292
    :sys_var_bool_ptr(name_arg, value_arg)
322
293
  {}
323
294
  bool is_readonly() const { return 1; }
324
295
};
332
303
  sys_check_func check_func;
333
304
  sys_update_func update_func;
334
305
  sys_set_default_func set_default_func;
335
 
  sys_var_str(sys_var_chain *chain, const char *name_arg,
 
306
  sys_var_str(const char *name_arg,
336
307
              sys_check_func check_func_arg,
337
308
              sys_update_func update_func_arg,
338
309
              sys_set_default_func set_default_func_arg,
339
310
              char *value_arg)
340
311
    :sys_var(name_arg), value(value_arg), check_func(check_func_arg),
341
312
    update_func(update_func_arg),set_default_func(set_default_func_arg)
342
 
  { chain_sys_var(chain); }
 
313
  {  }
343
314
  bool check(Session *session, set_var *var);
344
315
  bool update(Session *session, set_var *var)
345
316
  {
366
337
{
367
338
  const boost::filesystem::path &value;
368
339
public:
369
 
  sys_var_fs_path(sys_var_chain *chain,
370
 
                  const char *name_arg,
 
340
  sys_var_fs_path(const char *name_arg,
371
341
                  const boost::filesystem::path& value_arg) :
372
342
    sys_var(name_arg),
373
343
    value(value_arg)
374
 
  {
375
 
    chain_sys_var(chain);
376
 
  }
 
344
  { }
377
345
 
378
346
  inline void set(char *)
379
347
  { }
403
371
{
404
372
  char *value;                                  // Pointer to const value
405
373
public:
406
 
  sys_var_const_str(sys_var_chain *chain, const char *name_arg,
 
374
  sys_var_const_str(const char *name_arg,
407
375
                    const char *value_arg)
408
376
    :sys_var(name_arg), value((char*) value_arg)
409
 
  { chain_sys_var(chain); }
 
377
  {  }
410
378
  inline void set (char *new_value)
411
379
  {
412
380
    value= new_value;
438
406
{
439
407
  char **value;                                 // Pointer to const value
440
408
public:
441
 
  sys_var_const_str_ptr(sys_var_chain *chain, const char *name_arg, char **value_arg)
 
409
  sys_var_const_str_ptr(const char *name_arg, char **value_arg)
442
410
    :sys_var(name_arg),value(value_arg)
443
 
  { chain_sys_var(chain); }
 
411
  {  }
444
412
  bool check(Session *, set_var *)
445
413
  {
446
414
    return 1;
484
452
  sys_check_func check_func;
485
453
public:
486
454
  uint32_t system_variables::*offset;
487
 
  sys_var_session_uint32_t(sys_var_chain *chain, const char *name_arg,
 
455
  sys_var_session_uint32_t(const char *name_arg,
488
456
                           uint32_t system_variables::*offset_arg,
489
457
                           sys_check_func c_func= NULL,
490
458
                           sys_after_update_func au_func= NULL)
491
459
    :sys_var_session(name_arg, au_func), check_func(c_func),
492
460
    offset(offset_arg)
493
 
  { chain_sys_var(chain); }
 
461
  {  }
494
462
  bool check(Session *session, set_var *var);
495
463
  bool update(Session *session, set_var *var);
496
464
  void set_default(Session *session, sql_var_t type);
504
472
{
505
473
public:
506
474
  ha_rows system_variables::*offset;
507
 
  sys_var_session_ha_rows(sys_var_chain *chain, const char *name_arg,
 
475
  sys_var_session_ha_rows(const char *name_arg,
508
476
                      ha_rows system_variables::*offset_arg)
509
477
    :sys_var_session(name_arg), offset(offset_arg)
510
 
  { chain_sys_var(chain); }
511
 
  sys_var_session_ha_rows(sys_var_chain *chain, const char *name_arg,
 
478
  {  }
 
479
  sys_var_session_ha_rows(const char *name_arg,
512
480
                      ha_rows system_variables::*offset_arg,
513
481
                      sys_after_update_func func)
514
482
    :sys_var_session(name_arg,func), offset(offset_arg)
515
 
  { chain_sys_var(chain); }
 
483
  {  }
516
484
  bool update(Session *session, set_var *var);
517
485
  void set_default(Session *session, sql_var_t type);
518
486
  SHOW_TYPE show_type() { return SHOW_HA_ROWS; }
527
495
public:
528
496
  uint64_t system_variables::*offset;
529
497
  bool only_global;
530
 
  sys_var_session_uint64_t(sys_var_chain *chain, 
 
498
  sys_var_session_uint64_t(
531
499
                           const char *name_arg,
532
500
                           uint64_t system_variables::*offset_arg,
533
501
                           sys_after_update_func au_func= NULL,
535
503
    :sys_var_session(name_arg, au_func),
536
504
    check_func(c_func),
537
505
    offset(offset_arg)
538
 
  { chain_sys_var(chain); }
539
 
  sys_var_session_uint64_t(sys_var_chain *chain,
540
 
                           const char *name_arg,
 
506
  {  }
 
507
  sys_var_session_uint64_t(const char *name_arg,
541
508
                           uint64_t system_variables::*offset_arg,
542
509
                           sys_after_update_func func,
543
510
                           bool only_global_arg,
546
513
    check_func(cfunc),
547
514
    offset(offset_arg),
548
515
    only_global(only_global_arg)
549
 
  { chain_sys_var(chain); }
 
516
  {  }
550
517
  bool update(Session *session, set_var *var);
551
518
  void set_default(Session *session, sql_var_t type);
552
519
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
569
536
public:
570
537
  size_t system_variables::*offset;
571
538
  bool only_global;
572
 
  sys_var_session_size_t(sys_var_chain *chain, const char *name_arg,
 
539
  sys_var_session_size_t(const char *name_arg,
573
540
                         size_t system_variables::*offset_arg,
574
541
                         sys_after_update_func au_func= NULL,
575
542
                         sys_check_func c_func= NULL)
576
543
    :sys_var_session(name_arg, au_func),
577
544
     check_func(c_func),
578
545
     offset(offset_arg)
579
 
  { chain_sys_var(chain); }
580
 
  sys_var_session_size_t(sys_var_chain *chain,
581
 
                         const char *name_arg,
 
546
  {  }
 
547
  sys_var_session_size_t(const char *name_arg,
582
548
                         size_t system_variables::*offset_arg,
583
549
                         sys_after_update_func func,
584
550
                         bool only_global_arg,
587
553
     check_func(cfunc),
588
554
     offset(offset_arg),
589
555
     only_global(only_global_arg)
590
 
  { chain_sys_var(chain); }
 
556
  {  }
591
557
  bool update(Session *session, set_var *var);
592
558
  void set_default(Session *session, sql_var_t type);
593
559
  SHOW_TYPE show_type() { return SHOW_SIZE; }
609
575
{
610
576
public:
611
577
  bool system_variables::*offset;
612
 
  sys_var_session_bool(sys_var_chain *chain, const char *name_arg, bool system_variables::*offset_arg)
 
578
  sys_var_session_bool(const char *name_arg, bool system_variables::*offset_arg)
613
579
    :sys_var_session(name_arg), offset(offset_arg)
614
 
  { chain_sys_var(chain); }
615
 
  sys_var_session_bool(sys_var_chain *chain, const char *name_arg, bool system_variables::*offset_arg,
 
580
  {  }
 
581
  sys_var_session_bool(const char *name_arg, bool system_variables::*offset_arg,
616
582
                   sys_after_update_func func)
617
583
    :sys_var_session(name_arg,func), offset(offset_arg)
618
 
  { chain_sys_var(chain); }
 
584
  {  }
619
585
  bool update(Session *session, set_var *var);
620
586
  void set_default(Session *session, sql_var_t type);
621
587
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
637
603
  TYPELIB *enum_names;
638
604
  sys_check_func check_func;
639
605
public:
640
 
  sys_var_session_enum(sys_var_chain *chain, const char *name_arg,
 
606
  sys_var_session_enum(const char *name_arg,
641
607
                   uint32_t system_variables::*offset_arg, TYPELIB *typelib,
642
608
                   sys_after_update_func func= NULL,
643
609
                   sys_check_func check_f= NULL)
644
610
    :sys_var_session(name_arg, func), offset(offset_arg),
645
611
    enum_names(typelib), check_func(check_f)
646
 
  { chain_sys_var(chain); }
 
612
  {  }
647
613
  bool check(Session *session, set_var *var)
648
614
  {
649
615
    int ret= 0;
666
632
protected:
667
633
  plugin::StorageEngine *system_variables::*offset;
668
634
public:
669
 
  sys_var_session_storage_engine(sys_var_chain *chain, const char *name_arg,
 
635
  sys_var_session_storage_engine(const char *name_arg,
670
636
                                 plugin::StorageEngine *system_variables::*offset_arg)
671
637
    :sys_var_session(name_arg), offset(offset_arg)
672
 
  { chain_sys_var(chain); }
 
638
  {  }
673
639
  bool check(Session *session, set_var *var);
674
640
  SHOW_TYPE show_type() { return SHOW_CHAR; }
675
641
  bool check_update_type(Item_result type)
689
655
public:
690
656
  uint64_t bit_flag;
691
657
  bool reverse;
692
 
  sys_var_session_bit(sys_var_chain *chain, const char *name_arg,
 
658
  sys_var_session_bit(const char *name_arg,
693
659
                  sys_check_func c_func, sys_update_func u_func,
694
660
                  uint64_t bit, bool reverse_arg=0)
695
661
    :sys_var_session(name_arg, NULL), check_func(c_func),
696
662
    update_func(u_func), bit_flag(bit), reverse(reverse_arg)
697
 
  { chain_sys_var(chain); }
 
663
  {  }
698
664
  bool check(Session *session, set_var *var);
699
665
  bool update(Session *session, set_var *var);
700
666
  bool check_update_type(Item_result)
710
676
class sys_var_timestamp :public sys_var
711
677
{
712
678
public:
713
 
  sys_var_timestamp(sys_var_chain *chain, const char *name_arg)
 
679
  sys_var_timestamp(const char *name_arg)
714
680
    :sys_var(name_arg, NULL)
715
 
  { chain_sys_var(chain); }
 
681
  {  }
716
682
  bool update(Session *session, set_var *var);
717
683
  void set_default(Session *session, sql_var_t type);
718
684
  bool check_type(sql_var_t type)    { return type == OPT_GLOBAL; }
727
693
class sys_var_last_insert_id :public sys_var
728
694
{
729
695
public:
730
 
  sys_var_last_insert_id(sys_var_chain *chain, const char *name_arg)
 
696
  sys_var_last_insert_id(const char *name_arg)
731
697
    :sys_var(name_arg, NULL)
732
 
  { chain_sys_var(chain); }
 
698
  {  }
733
699
  bool update(Session *session, set_var *var);
734
700
  bool check_type(sql_var_t type) { return type == OPT_GLOBAL; }
735
701
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
759
725
  const CHARSET_INFO *system_variables::*offset;
760
726
  const CHARSET_INFO **global_default;
761
727
public:
762
 
  sys_var_collation_sv(sys_var_chain *chain, const char *name_arg,
 
728
  sys_var_collation_sv(const char *name_arg,
763
729
                       const CHARSET_INFO *system_variables::*offset_arg,
764
730
                       const CHARSET_INFO **global_default_arg)
765
731
    :sys_var_collation(name_arg),
766
732
    offset(offset_arg), global_default(global_default_arg)
767
733
  {
768
 
    chain_sys_var(chain);
 
734
    
769
735
  }
770
736
  bool update(Session *session, set_var *var);
771
737
  void set_default(Session *session, sql_var_t type);
781
747
  sql_var_t var_type;
782
748
  SHOW_TYPE show_type_value;
783
749
  sys_value_ptr_func value_ptr_func;
784
 
  sys_var_readonly(sys_var_chain *chain, const char *name_arg, sql_var_t type,
 
750
  sys_var_readonly(const char *name_arg, sql_var_t type,
785
751
                   SHOW_TYPE show_type_arg,
786
752
                   sys_value_ptr_func value_ptr_func_arg)
787
753
    :sys_var(name_arg), var_type(type),
788
754
       show_type_value(show_type_arg), value_ptr_func(value_ptr_func_arg)
789
 
  { chain_sys_var(chain); }
 
755
  {  }
790
756
  bool update(Session *, set_var *)
791
757
  { return 1; }
792
758
  bool check_default(sql_var_t)
807
773
class sys_var_session_time_zone :public sys_var_session
808
774
{
809
775
public:
810
 
  sys_var_session_time_zone(sys_var_chain *chain, const char *name_arg)
 
776
  sys_var_session_time_zone(const char *name_arg)
811
777
    :sys_var_session(name_arg, NULL)
812
778
  {
813
 
    chain_sys_var(chain);
 
779
    
814
780
  }
815
781
  bool check(Session *session, set_var *var);
816
782
  SHOW_TYPE show_type() { return SHOW_CHAR; }
831
797
{
832
798
  uint64_t system_variables::*offset;
833
799
public:
834
 
  sys_var_microseconds(sys_var_chain *chain, const char *name_arg,
 
800
  sys_var_microseconds(const char *name_arg,
835
801
                       uint64_t system_variables::*offset_arg):
836
802
    sys_var_session(name_arg), offset(offset_arg)
837
 
  { chain_sys_var(chain); }
 
803
  {  }
838
804
  bool check(Session *, set_var *) {return 0;}
839
805
  bool update(Session *session, set_var *var);
840
806
  void set_default(Session *session, sql_var_t type);
848
814
class sys_var_session_lc_time_names :public sys_var_session
849
815
{
850
816
public:
851
 
  sys_var_session_lc_time_names(sys_var_chain *chain, const char *name_arg)
 
817
  sys_var_session_lc_time_names(const char *name_arg)
852
818
    : sys_var_session(name_arg, NULL)
853
819
  {
854
 
    chain_sys_var(chain);
 
820
    
855
821
  }
856
822
  bool check(Session *session, set_var *var);
857
823
  SHOW_TYPE show_type() { return SHOW_CHAR; }
954
920
drizzle_show_var* enumerate_sys_vars(Session *session);
955
921
void drizzle_add_plugin_sysvar(sys_var_pluginvar *var);
956
922
void drizzle_del_plugin_sysvar();
957
 
int mysql_add_sys_var_chain(sys_var *chain, struct option *long_options);
958
 
int mysql_del_sys_var_chain(sys_var *chain);
 
923
void add_sys_var_to_list(sys_var *var, struct option *long_options);
 
924
void add_sys_var_to_list(sys_var *var);
959
925
sys_var *find_sys_var(Session *session, const char *str, uint32_t length=0);
960
926
int sql_set_variables(Session *session, List<set_var_base> *var_list);
961
927
bool not_all_support_one_shot(List<set_var_base> *var_list);