← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sys_var.h

  • Committer: Andrew Hutchings
  • Date: 2010-11-18 13:17:52 UTC
  • mto: (1938.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 1939.
  • Revision ID: andrew@linuxjedi.co.uk-20101118131752-2i9nlxuwzov302ju
https://launchpad.net/bugs/676735
Cleanup after bug fix

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
36
36
{
37
37
 
38
38
class sys_var;
 
39
class sys_var_pluginvar; /* opaque */
39
40
class Time_zone;
40
41
typedef struct my_locale_st MY_LOCALE;
41
42
 
89
90
{
90
91
protected:
91
92
  std::string name; /**< The name of the variable */
92
 
  sys_check_func check_func;
93
93
  sys_after_update_func after_update; /**< Function pointer triggered after the variable's value is updated */
94
94
  struct option *option_limits; /**< Updated by by sys_var_init() */
95
95
  bool m_allow_empty_value; /**< Does variable allow an empty value? */
96
96
public:
97
 
  sys_var(const std::string &name_arg,
98
 
          sys_after_update_func func= NULL,
99
 
          sys_check_func check_func_arg= NULL)
 
97
  sys_var(const std::string &name_arg, sys_after_update_func func= NULL)
100
98
    :
101
99
    name(name_arg),
102
 
    check_func(check_func_arg),
103
100
    after_update(func),
104
101
    option_limits(NULL),
105
102
    m_allow_empty_value(true)
183
180
  {
184
181
    return 0;
185
182
  }
 
183
  virtual sys_var_pluginvar *cast_pluginvar()
 
184
  {
 
185
    return 0;
 
186
  }
186
187
};
187
188
 
188
189
/**
224
225
  { return (unsigned char*) value; }
225
226
};
226
227
 
227
 
class sys_var_uint32_t_ptr_readonly :
228
 
  public sys_var_uint32_t_ptr
229
 
{
230
 
public:
231
 
  sys_var_uint32_t_ptr_readonly(const char *name_arg,
232
 
                                uint32_t *value_ptr_arg) :
233
 
    sys_var_uint32_t_ptr(name_arg, value_ptr_arg)
234
 
  {}
235
 
 
236
 
  sys_var_uint32_t_ptr_readonly(const char *name_arg,
237
 
                                uint32_t *value_ptr_arg,
238
 
                                sys_after_update_func func) :
239
 
    sys_var_uint32_t_ptr(name_arg, value_ptr_arg, func)
240
 
  {}
241
 
 
242
 
  bool is_readonly() const
243
 
  {
244
 
    return true;
245
 
  }
246
 
};
247
 
 
248
228
 
249
229
class sys_var_uint64_t_ptr :public sys_var
250
230
{
319
299
 
320
300
class sys_var_bool_ptr :public sys_var
321
301
{
322
 
  bool default_value;
323
302
public:
324
303
  bool *value;
325
304
  sys_var_bool_ptr(const std::string &name_arg, bool *value_arg,
326
305
                   sys_after_update_func func= NULL) :
327
 
    sys_var(name_arg, func), default_value(*value_arg), value(value_arg)
 
306
    sys_var(name_arg, func), value(value_arg)
328
307
  { }
329
308
  bool check(Session *session, set_var *var)
330
309
  {
331
310
    return check_enum(session, var, &bool_typelib);
332
311
  }
333
 
  virtual bool check_default(sql_var_t)
334
 
  {
335
 
    return false;
336
 
  }
337
312
  bool update(Session *session, set_var *var);
338
313
  void set_default(Session *session, sql_var_t type);
339
314
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
359
334
public:
360
335
  char *value;                                  // Pointer to allocated string
361
336
  uint32_t value_length;
 
337
  sys_check_func check_func;
362
338
  sys_update_func update_func;
363
339
  sys_set_default_func set_default_func;
364
340
  sys_var_str(const char *name_arg,
365
 
              sys_check_func check_func_arg,
366
 
              sys_update_func update_func_arg,
367
 
              sys_set_default_func set_default_func_arg,
368
 
              char *value_arg) :
369
 
    sys_var(name_arg, NULL, check_func_arg),
370
 
    value(value_arg),
371
 
    update_func(update_func_arg),
372
 
    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)
373
347
  {  }
374
348
  bool check(Session *session, set_var *var);
375
349
  bool update(Session *session, set_var *var)
434
408
  constrained_value<T> &value;
435
409
  T basic_value;
436
410
  T default_value;
 
411
  bool have_default_value;
437
412
public:
438
413
  sys_var_constrained_value(const char *name_arg,
439
414
                            constrained_value<T> &value_arg) :
440
415
    sys_var(name_arg),
441
416
    value(value_arg),
442
 
    default_value(value_arg.get())
443
 
  { }
444
 
 
445
 
  sys_var_constrained_value(const char *name_arg,
446
 
                            constrained_value<T> &value_arg,
447
 
                            sys_after_update_func after_update_func_arg) :
448
 
    sys_var(name_arg, after_update_func_arg),
449
 
    value(value_arg),
450
 
    default_value(value_arg.get())
451
 
  { }
452
 
 
453
 
  sys_var_constrained_value(const char *name_arg,
454
 
                            constrained_value<T> &value_arg,
455
 
                            sys_check_func check_func_arg) :
456
 
    sys_var(name_arg, NULL, check_func_arg),
457
 
    value(value_arg),
458
 
    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)
459
428
  { }
460
429
 
461
430
public:
468
437
 
469
438
  bool update(Session *, set_var *var)
470
439
  {
471
 
    value= uint32_t(var->getInteger());
 
440
    value= var->save_result.uint32_t_value;
472
441
    return false;
473
442
  }
474
443
 
475
444
  bool check_default(sql_var_t)
476
445
  {
477
 
    return false;
 
446
    return not have_default_value;
478
447
  }
479
448
 
480
449
  void set_default(Session *, sql_var_t)
484
453
 
485
454
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
486
455
  {
487
 
    basic_value= value.get();
 
456
    basic_value= T(value);
488
457
    return (unsigned char*)&basic_value;
489
458
  }
490
459
};
504
473
template<>
505
474
inline SHOW_TYPE sys_var_constrained_value<uint32_t>::show_type()
506
475
{
507
 
  return SHOW_INT;
 
476
  return SHOW_LONG;
508
477
}
509
478
 
510
479
template<>
516
485
template<>
517
486
inline bool sys_var_constrained_value<uint64_t>::update(Session *, set_var *var)
518
487
{
519
 
  value= var->getInteger();
 
488
  value= var->save_result.uint64_t_value;
520
489
  return false;
521
490
}
522
491
 
523
492
template<>
524
493
inline bool sys_var_constrained_value<uint32_t>::update(Session *, set_var *var)
525
494
{
526
 
  value= uint32_t(var->getInteger());
 
495
  value= var->save_result.uint32_t_value;
527
496
  return false;
528
497
}
529
498
 
550
519
  }
551
520
};
552
521
 
553
 
class sys_var_std_string :
554
 
  public sys_var
555
 
{
556
 
  std::string &value;
557
 
  sys_check_func check_func;
558
 
  sys_update_func update_func;
559
 
  sys_set_default_func set_default_func;
560
 
public:
561
 
  sys_var_std_string(const std::string &name_arg,
562
 
                     std::string &value_arg,
563
 
                     sys_check_func check_func_arg= NULL,
564
 
                     sys_update_func update_func_arg= NULL) :
565
 
    sys_var(name_arg),
566
 
    value(value_arg),
567
 
    check_func(check_func_arg),
568
 
    update_func(update_func_arg)
569
 
  {  }
570
 
 
571
 
  inline void set(char *val_in)
572
 
  {
573
 
    value= val_in; 
574
 
  }
575
 
 
576
 
  void set_check_func(sys_check_func check_func_arg= NULL)
577
 
  {
578
 
    check_func= check_func_arg;
579
 
  }
580
 
 
581
 
  void set_update_func(sys_update_func update_func_arg= NULL)
582
 
  {
583
 
    update_func= update_func_arg;
584
 
  }
585
 
 
586
 
  bool check(Session *session, set_var *var);
587
 
    
588
 
  bool update(Session *session, set_var *var)
589
 
  {
590
 
    if (update_func != NULL)
591
 
    {
592
 
      return (*update_func)(session, var);
593
 
    }
594
 
    return false;
595
 
  }
596
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
597
 
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
598
 
  {
599
 
    return (unsigned char*)(value.c_str());
600
 
  }
601
 
  bool check_update_type(Item_result type)
602
 
  {
603
 
    return type != STRING_RESULT;               /* Only accept strings */
604
 
  }
605
 
  bool check_default(sql_var_t)
606
 
  { return true; }
607
 
  bool is_readonly() const { return false; }
608
 
};
609
 
 
610
522
class sys_var_const_string :
611
523
  public sys_var
