← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/set_var.h

  • Committer: Brian Aker
  • Date: 2010-02-14 02:02:48 UTC
  • mfrom: (1273.13.64 fix_is)
  • Revision ID: brian@gaz-20100214020248-bhovaejhz9fmer3q
Merge in data_dictionary.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/set_var.h
49
49
 
50
50
typedef int (*sys_check_func)(Session *,  set_var *);
51
51
typedef bool (*sys_update_func)(Session *, set_var *);
52
 
typedef void (*sys_after_update_func)(Session *,enum_var_type);
53
 
typedef void (*sys_set_default_func)(Session *, enum_var_type);
 
52
typedef void (*sys_after_update_func)(Session *, sql_var_t);
 
53
typedef void (*sys_set_default_func)(Session *, sql_var_t);
54
54
typedef unsigned char *(*sys_value_ptr_func)(Session *session);
55
55
 
56
56
static const std::vector<std::string> empty_aliases;
183
183
  virtual bool check(Session *session, set_var *var);
184
184
  bool check_enum(Session *session, set_var *var, const TYPELIB *enum_names);
185
185
  virtual bool update(Session *session, set_var *var)=0;
186
 
  virtual void set_default(Session *, enum_var_type)
 
186
  virtual void set_default(Session *, sql_var_t)
187
187
  {}
188
188
  virtual SHOW_TYPE show_type()
189
189
  {
190
190
    return SHOW_UNDEF;
191
191
  }
192
 
  virtual unsigned char *value_ptr(Session *, enum_var_type, const LEX_STRING *)
 
192
  virtual unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
193
193
  {
194
194
    return 0;
195
195
  }
196
 
  virtual bool check_type(enum_var_type type)
 
196
  virtual bool check_type(sql_var_t type)
197
197
  {
198
198
    return type != OPT_GLOBAL;
199
199
  }             /* Error if not GLOBAL */
201
201
  {
202
202
    return type != INT_RESULT;
203
203
  }             /* Assume INT */
204
 
  virtual bool check_default(enum_var_type)
 
204
  virtual bool check_default(sql_var_t)
205
205
  {
206
206
    return option_limits == 0;
207
207
  }
208
 
  Item *item(Session *session, enum_var_type type, const LEX_STRING *base);
 
208
  Item *item(Session *session, sql_var_t type, const LEX_STRING *base);
209
209
  virtual bool is_readonly() const
210
210
  {
211
211
    return 0;
249
249
  { chain_sys_var(chain); }
250
250
  bool check(Session *session, set_var *var);
251
251
  bool update(Session *session, set_var *var);
252
 
  void set_default(Session *session, enum_var_type type);
 
252
  void set_default(Session *session, sql_var_t type);
253
253
  SHOW_TYPE show_type() { return SHOW_INT; }
254
 
  unsigned char *value_ptr(Session *, enum_var_type, const LEX_STRING *)
 
254
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
255
255
  { return (unsigned char*) value; }
256
256
};
257
257
 
268
268
    :sys_var(name_arg,func), value(value_ptr_arg)
269
269
  { chain_sys_var(chain); }
270
270
  bool update(Session *session, set_var *var);
271
 
  void set_default(Session *session, enum_var_type type);
 
271
  void set_default(Session *session, sql_var_t type);
272
272
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
273
 
  unsigned char *value_ptr(Session *, enum_var_type,
 
273
  unsigned char *value_ptr(Session *, sql_var_t,
274
274
                           const LEX_STRING *)
275
275
  { return (unsigned char*) value; }
276
276
};
287
287
    :sys_var(name_arg,func), value(value_ptr_arg)
288
288
  { chain_sys_var(chain); }
289
289
  bool update(Session *session, set_var *var);
290
 
  void set_default(Session *session, enum_var_type type);
 
290
  void set_default(Session *session, sql_var_t type);
291
291
  SHOW_TYPE show_type() { return SHOW_SIZE; }
292
 
  unsigned char *value_ptr(Session *, enum_var_type, const LEX_STRING *)
 
292
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
293
293
  { return (unsigned char*) value; }
294
294
};
295
295
 
305
305
    return check_enum(session, var, &bool_typelib);
306
306
  }
307
307
  bool update(Session *session, set_var *var);
308
 
  void set_default(Session *session, enum_var_type type);
 
308
  void set_default(Session *session, sql_var_t type);
309
309
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
310
 
  unsigned char *value_ptr(Session *, enum_var_type, const LEX_STRING *)
 
310
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
311
311
  { return (unsigned char*) value; }
312
312
  bool check_update_type(Item_result)
313
313
  { return 0; }
345
345
  {
346
346
    return (*update_func)(session, var);
347
347
  }
