← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sys_var.h

  • Committer: Stewart Smith
  • Date: 2010-11-03 03:29:48 UTC
  • mto: (1902.1.1 build) (1910.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 1903.
  • Revision ID: stewart@flamingspork.com-20101103032948-ocaksrku0oqxw8aa
fix more docs warnings: underline/overline too short

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sys_var.h
23
23
#include <string>
24
24
#include <boost/filesystem.hpp>
25
25
 
 
26
/*
 
27
#include "drizzled/function/func.h"
 
28
#include "drizzled/function/set_user_var.h"
 
29
#include "drizzled/item/string.h"
 
30
#include "drizzled/item/field.h"
 
31
*/
26
32
#include "drizzled/constrained_value.h"
27
33
#include "drizzled/set_var.h"
28
34
#include "drizzled/show_type.h"
36
42
{
37
43
 
38
44
class sys_var;
 
45
class sys_var_pluginvar; /* opaque */
39
46
class Time_zone;
40
47
typedef struct my_locale_st MY_LOCALE;
41
48
 
89
96
{
90
97
protected:
91
98
  std::string name; /**< The name of the variable */
92
 
  sys_check_func check_func;
93
99
  sys_after_update_func after_update; /**< Function pointer triggered after the variable's value is updated */
94
100
  struct option *option_limits; /**< Updated by by sys_var_init() */
95
101
  bool m_allow_empty_value; /**< Does variable allow an empty value? */
96
102
public:
97
 
  sys_var(const std::string &name_arg,
98
 
          sys_after_update_func func= NULL,
99
 
          sys_check_func check_func_arg= NULL)
 
103
  sys_var(const std::string name_arg, sys_after_update_func func= NULL)
100
104
    :
101
105
    name(name_arg),
102
 
    check_func(check_func_arg),
103
106
    after_update(func),
104
 
    option_limits(NULL),
105
107
    m_allow_empty_value(true)
106
108
  {}
107
109
  virtual ~sys_var() {}
183
185
  {
184
186
    return 0;
185
187
  }
 
188
  virtual sys_var_pluginvar *cast_pluginvar()
 
189
  {
 
190
    return 0;
 
191
  }
186
192
};
187
193
 
188
194
/**
224
230
  { return (unsigned char*) value; }
225
231
};
226
232
 
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
233
 
249
234
class sys_var_uint64_t_ptr :public sys_var
250
235
{
251
236
  uint64_t *value;
252
 
  const uint64_t default_value;
253
 
  bool have_default_value;
254
237
public:
255
 
  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg) :
256
 
    sys_var(name_arg),
257
 
    value(value_ptr_arg),
258
 
    default_value(0),
259
 
    have_default_value(false)
260
 
  {  }
261
 
 
262
 
  sys_var_uint64_t_ptr(const char *name_arg,
263
 
                       uint64_t *value_ptr_arg,
264
 
                       const uint64_t default_value_in) :
265
 
    sys_var(name_arg),
266
 
    value(value_ptr_arg),
267
 
    default_value(default_value_in),
268
 
    have_default_value(true)
269
 
  {  }
270
 
 
271
 
  sys_var_uint64_t_ptr(const char *name_arg,
272
 
                       uint64_t *value_ptr_arg,
273
 
                       sys_after_update_func func) :
274
 
    sys_var(name_arg,func),
275
 
    value(value_ptr_arg),
276
 
    default_value(0),
277
 
    have_default_value(false)
278
 
  {  }
279
 
 
280
 
  sys_var_uint64_t_ptr(const char *name_arg,
281
 
                       uint64_t *value_ptr_arg,
282
 
                       sys_after_update_func func,
283
 
                       const uint64_t default_value_in) :
284
 
    sys_var(name_arg,func),
285
 
    value(value_ptr_arg),
286
 
    default_value(default_value_in),
287
 
    have_default_value(true)
288
 
  {  }
289
 
 
 
238
  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg)
 
239
    :sys_var(name_arg),value(value_ptr_arg)
 
240
  {  }
 
241
  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg,
 
242
                       sys_after_update_func func)
 
243
    :sys_var(name_arg,func), value(value_ptr_arg)
 
244
  {  }
290
245
  bool update(Session *session, set_var *var);
291
246
  void set_default(Session *session, sql_var_t type);
292
 
  virtual bool check_default(sql_var_t)
293
 
  {
294
 
    return (not have_default_value) && option_limits == 0;
295
 
  }
296
247
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
297
248
  unsigned char *value_ptr(Session *, sql_var_t,
298
249
                           const LEX_STRING *)
319
270
 
320
271
class sys_var_bool_ptr :public sys_var
321
272
{
322
 
  bool default_value;
323
273
public:
324
274
  bool *value;
325
 
  sys_var_bool_ptr(const std::string &name_arg, bool *value_arg,
326
 
                   sys_after_update_func func= NULL) :
327
 
    sys_var(name_arg, func), default_value(*value_arg), value(value_arg)
328
 
  { }
 
275
  sys_var_bool_ptr(const char *name_arg, bool *value_arg)
 
276
    :sys_var(name_arg),value(value_arg)
 
277
  {  }
329
278
  bool check(Session *session, set_var *var)
330
279
  {
331
280
    return check_enum(session, var, &bool_typelib);
332
281
  }
333
 
  virtual bool check_default(sql_var_t)
334
 
  {
335
 
    return false;
336
 
  }
337
282
  bool update(Session *session, set_var *var);
338
283
  void set_default(Session *session, sql_var_t type);
339
284
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
359
304
public:
360
305
  char *value;                                  // Pointer to allocated string
361
306
  uint32_t value_length;
 
307
  sys_check_func check_func;
362
308
  sys_update_func update_func;
363
309
  sys_set_default_func set_default_func;
364
310
  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)
 
311
              sys_check_func check_func_arg,
 
312
              sys_update_func update_func_arg,
 
313
              sys_set_default_func set_default_func_arg,
 
314
              char *value_arg)
 
315
    :sys_var(name_arg), value(value_arg), check_func(check_func_arg),
 
316
    update_func(update_func_arg),set_default_func(set_default_func_arg)
373
317
  {  }
374
318
  bool check(Session *session, set_var *var);
375
319
  bool update(Session *session, set_var *var)
434
378
  constrained_value<T> &value;
435
379
  T basic_value;
436
380
  T default_value;
 
381
  bool have_default_value;
437
382
public:
438
383
  sys_var_constrained_value(const char *name_arg,
439
384
                            constrained_value<T> &value_arg) :
440
385
    sys_var(name_arg),
441
386
    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())
 
387
    default_value(0),
 
388
    have_default_value(false)
 
389
  { }
 
390
 
 
391
  sys_var_constrained_value(const char *name_arg,
 
392
                            constrained_value<T> &value_arg,
 
393
                            T default_value_arg) :
 
394
    sys_var(name_arg),
 
395
    value(value_arg),
 
396
    default_value(default_value_arg),
 
397
    have_default_value(true)
459
398
  { }
460
399
 
461
400
public:
474
413
 
475
414
  bool check_default(sql_var_t)
476
415
  {
477
 
    return false;
 
416
    return not have_default_value;
478
417
  }
479
418
 
480
419
  void set_default(Session *, sql_var_t)
484
423
 
485
424
  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
486
425
  {
487
 
    basic_value= value.get();
 
426
    basic_value= T(value);
488
427
    return (unsigned char*)&basic_value;
489
428
  }
490
429
};
491
430
 
492
431
template<>
 
432
inline bool sys_var_constrained_value<const uint64_t>::is_readonly() const
 
433
{
 
434
  return true;
 
435
}
 
436
 
 
437
template<>
 
438
inline bool sys_var_constrained_value<const uint32_t>::is_readonly() const
 
439
{
 
440
  return true;
 
441
}
 
442
 
 
443
template<>
493
444
inline SHOW_TYPE sys_var_constrained_value<uint64_t>::show_type()
494
445
{
495
446
  return SHOW_LONGLONG;
504
455
template<>
505
456
inline SHOW_TYPE sys_var_constrained_value<uint32_t>::show_type()
506
457
{
507
 
  return SHOW_INT;
 
458
  return SHOW_LONG;
508
459
}
509
460
 
510
461
template<>
527
478
  return false;
528
479
}
529
480
 
530
 
template<class T>
531
 
class sys_var_constrained_value_readonly :
532
 
  public sys_var_constrained_value<T>
533
 
{
534
 
public:
535
 
  sys_var_constrained_value_readonly(const char *name_arg,
536
 
                                     constrained_value<T> &value_arg) :
537
 
    sys_var_constrained_value<T>(name_arg, value_arg)
538
 
  { }
539
 
 
540
 
  sys_var_constrained_value_readonly(const char *name_arg,
541
 
                                     constrained_value<T> &value_arg,
542
 
                                     T default_value_arg) :
543
 
    sys_var_constrained_value<T>(name_arg, value_arg, default_value_arg)
544
 
  { }
545
 
 
546
 
public:
547
 
  bool is_readonly() const
548
 
  {
549
 
    return true;
550
 
  }
551
 
};
552
 
 
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
 
};
 
481
template<>
 
482
inline unsigned char *sys_var_constrained_value<const uint64_t>::value_ptr(Session *, sql_var_t, const LEX_STRING *)
 
483
{
 
484
  return (unsigned char*)&basic_value;
 
485
}
 
486
 
 
487
template<>
 
488
inline unsigned char *sys_var_constrained_value<const uint32_t>::value_ptr(Session *, sql_var_t, const LEX_STRING *)
 
489
{
 
490
  return (unsigned char*)&basic_value;
 
491
}
609
492
 
610
493
class sys_var_const_string :
611
494
  public sys_var
1157
1040
*/
1158
1041
 
1159
1042
drizzle_show_var* enumerate_sys_vars(Session *session);
 
1043
void drizzle_add_plugin_sysvar(sys_var_pluginvar *var);
 
1044
void drizzle_del_plugin_sysvar();
1160
1045
void add_sys_var_to_list(sys_var *var, struct option *long_options);
1161
1046
void add_sys_var_to_list(sys_var *var);
1162
 
sys_var *find_sys_var(const char *str, uint32_t length=0);
 
1047
sys_var *find_sys_var(Session *session, const char *str, uint32_t length=0);
1163
1048
bool not_all_support_one_shot(List<set_var_base> *var_list);
1164
1049
extern sys_var_session_time_zone sys_time_zone;
1165
1050
extern sys_var_session_bit sys_autocommit;