612
524
{
946
858
                                 plugin::StorageEngine *drizzle_system_variables::*offset_arg)
947
859
    :sys_var_session(name_arg), offset(offset_arg)
948
860
  {  }
 
861
  bool check(Session *session, set_var *var);
949
862
  SHOW_TYPE show_type() { return SHOW_CHAR; }
950
863
  bool check_update_type(Item_result type)
951
864
  {
1019
932
  sys_var_collation(const char *name_arg)
1020
933
    :sys_var_session(name_arg, NULL)
1021
934
  { }
 
935
  bool check(Session *session, set_var *var);
1022
936
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1023
937
  bool check_update_type(Item_result type)
1024
938
  {
1086
1000
  {
1087
1001
    
1088
1002
  }
 
1003
  bool check(Session *session, set_var *var);
1089
1004
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1090
1005
  bool check_update_type(Item_result type)
1091
1006
  {
1126
1041
  {
1127
1042
    
1128
1043
  }
 
1044
  bool check(Session *session, set_var *var);
1129
1045
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1130
1046
  bool check_update_type(Item_result type)
1131
1047
  {
1153
1069
*/
1154
1070
 
1155
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();
1156
1074
void add_sys_var_to_list(sys_var *var, struct option *long_options);
1157
1075
void add_sys_var_to_list(sys_var *var);
1158
 
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);
1159
1078
extern sys_var_session_time_zone sys_time_zone;
1160
1079
extern sys_var_session_bit sys_autocommit;
1161
1080
const CHARSET_INFO *get_old_charset_by_name(const char *old_name);