348
 
  void set_default(Session *session, enum_var_type type)
 
348
  void set_default(Session *session, sql_var_t type)
349
349
  {
350
350
    (*set_default_func)(session, type);
351
351
  }
352
352
  SHOW_TYPE show_type() { return SHOW_CHAR; }
353
 
  unsigned char *value_ptr(Session *, enum_var_type, const LEX_STRING *)
 
353
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
354
354
  { return (unsigned char*) value; }
355
355
  bool check_update_type(Item_result type)
356
356
  {
357
357
    return type != STRING_RESULT;               /* Only accept strings */
358
358
  }
359
 
  bool check_default(enum_var_type)
 
359
  bool check_default(sql_var_t)
360
360
  { return 0; }
361
361
};
362
362
 
382
382
    return 1;
383
383
  }
384
384
  SHOW_TYPE show_type() { return SHOW_CHAR; }
385
 
  unsigned char *value_ptr(Session *, enum_var_type, const LEX_STRING *)
 
385
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
386
386
  {
387
387
    return (unsigned char*) value;
388
388
  }
390
390
  {
391
391
    return 1;
392
392
  }
393
 
  bool check_default(enum_var_type)
 
393
  bool check_default(sql_var_t)
394
394
  { return 1; }
395
395
  bool is_readonly() const { return 1; }
396
396
};
412
412
    return 1;
413
413
  }
414
414
  SHOW_TYPE show_type() { return SHOW_CHAR; }
415
 
  unsigned char *value_ptr(Session *, enum_var_type, const LEX_STRING *)
 
415
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
416
416
  {
417
417
    return (unsigned char*) *value;
418
418
  }
420
420
  {
421
421
    return 1;
422
422
  }
423
 
  bool check_default(enum_var_type)
 
423
  bool check_default(sql_var_t)
424
424
  { return 1; }
425
425
  bool is_readonly(void) const { return 1; }
426
426
};
433
433
              sys_after_update_func func= NULL)
434
434
    :sys_var(name_arg, func)
435
435
  {}
436
 
  bool check_type(enum_var_type)
 
436
  bool check_type(sql_var_t)
437
437
  { return 0; }
438
 
  bool check_default(enum_var_type type)
 
438
  bool check_default(sql_var_t type)
439
439
  {
440
440
    return type == OPT_GLOBAL && !option_limits;
441
441
  }
455
455
  { chain_sys_var(chain); }
456
456
  bool check(Session *session, set_var *var);
457
457
  bool update(Session *session, set_var *var);
458
 
  void set_default(Session *session, enum_var_type type);
 
458
  void set_default(Session *session, sql_var_t type);
459
459
  SHOW_TYPE show_type() { return SHOW_INT; }
460
 
  unsigned char *value_ptr(Session *session, enum_var_type type,
 
460
  unsigned char *value_ptr(Session *session, sql_var_t type,
461
461
                           const LEX_STRING *base);
462
462
};
463
463
 
476
476
    :sys_var_session(name_arg,func), offset(offset_arg)
477
477
  { chain_sys_var(chain); }
478
478
  bool update(Session *session, set_var *var);
479
 
  void set_default(Session *session, enum_var_type type);
 
479
  void set_default(Session *session, sql_var_t type);
480
480
  SHOW_TYPE show_type() { return SHOW_HA_ROWS; }
481
 
  unsigned char *value_ptr(Session *session, enum_var_type type,
 
481
  unsigned char *value_ptr(Session *session, sql_var_t type,
482
482
                           const LEX_STRING *base);
483
483
};
484
484
 
510
510
    only_global(only_global_arg)
511
511
  { chain_sys_var(chain); }
512
512
  bool update(Session *session, set_var *var);
513
 
  void set_default(Session *session, enum_var_type type);
 
513
  void set_default(Session *session, sql_var_t type);
514
514
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
515
 
  unsigned char *value_ptr(Session *session, enum_var_type type,
 
515
  unsigned char *value_ptr(Session *session, sql_var_t type,
516
516
                           const LEX_STRING *base);
517
517
  bool check(Session *session, set_var *var);
518
 
  bool check_default(enum_var_type type)
 
518
  bool check_default(sql_var_t type)
519
519
  {
520
520
    return type == OPT_GLOBAL && !option_limits;
521
521
  }
522
 
  bool check_type(enum_var_type type)
 
522
  bool check_type(sql_var_t type)
523
523
  {
524
524
    return (only_global && type != OPT_GLOBAL);
525
525
  }
551
551
     only_global(only_global_arg)
552
552
  { chain_sys_var(chain); }
553
553
  bool update(Session *session, set_var *var);
554
 
  void set_default(Session *session, enum_var_type type);
 
554
  void set_default(Session *session, sql_var_t type);
555
555
  SHOW_TYPE show_type() { return SHOW_SIZE; }
556
 
  unsigned char *value_ptr(Session *session, enum_var_type type,
 
556
  unsigned char *value_ptr(Session *session, sql_var_t type,
557
557
                           const LEX_STRING *base);
558
558
  bool check(Session *session, set_var *var);
559
 
  bool check_default(enum_var_type type)
 
559
  bool check_default(sql_var_t type)
560
560
  {
561
561
    return type == OPT_GLOBAL && !option_limits;
562
562
  }
563
 
  bool check_type(enum_var_type type)
 
563
  bool check_type(sql_var_t type)
564
564
  {
565
565
    return (only_global && type != OPT_GLOBAL);
566
566
  }
579
579
    :sys_var_session(name_arg,func), offset(offset_arg)
580
580
  { chain_sys_var(chain); }
581
581
  bool update(Session *session, set_var *var);
582
 
  void set_default(Session *session, enum_var_type type);
 
582
  void set_default(Session *session, sql_var_t type);
583
583
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
584
 
  unsigned char *value_ptr(Session *session, enum_var_type type,
 
584
  unsigned char *value_ptr(Session *session, sql_var_t type,
585
585
                           const LEX_STRING *base);
586
586
  bool check(Session *session, set_var *var)
587
587
  {
614
614
    return ret ? ret : check_enum(session, var, enum_names);
615
615
  }
616
616
  bool update(Session *session, set_var *var);
617
 
  void set_default(Session *session, enum_var_type type);
 
617
  void set_default(Session *session, sql_var_t type);
618
618
  SHOW_TYPE show_type() { return SHOW_CHAR; }
619
 
  unsigned char *value_ptr(Session *session, enum_var_type type,
 
619
  unsigned char *value_ptr(Session *session, sql_var_t type,
620
620
                           const LEX_STRING *base);
621
621
  bool check_update_type(Item_result)
622
622
  { return 0; }
638
638
  {
639
639
    return type != STRING_RESULT;               /* Only accept strings */
640
640
  }
641
 
  void set_default(Session *session, enum_var_type type);
 
641
  void set_default(Session *session, sql_var_t type);
642
642
  bool update(Session *session, set_var *var);
643
 
  unsigned char *value_ptr(Session *session, enum_var_type type,
 
643
  unsigned char *value_ptr(Session *session, sql_var_t type,
644
644
                           const LEX_STRING *base);
645
645
};
646
646
 
661
661
  bool update(Session *session, set_var *var);
662
662
  bool check_update_type(Item_result)
663
663
  { return 0; }
664
 
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
 
664
  bool check_type(sql_var_t type) { return type == OPT_GLOBAL; }
665
665
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
666
 
  unsigned char *value_ptr(Session *session, enum_var_type type,
 
666
  unsigned char *value_ptr(Session *session, sql_var_t type,
667
667
                           const LEX_STRING *base);
668
668
};
669
669
 
676
676
    :sys_var(name_arg, NULL)
677
677
  { chain_sys_var(chain); }
678
678
  bool update(Session *session, set_var *var);
679
 
  void set_default(Session *session, enum_var_type type);
680
 
  bool check_type(enum_var_type type)    { return type == OPT_GLOBAL; }
681
 
  bool check_default(enum_var_type)
 
679
  void set_default(Session *session, sql_var_t type);
 
680
  bool check_type(sql_var_t type)    { return type == OPT_GLOBAL; }
 
681
  bool check_default(sql_var_t)
682
682
  { return 0; }
683
683
  SHOW_TYPE show_type(void) { return SHOW_LONG; }
684
 
  unsigned char *value_ptr(Session *session, enum_var_type type,
 
684
  unsigned char *value_ptr(Session *session, sql_var_t type,
685
685
                           const LEX_STRING *base);
686
686
};
687
687
 
693
693
    :sys_var(name_arg, NULL)
694
694
  { chain_sys_var(chain); }
695
695
  bool update(Session *session, set_var *var);
696
 
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
 
696
  bool check_type(sql_var_t type) { return type == OPT_GLOBAL; }
697
697
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
698
 
  unsigned char *value_ptr(Session *session, enum_var_type type,
 
698
  unsigned char *value_ptr(Session *session, sql_var_t type,
699
699
                           const LEX_STRING *base);
700
700
};
701
701
 
712
712
  {
713
713
    return ((type != STRING_RESULT) && (type != INT_RESULT));
714
714
  }
715
 
  bool check_default(enum_var_type) { return 0; }
716
 
  virtual void set_default(Session *session, enum_var_type type)= 0;
 
715
  bool check_default(sql_var_t) { return 0; }
 
716
  virtual void set_default(Session *session, sql_var_t type)= 0;
717
717
};
718
718
 
719
719
class sys_var_collation_sv :public sys_var_collation
730
730
    chain_sys_var(chain);
731
731
  }
732
732
  bool update(Session *session, set_var *var);
733
 
  void set_default(Session *session, enum_var_type type);
734
 
  unsigned char *value_ptr(Session *session, enum_var_type type,
 
733
  void set_default(Session *session, sql_var_t type);
 
734
  unsigned char *value_ptr(Session *session, sql_var_t type,
735
735
                           const LEX_STRING *base);
736
736
};
737
737
 
740
740
class sys_var_readonly: public sys_var
741
741
{
742
742
public:
743
 
  enum_var_type var_type;
 
743
  sql_var_t var_type;
744
744
  SHOW_TYPE show_type_value;
745
745
  sys_value_ptr_func value_ptr_func;
746
 
  sys_var_readonly(sys_var_chain *chain, const char *name_arg, enum_var_type type,
 
746
  sys_var_readonly(sys_var_chain *chain, const char *name_arg, sql_var_t type,
747
747
                   SHOW_TYPE show_type_arg,
748
748
                   sys_value_ptr_func value_ptr_func_arg)
749
749
    :sys_var(name_arg), var_type(type),
751
751
  { chain_sys_var(chain); }
752
752
  bool update(Session *, set_var *)
753
753
  { return 1; }
754
 
  bool check_default(enum_var_type)
 
754
  bool check_default(sql_var_t)
755
755
  { return 1; }
756
 
  bool check_type(enum_var_type type) { return type != var_type; }
 
756
  bool check_type(sql_var_t type) { return type != var_type; }
757
757
  bool check_update_type(Item_result)
758
758
  { return 1; }
759
 
  unsigned char *value_ptr(Session *session, enum_var_type,
 
759
  unsigned char *value_ptr(Session *session, sql_var_t,
760
760
                           const LEX_STRING *)
761
761
  {
762
762
    return (*value_ptr_func)(session);
780
780
  {
781
781
    return type != STRING_RESULT;               /* Only accept strings */
782
782
  }
783
 
  bool check_default(enum_var_type)
 
783
  bool check_default(sql_var_t)
784
784
  { return 0; }
785
785
  bool update(Session *session, set_var *var);
786
 
  unsigned char *value_ptr(Session *session, enum_var_type type,
 
786
  unsigned char *value_ptr(Session *session, sql_var_t type,
787
787
                           const LEX_STRING *base);
788
 
  virtual void set_default(Session *session, enum_var_type type);
 
788
  virtual void set_default(Session *session, sql_var_t type);
789
789
};
790
790
 
791
791
 
799
799
  { chain_sys_var(chain); }
800
800
  bool check(Session *, set_var *) {return 0;}
801
801
  bool update(Session *session, set_var *var);
802
 
  void set_default(Session *session, enum_var_type type);
 
802
  void set_default(Session *session, sql_var_t type);
803
803
  SHOW_TYPE show_type() { return SHOW_DOUBLE; }
804
804
  bool check_update_type(Item_result type)
805
805
  {
821
821
  {
822
822
    return ((type != STRING_RESULT) && (type != INT_RESULT));
823
823
  }
824
 
  bool check_default(enum_var_type)
 
824
  bool check_default(sql_var_t)
825
825
  { return 0; }
826
826
  bool update(Session *session, set_var *var);
827
 
  unsigned char *value_ptr(Session *session, enum_var_type type,
 
827
  unsigned char *value_ptr(Session *session, sql_var_t type,
828
828
                           const LEX_STRING *base);
829
 
  virtual void set_default(Session *session, enum_var_type type);
 
829
  virtual void set_default(Session *session, sql_var_t type);
830
830
};
831
831
 
832
832
 
850
850
public:
851
851
  sys_var *var;
852
852
  Item *value;
853
 
  enum_var_type type;
 
853
  sql_var_t type;
854
854
  union
855
855
  {
856
856
    const CHARSET_INFO *charset;
863
863
  } save_result;
864
864
  LEX_STRING base;                      /* for structs */
865
865
 
866
 
  set_var(enum_var_type type_arg, sys_var *var_arg,
 
866
  set_var(sql_var_t type_arg, sys_var *var_arg,
867
867
          const LEX_STRING *base_name_arg, Item *value_arg)
868
868
    :var(var_arg), type(type_arg), base(*base_name_arg)
869
869
  {