← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/set_var.h

  • Committer: Monty Taylor
  • Date: 2008-08-05 17:22:51 UTC
  • mto: (266.1.1 codestyle)
  • mto: This revision was merged to the branch mainline in revision 266.
  • Revision ID: monty@inaugust.com-20080805172251-tk91a74duyahmq65
https://launchpad.net/bugs/253310
Carried over longlong->int64_t change to assembler file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/set_var.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
19
 
 
20
 
#ifndef DRIZZLED_ITEM_SET_H
21
 
#define DRIZZLED_ITEM_SET_H
22
 
 
23
 
/* Classes to support the SET command */
24
 
 
25
 
 
26
 
/****************************************************************************
27
 
  Variables that are changable runtime are declared using the
28
 
  following classes
29
 
****************************************************************************/
30
 
 
31
 
class sys_var;
32
 
class set_var;
33
 
class sys_var_pluginvar; /* opaque */
34
 
typedef struct system_variables SV;
35
 
typedef struct my_locale_st MY_LOCALE;
36
 
 
37
 
extern TYPELIB bool_typelib, delay_key_write_typelib, sql_mode_typelib,
38
 
  optimizer_switch_typelib, slave_exec_mode_typelib;
39
 
 
40
 
typedef int (*sys_check_func)(Session *,  set_var *);
41
 
typedef bool (*sys_update_func)(Session *, set_var *);
42
 
typedef void (*sys_after_update_func)(Session *,enum_var_type);
43
 
typedef void (*sys_set_default_func)(Session *, enum_var_type);
44
 
typedef unsigned char *(*sys_value_ptr_func)(Session *session);
45
 
 
46
 
struct sys_var_chain
47
 
{
48
 
  sys_var *first;
49
 
  sys_var *last;
50
 
};
51
 
 
52
 
class sys_var
53
 
{
54
 
public:
55
 
 
56
 
  /**
57
 
    Enumeration type to indicate for a system variable whether it will be written to the binlog or not.
58
 
  */
59
 
  enum Binlog_status_enum
60
 
  {  
61
 
    /* The variable value is not in the binlog. */
62
 
    NOT_IN_BINLOG,
63
 
    /* The value of the @@session variable is in the binlog. */
64
 
    SESSION_VARIABLE_IN_BINLOG
65
 
    /*
66
 
      Currently, no @@global variable is ever in the binlog, so we
67
 
      don't need an enumeration value for that.
68
 
    */
69
 
  };
70
 
 
71
 
  sys_var *next;
72
 
  struct my_option *option_limits;      /* Updated by by set_var_init() */
73
 
  uint32_t name_length;                 /* Updated by by set_var_init() */
74
 
  const char *name;
75
 
 
76
 
  sys_after_update_func after_update;
77
 
  bool no_support_one_shot;
78
 
  sys_var(const char *name_arg, sys_after_update_func func= NULL,
79
 
          Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
80
 
    :name(name_arg), after_update(func), no_support_one_shot(1),
81
 
    binlog_status(binlog_status_arg),
82
 
    m_allow_empty_value(true)
83
 
  {}
84
 
  virtual ~sys_var() {}
85
 
  void chain_sys_var(sys_var_chain *chain_arg)
86
 
  {
87
 
    if (chain_arg->last)
88
 
      chain_arg->last->next= this;
89
 
    else
90
 
      chain_arg->first= this;
91
 
    chain_arg->last= this;
92
 
  }
93
 
  virtual bool check(Session *session, set_var *var);
94
 
  bool check_enum(Session *session, set_var *var, const TYPELIB *enum_names);
95
 
  bool check_set(Session *session, set_var *var, TYPELIB *enum_names);
96
 
  bool is_written_to_binlog(enum_var_type type)
97
 
  {
98
 
    return (type == OPT_SESSION || type == OPT_DEFAULT) &&
99
 
      (binlog_status == SESSION_VARIABLE_IN_BINLOG);
100
 
  }
101
 
  virtual bool update(Session *session, set_var *var)=0;
102
 
  virtual void set_default(Session *session_arg __attribute__((unused)),
103
 
                           enum_var_type type __attribute__((unused)))
104
 
  {}
105
 
  virtual SHOW_TYPE show_type() { return SHOW_UNDEF; }
106
 
  virtual unsigned char *value_ptr(Session *session __attribute__((unused)),
107
 
                           enum_var_type type __attribute__((unused)),
108
 
                           LEX_STRING *base __attribute__((unused)))
109
 
  { return 0; }
110
 
  virtual bool check_type(enum_var_type type)
111
 
  { return type != OPT_GLOBAL; }                /* Error if not GLOBAL */
112
 
  virtual bool check_update_type(Item_result type)
113
 
  { return type != INT_RESULT; }                /* Assume INT */
114
 
  virtual bool check_default(enum_var_type type __attribute__((unused)))
115
 
  { return option_limits == 0; }
116
 
  Item *item(Session *session, enum_var_type type, LEX_STRING *base);
117
 
  virtual bool is_struct() { return 0; }
118
 
  virtual bool is_readonly() const { return 0; }
119
 
  virtual sys_var_pluginvar *cast_pluginvar() { return 0; }
120
 
 
121
 
protected:
122
 
  void set_allow_empty_value(bool allow_empty_value)
123
 
  {
124
 
    m_allow_empty_value= allow_empty_value;
125
 
  }
126
 
 
127
 
private:
128
 
  const Binlog_status_enum binlog_status;
129
 
 
130
 
  bool m_allow_empty_value;
131
 
};
132
 
 
133
 
 
134
 
/*
135
 
  A base class for all variables that require its access to
136
 
  be guarded with a mutex.
137
 
*/
138
 
 
139
 
class sys_var_global: public sys_var
140
 
{
141
 
protected:
142
 
  pthread_mutex_t *guard;
143
 
public:
144
 
  sys_var_global(const char *name_arg, sys_after_update_func after_update_arg,
145
 
                 pthread_mutex_t *guard_arg)
146
 
    :sys_var(name_arg, after_update_arg), guard(guard_arg) {}
147
 
};
148
 
 
149
 
 
150
 
/*
151
 
  A global-only ulong variable that requires its access to be
152
 
  protected with a mutex.
153
 
*/
154
 
 
155
 
class sys_var_long_ptr_global: public sys_var_global
156
 
{
157
 
  ulong *value;
158
 
public:
159
 
  sys_var_long_ptr_global(sys_var_chain *chain, const char *name_arg,
160
 
                          ulong *value_ptr_arg,
161
 
                          pthread_mutex_t *guard_arg,
162
 
                          sys_after_update_func after_update_arg= NULL)
163
 
    :sys_var_global(name_arg, after_update_arg, guard_arg),
164
 
    value(value_ptr_arg)
165
 
  { chain_sys_var(chain); }
166
 
  bool check(Session *session, set_var *var);
167
 
  bool update(Session *session, set_var *var);
168
 
  void set_default(Session *session, enum_var_type type);
169
 
  SHOW_TYPE show_type() { return SHOW_LONG; }
170
 
  unsigned char *value_ptr(Session *session __attribute__((unused)),
171
 
                   enum_var_type type __attribute__((unused)),
172
 
                   LEX_STRING *base __attribute__((unused)))
173
 
  { return (unsigned char*) value; }
174
 
};
175
 
 
176
 
 
177
 
/*
178
 
  A global ulong variable that is protected by LOCK_global_system_variables
179
 
*/
180
 
 
181
 
class sys_var_long_ptr :public sys_var_long_ptr_global
182
 
{
183
 
public:
184
 
  sys_var_long_ptr(sys_var_chain *chain, const char *name_arg, ulong *value_ptr,
185
 
                   sys_after_update_func after_update_arg= NULL);
186
 
};
187
 
 
188
 
 
189
 
class sys_var_uint32_t_ptr :public sys_var
190
 
{
191
 
  uint32_t *value;
192
 
public:
193
 
  sys_var_uint32_t_ptr(sys_var_chain *chain, const char *name_arg,
194
 
                       uint32_t *value_ptr_arg)
195
 
    :sys_var(name_arg),value(value_ptr_arg)
196
 
  { chain_sys_var(chain); }
197
 
  sys_var_uint32_t_ptr(sys_var_chain *chain, const char *name_arg,
198
 
                       uint32_t *value_ptr_arg,
199
 
                       sys_after_update_func func)
200
 
    :sys_var(name_arg,func), value(value_ptr_arg)
201
 
  { chain_sys_var(chain); }
202
 
  bool update(Session *session, set_var *var);
203
 
  void set_default(Session *session, enum_var_type type);
204
 
  SHOW_TYPE show_type() { return SHOW_LONG; }
205
 
  unsigned char *value_ptr(Session *session __attribute__((unused)),
206
 
                   enum_var_type type __attribute__((unused)),
207
 
                   LEX_STRING *base __attribute__((unused)))
208
 
  { return (unsigned char*) value; }
209
 
};
210
 
 
211
 
 
212
 
class sys_var_uint64_t_ptr :public sys_var
213
 
{
214
 
  uint64_t *value;
215
 
public:
216
 
  sys_var_uint64_t_ptr(sys_var_chain *chain, const char *name_arg, uint64_t *value_ptr_arg)
217
 
    :sys_var(name_arg),value(value_ptr_arg)
218
 
  { chain_sys_var(chain); }
219
 
  sys_var_uint64_t_ptr(sys_var_chain *chain, const char *name_arg, uint64_t *value_ptr_arg,
220
 
                       sys_after_update_func func)
221
 
    :sys_var(name_arg,func), value(value_ptr_arg)
222
 
  { chain_sys_var(chain); }
223
 
  bool update(Session *session, set_var *var);
224
 
  void set_default(Session *session, enum_var_type type);
225
 
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
226
 
  unsigned char *value_ptr(Session *session __attribute__((unused)),
227
 
                   enum_var_type type __attribute__((unused)),
228
 
                   LEX_STRING *base __attribute__((unused)))
229
 
  { return (unsigned char*) value; }
230
 
};
231
 
 
232
 
 
233
 
class sys_var_bool_ptr :public sys_var
234
 
{
235
 
public:
236
 
  bool *value;
237
 
  sys_var_bool_ptr(sys_var_chain *chain, const char *name_arg, bool *value_arg)
238
 
    :sys_var(name_arg),value(value_arg)
239
 
  { chain_sys_var(chain); }
240
 
  bool check(Session *session, set_var *var)
241
 
  {
242
 
    return check_enum(session, var, &bool_typelib);
243
 
  }
244
 
  bool update(Session *session, set_var *var);
245
 
  void set_default(Session *session, enum_var_type type);
246
 
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
247
 
  unsigned char *value_ptr(Session *session __attribute__((unused)),
248
 
                   enum_var_type type __attribute__((unused)),
249
 
                   LEX_STRING *base __attribute__((unused)))
250
 
  { return (unsigned char*) value; }
251
 
  bool check_update_type(Item_result type __attribute__((unused)))
252
 
  { return 0; }
253
 
};
254
 
 
255
 
class sys_var_bool_ptr_readonly :public sys_var_bool_ptr
256
 
{
257
 
public:
258
 
  sys_var_bool_ptr_readonly(sys_var_chain *chain, const char *name_arg,
259
 
                            bool *value_arg)
260
 
    :sys_var_bool_ptr(chain, name_arg, value_arg)
261
 
  {}
262
 
  bool is_readonly() const { return 1; }
263
 
};
264
 
 
265
 
 
266
 
class sys_var_str :public sys_var
267
 
{
268
 
public:
269
 
  char *value;                                  // Pointer to allocated string
270
 
  uint32_t value_length;
271
 
  sys_check_func check_func;
272
 
  sys_update_func update_func;
273
 
  sys_set_default_func set_default_func;
274
 
  sys_var_str(sys_var_chain *chain, const char *name_arg,
275
 
              sys_check_func check_func_arg,
276
 
              sys_update_func update_func_arg,
277
 
              sys_set_default_func set_default_func_arg,
278
 
              char *value_arg)
279
 
    :sys_var(name_arg), value(value_arg), check_func(check_func_arg),
280
 
    update_func(update_func_arg),set_default_func(set_default_func_arg)
281
 
  { chain_sys_var(chain); }
282
 
  bool check(Session *session, set_var *var);
283
 
  bool update(Session *session, set_var *var)
284
 
  {
285
 
    return (*update_func)(session, var);
286
 
  }
287
 
  void set_default(Session *session, enum_var_type type)
288
 
  {
289
 
    (*set_default_func)(session, type);
290
 
  }
291
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
292
 
  unsigned char *value_ptr(Session *session __attribute__((unused)),
293
 
                   enum_var_type type __attribute__((unused)),
294
 
                   LEX_STRING *base __attribute__((unused)))
295
 
  { return (unsigned char*) value; }
296
 
  bool check_update_type(Item_result type)
297
 
  {
298
 
    return type != STRING_RESULT;               /* Only accept strings */
299
 
  }
300
 
  bool check_default(enum_var_type type __attribute__((unused)))
301
 
  { return 0; }
302
 
};
303
 
 
304
 
 
305
 
class sys_var_const_str :public sys_var
306
 
{
307
 
  char *value;                                  // Pointer to const value
308
 
public:
309
 
  sys_var_const_str(sys_var_chain *chain, const char *name_arg,
310
 
                    const char *value_arg)
311
 
    :sys_var(name_arg), value((char*) value_arg)
312
 
  { chain_sys_var(chain); }
313
 
  inline void set (char *new_value)
314
 
  {
315
 
    value= new_value;
316
 
  }
317
 
  bool check(Session *session __attribute__((unused)),
318
 
             set_var *var __attribute__((unused)))
319
 
  {
320
 
    return 1;
321
 
  }
322
 
  bool update(Session *session __attribute__((unused)),
323
 
              set_var *var __attribute__((unused)))
324
 
  {
325
 
    return 1;
326
 
  }
327
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
328
 
  unsigned char *value_ptr(Session *session __attribute__((unused)),
329
 
                   enum_var_type type __attribute__((unused)),
330
 
                   LEX_STRING *base __attribute__((unused)))
331
 
  {
332
 
    return (unsigned char*) value;
333
 
  }
334
 
  bool check_update_type(Item_result type __attribute__((unused)))
335
 
  {
336
 
    return 1;
337
 
  }
338
 
  bool check_default(enum_var_type type __attribute__((unused)))
339
 
  { return 1; }
340
 
  bool is_readonly() const { return 1; }
341
 
};
342
 
 
343
 
 
344
 
class sys_var_const_str_ptr :public sys_var
345
 
{
346
 
  char **value;                                 // Pointer to const value
347
 
public:
348
 
  sys_var_const_str_ptr(sys_var_chain *chain, const char *name_arg, char **value_arg)
349
 
    :sys_var(name_arg),value(value_arg)
350
 
  { chain_sys_var(chain); }
351
 
  bool check(Session *session __attribute__((unused)),
352
 
             set_var *var __attribute__((unused)))
353
 
  {
354
 
    return 1;
355
 
  }
356
 
  bool update(Session *session __attribute__((unused)),
357
 
              set_var *var __attribute__((unused)))
358
 
  {
359
 
    return 1;
360
 
  }
361
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
362
 
  unsigned char *value_ptr(Session *session __attribute__((unused)),
363
 
                   enum_var_type type __attribute__((unused)),
364
 
                   LEX_STRING *base __attribute__((unused)))
365
 
  {
366
 
    return (unsigned char*) *value;
367
 
  }
368
 
  bool check_update_type(Item_result type __attribute__((unused)))
369
 
  {
370
 
    return 1;
371
 
  }
372
 
  bool check_default(enum_var_type type __attribute__((unused)))
373
 
  { return 1; }
374
 
  bool is_readonly(void) const { return 1; }
375
 
};
376
 
 
377
 
 
378
 
class sys_var_enum :public sys_var
379
 
{
380
 
  uint32_t *value;
381
 
  TYPELIB *enum_names;
382
 
public:
383
 
  sys_var_enum(sys_var_chain *chain, const char *name_arg, uint32_t *value_arg,
384
 
               TYPELIB *typelib, sys_after_update_func func)
385
 
    :sys_var(name_arg,func), value(value_arg), enum_names(typelib)
386
 
  { chain_sys_var(chain); }
387
 
  bool check(Session *session, set_var *var)
388
 
  {
389
 
    return check_enum(session, var, enum_names);
390
 
  }
391
 
  bool update(Session *session, set_var *var);
392
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
393
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
394
 
  bool check_update_type(Item_result type __attribute__((unused)))
395
 
  { return 0; }
396
 
};
397
 
 
398
 
 
399
 
class sys_var_enum_const :public sys_var
400
 
{
401
 
  ulong SV::*offset;
402
 
  TYPELIB *enum_names;
403
 
public:
404
 
  sys_var_enum_const(sys_var_chain *chain, const char *name_arg, ulong SV::*offset_arg,
405
 
      TYPELIB *typelib, sys_after_update_func func)
406
 
    :sys_var(name_arg,func), offset(offset_arg), enum_names(typelib)
407
 
  { chain_sys_var(chain); }
408
 
  bool check(Session *session __attribute__((unused)),
409
 
             set_var *var __attribute__((unused)))
410
 
  { return 1; }
411
 
  bool update(Session *session __attribute__((unused)),
412
 
              set_var *var __attribute__((unused)))
413
 
  { return 1; }
414
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
415
 
  bool check_update_type(Item_result type __attribute__((unused)))
416
 
  { return 1; }
417
 
  bool is_readonly() const { return 1; }
418
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
419
 
};
420
 
 
421
 
 
422
 
class sys_var_session :public sys_var
423
 
{
424
 
public:
425
 
  sys_var_session(const char *name_arg, 
426
 
              sys_after_update_func func= NULL,
427
 
              Binlog_status_enum binlog_status= NOT_IN_BINLOG)
428
 
    :sys_var(name_arg, func, binlog_status)
429
 
  {}
430
 
  bool check_type(enum_var_type type __attribute__((unused)))
431
 
  { return 0; }
432
 
  bool check_default(enum_var_type type)
433
 
  {
434
 
    return type == OPT_GLOBAL && !option_limits;
435
 
  }
436
 
};
437
 
 
438
 
 
439
 
class sys_var_session_ulong :public sys_var_session
440
 
{
441
 
  sys_check_func check_func;
442
 
public:
443
 
  ulong SV::*offset;
444
 
  sys_var_session_ulong(sys_var_chain *chain, const char *name_arg,
445
 
                    ulong SV::*offset_arg,
446
 
                    sys_check_func c_func= NULL,
447
 
                    sys_after_update_func au_func= NULL,
448
 
                    Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
449
 
    :sys_var_session(name_arg, au_func, binlog_status_arg), check_func(c_func),
450
 
    offset(offset_arg)
451
 
  { chain_sys_var(chain); }
452
 
  bool check(Session *session, set_var *var);
453
 
  bool update(Session *session, set_var *var);
454
 
  void set_default(Session *session, enum_var_type type);
455
 
  SHOW_TYPE show_type() { return SHOW_LONG; }
456
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
457
 
};
458
 
 
459
 
 
460
 
class sys_var_session_ha_rows :public sys_var_session
461
 
{
462
 
public:
463
 
  ha_rows SV::*offset;
464
 
  sys_var_session_ha_rows(sys_var_chain *chain, const char *name_arg, 
465
 
                      ha_rows SV::*offset_arg)
466
 
    :sys_var_session(name_arg), offset(offset_arg)
467
 
  { chain_sys_var(chain); }
468
 
  sys_var_session_ha_rows(sys_var_chain *chain, const char *name_arg, 
469
 
                      ha_rows SV::*offset_arg,
470
 
                      sys_after_update_func func)
471
 
    :sys_var_session(name_arg,func), offset(offset_arg)
472
 
  { chain_sys_var(chain); }
473
 
  bool update(Session *session, set_var *var);
474
 
  void set_default(Session *session, enum_var_type type);
475
 
  SHOW_TYPE show_type() { return SHOW_HA_ROWS; }
476
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
477
 
};
478
 
 
479
 
 
480
 
class sys_var_session_uint64_t :public sys_var_session
481
 
{
482
 
  sys_check_func check_func;
483
 
public:
484
 
  uint64_t SV::*offset;
485
 
  bool only_global;
486
 
  sys_var_session_uint64_t(sys_var_chain *chain, const char *name_arg,
487
 
                           uint64_t SV::*offset_arg,
488
 
                           sys_after_update_func au_func= NULL,
489
 
                           sys_check_func c_func= NULL,
490
 
                           Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
491
 
        :sys_var_session(name_arg, au_func, binlog_status_arg),
492
 
         check_func(c_func),
493
 
         offset(offset_arg)
494
 
            { chain_sys_var(chain); }
495
 
  sys_var_session_uint64_t(sys_var_chain *chain, const char *name_arg, 
496
 
                        uint64_t SV::*offset_arg, 
497
 
                        sys_after_update_func func, bool only_global_arg,
498
 
      sys_check_func cfunc= NULL)
499
 
    :sys_var_session(name_arg, func),
500
 
    check_func(cfunc),
501
 
    offset(offset_arg),
502
 
    only_global(only_global_arg)
503
 
  { chain_sys_var(chain); }
504
 
  bool update(Session *session, set_var *var);
505
 
  void set_default(Session *session, enum_var_type type);
506
 
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
507
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
508
 
  bool check(Session *session, set_var *var);
509
 
  bool check_default(enum_var_type type)
510
 
  {
511
 
    return type == OPT_GLOBAL && !option_limits;
512
 
  }
513
 
  bool check_type(enum_var_type type)
514
 
  {
515
 
    return (only_global && type != OPT_GLOBAL);
516
 
  }
517
 
};
518
 
 
519
 
 
520
 
class sys_var_session_bool :public sys_var_session
521
 
{
522
 
public:
523
 
  bool SV::*offset;
524
 
  sys_var_session_bool(sys_var_chain *chain, const char *name_arg, bool SV::*offset_arg)
525
 
    :sys_var_session(name_arg), offset(offset_arg)
526
 
  { chain_sys_var(chain); }
527
 
  sys_var_session_bool(sys_var_chain *chain, const char *name_arg, bool SV::*offset_arg,
528
 
                   sys_after_update_func func)
529
 
    :sys_var_session(name_arg,func), offset(offset_arg)
530
 
  { chain_sys_var(chain); }
531
 
  bool update(Session *session, set_var *var);
532
 
  void set_default(Session *session, enum_var_type type);
533
 
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
534
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
535
 
  bool check(Session *session, set_var *var)
536
 
  {
537
 
    return check_enum(session, var, &bool_typelib);
538
 
  }
539
 
  bool check_update_type(Item_result type __attribute__((unused)))
540
 
  { return 0; }
541
 
};
542
 
 
543
 
 
544
 
class sys_var_session_enum :public sys_var_session
545
 
{
546
 
protected:
547
 
  ulong SV::*offset;
548
 
  TYPELIB *enum_names;
549
 
  sys_check_func check_func;
550
 
public:
551
 
  sys_var_session_enum(sys_var_chain *chain, const char *name_arg,
552
 
                   ulong SV::*offset_arg, TYPELIB *typelib,
553
 
                   sys_after_update_func func= NULL,
554
 
                   sys_check_func check= NULL)
555
 
    :sys_var_session(name_arg, func), offset(offset_arg),
556
 
    enum_names(typelib), check_func(check)
557
 
  { chain_sys_var(chain); }
558
 
  bool check(Session *session, set_var *var)
559
 
  {
560
 
    int ret= 0;
561
 
    if (check_func)
562
 
      ret= (*check_func)(session, var);
563
 
    return ret ? ret : check_enum(session, var, enum_names);
564
 
  }
565
 
  bool update(Session *session, set_var *var);
566
 
  void set_default(Session *session, enum_var_type type);
567
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
568
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
569
 
  bool check_update_type(Item_result type __attribute__((unused)))
570
 
  { return 0; }
571
 
};
572
 
 
573
 
 
574
 
 
575
 
class sys_var_session_optimizer_switch :public sys_var_session_enum
576
 
{
577
 
public:
578
 
  sys_var_session_optimizer_switch(sys_var_chain *chain, const char *name_arg, 
579
 
                               ulong SV::*offset_arg)
580
 
    :sys_var_session_enum(chain, name_arg, offset_arg, &optimizer_switch_typelib)
581
 
  {}
582
 
  bool check(Session *session, set_var *var)
583
 
  {
584
 
    return check_set(session, var, enum_names);
585
 
  }
586
 
  void set_default(Session *session, enum_var_type type);
587
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
588
 
  static bool symbolic_mode_representation(Session *session, uint64_t sql_mode,
589
 
                                           LEX_STRING *rep);
590
 
};
591
 
 
592
 
 
593
 
class sys_var_session_storage_engine :public sys_var_session
594
 
{
595
 
protected:
596
 
  plugin_ref SV::*offset;
597
 
public:
598
 
  sys_var_session_storage_engine(sys_var_chain *chain, const char *name_arg, 
599
 
                             plugin_ref SV::*offset_arg)
600
 
    :sys_var_session(name_arg), offset(offset_arg)
601
 
  { chain_sys_var(chain); }
602
 
  bool check(Session *session, set_var *var);
603
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
604
 
  bool check_update_type(Item_result type)
605
 
  {
606
 
    return type != STRING_RESULT;               /* Only accept strings */
607
 
  }
608
 
  void set_default(Session *session, enum_var_type type);
609
 
  bool update(Session *session, set_var *var);
610
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
611
 
};
612
 
 
613
 
class sys_var_session_bit :public sys_var_session
614
 
{
615
 
  sys_check_func check_func;
616
 
  sys_update_func update_func;
617
 
public:
618
 
  uint64_t bit_flag;
619
 
  bool reverse;
620
 
  sys_var_session_bit(sys_var_chain *chain, const char *name_arg,
621
 
                  sys_check_func c_func, sys_update_func u_func,
622
 
                  uint64_t bit, bool reverse_arg=0,
623
 
                  Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
624
 
    :sys_var_session(name_arg, NULL, binlog_status_arg), check_func(c_func),
625
 
    update_func(u_func), bit_flag(bit), reverse(reverse_arg)
626
 
  { chain_sys_var(chain); }
627
 
  bool check(Session *session, set_var *var);
628
 
  bool update(Session *session, set_var *var);
629
 
  bool check_update_type(Item_result type __attribute__((unused)))
630
 
  { return 0; }
631
 
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
632
 
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
633
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
634
 
};
635
 
 
636
 
/* some variables that require special handling */
637
 
 
638
 
class sys_var_timestamp :public sys_var
639
 
{
640
 
public:
641
 
  sys_var_timestamp(sys_var_chain *chain, const char *name_arg,
642
 
                    Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
643
 
    :sys_var(name_arg, NULL, binlog_status_arg)
644
 
  { chain_sys_var(chain); }
645
 
  bool update(Session *session, set_var *var);
646
 
  void set_default(Session *session, enum_var_type type);
647
 
  bool check_type(enum_var_type type)    { return type == OPT_GLOBAL; }
648
 
  bool check_default(enum_var_type type __attribute__((unused)))
649
 
  { return 0; }
650
 
  SHOW_TYPE show_type(void) { return SHOW_LONG; }
651
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
652
 
};
653
 
 
654
 
 
655
 
class sys_var_last_insert_id :public sys_var
656
 
{
657
 
public:
658
 
  sys_var_last_insert_id(sys_var_chain *chain, const char *name_arg,
659
 
                         Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
660
 
    :sys_var(name_arg, NULL, binlog_status_arg)
661
 
  { chain_sys_var(chain); }
662
 
  bool update(Session *session, set_var *var);
663
 
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
664
 
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
665
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
666
 
};
667
 
 
668
 
 
669
 
class sys_var_insert_id :public sys_var
670
 
{
671
 
public:
672
 
  sys_var_insert_id(sys_var_chain *chain, const char *name_arg)
673
 
    :sys_var(name_arg)
674
 
  { chain_sys_var(chain); }
675
 
  bool update(Session *session, set_var *var);
676
 
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
677
 
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
678
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
679
 
};
680
 
 
681
 
 
682
 
class sys_var_rand_seed1 :public sys_var
683
 
{
684
 
public:
685
 
  sys_var_rand_seed1(sys_var_chain *chain, const char *name_arg,
686
 
                     Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
687
 
    :sys_var(name_arg, NULL, binlog_status_arg)
688
 
  { chain_sys_var(chain); }
689
 
  bool update(Session *session, set_var *var);
690
 
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
691
 
};
692
 
 
693
 
class sys_var_rand_seed2 :public sys_var
694
 
{
695
 
public:
696
 
  sys_var_rand_seed2(sys_var_chain *chain, const char *name_arg,
697
 
                     Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
698
 
    :sys_var(name_arg, NULL, binlog_status_arg)
699
 
  { chain_sys_var(chain); }
700
 
  bool update(Session *session, set_var *var);
701
 
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
702
 
};
703
 
 
704
 
 
705
 
class sys_var_collation :public sys_var_session
706
 
{
707
 
public:
708
 
  sys_var_collation(const char *name_arg,
709
 
                    Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
710
 
    :sys_var_session(name_arg, NULL, binlog_status_arg)
711
 
  {
712
 
    no_support_one_shot= 0;
713
 
  }
714
 
  bool check(Session *session, set_var *var);
715
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
716
 
  bool check_update_type(Item_result type)
717
 
  {
718
 
    return ((type != STRING_RESULT) && (type != INT_RESULT));
719
 
  }
720
 
  bool check_default(enum_var_type type __attribute__((unused))) { return 0; }
721
 
  virtual void set_default(Session *session, enum_var_type type)= 0;
722
 
};
723
 
 
724
 
class sys_var_character_set :public sys_var_session
725
 
{
726
 
public:
727
 
  bool nullable;
728
 
  sys_var_character_set(const char *name_arg, bool is_nullable= 0,
729
 
                        Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
730
 
    :sys_var_session(name_arg, NULL, binlog_status_arg), nullable(is_nullable)
731
 
  {
732
 
    /*
733
 
      In fact only almost all variables derived from sys_var_character_set
734
 
      support ONE_SHOT; character_set_results doesn't. But that's good enough.
735
 
    */
736
 
    no_support_one_shot= 0;
737
 
  }
738
 
  bool check(Session *session, set_var *var);
739
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
740
 
  bool check_update_type(Item_result type)
741
 
  {
742
 
    return ((type != STRING_RESULT) && (type != INT_RESULT));
743
 
  }
744
 
  bool check_default(enum_var_type type __attribute__((unused)))
745
 
  { return 0; }
746
 
  bool update(Session *session, set_var *var);
747
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
748
 
  virtual void set_default(Session *session, enum_var_type type)= 0;
749
 
  virtual const CHARSET_INFO **ci_ptr(Session *session, enum_var_type type)= 0;
750
 
};
751
 
 
752
 
class sys_var_collation_sv :public sys_var_collation
753
 
{
754
 
  const CHARSET_INFO *SV::*offset;
755
 
  const CHARSET_INFO **global_default;
756
 
public:
757
 
  sys_var_collation_sv(sys_var_chain *chain, const char *name_arg,
758
 
                       const CHARSET_INFO *SV::*offset_arg,
759
 
                       const CHARSET_INFO **global_default_arg,
760
 
                       Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
761
 
    :sys_var_collation(name_arg, binlog_status_arg),
762
 
    offset(offset_arg), global_default(global_default_arg)
763
 
  {
764
 
    chain_sys_var(chain);
765
 
  }
766
 
  bool update(Session *session, set_var *var);
767
 
  void set_default(Session *session, enum_var_type type);
768
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
769
 
};
770
 
 
771
 
 
772
 
class sys_var_key_cache_param :public sys_var
773
 
{
774
 
protected:
775
 
  size_t offset;
776
 
public:
777
 
  sys_var_key_cache_param(sys_var_chain *chain, const char *name_arg, 
778
 
                          size_t offset_arg)
779
 
    :sys_var(name_arg), offset(offset_arg)
780
 
  { chain_sys_var(chain); }
781
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
782
 
  bool check_default(enum_var_type type __attribute__((unused)))
783
 
  { return 1; }
784
 
  bool is_struct() { return 1; }
785
 
};
786
 
 
787
 
 
788
 
class sys_var_key_buffer_size :public sys_var_key_cache_param
789
 
{
790
 
public:
791
 
  sys_var_key_buffer_size(sys_var_chain *chain, const char *name_arg)
792
 
    :sys_var_key_cache_param(chain, name_arg,
793
 
                             offsetof(KEY_CACHE, param_buff_size))
794
 
  {}
795
 
  bool update(Session *session, set_var *var);
796
 
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
797
 
};
798
 
 
799
 
 
800
 
class sys_var_key_cache_long :public sys_var_key_cache_param
801
 
{
802
 
public:
803
 
  sys_var_key_cache_long(sys_var_chain *chain, const char *name_arg, size_t offset_arg)
804
 
    :sys_var_key_cache_param(chain, name_arg, offset_arg)
805
 
  {}
806
 
  bool update(Session *session, set_var *var);
807
 
  SHOW_TYPE show_type() { return SHOW_LONG; }
808
 
};
809
 
 
810
 
 
811
 
class sys_var_session_date_time_format :public sys_var_session
812
 
{
813
 
  DATE_TIME_FORMAT *SV::*offset;
814
 
  enum enum_drizzle_timestamp_type date_time_type;
815
 
public:
816
 
  sys_var_session_date_time_format(sys_var_chain *chain, const char *name_arg,
817
 
                               DATE_TIME_FORMAT *SV::*offset_arg,
818
 
                               enum enum_drizzle_timestamp_type date_time_type_arg)
819
 
    :sys_var_session(name_arg), offset(offset_arg),
820
 
    date_time_type(date_time_type_arg)
821
 
  { chain_sys_var(chain); }
822
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
823
 
  bool check_update_type(Item_result type)
824
 
  {
825
 
    return type != STRING_RESULT;               /* Only accept strings */
826
 
  }
827
 
  bool check_default(enum_var_type type __attribute__((unused)))
828
 
  { return 0; }
829
 
  bool check(Session *session, set_var *var);
830
 
  bool update(Session *session, set_var *var);
831
 
  void update2(Session *session, enum_var_type type, DATE_TIME_FORMAT *new_value);
832
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
833
 
  void set_default(Session *session, enum_var_type type);
834
 
};
835
 
 
836
 
 
837
 
class sys_var_log_state :public sys_var_bool_ptr
838
 
{
839
 
  uint32_t log_type;
840
 
public:
841
 
  sys_var_log_state(sys_var_chain *chain, const char *name_arg, bool *value_arg, 
842
 
                    uint32_t log_type_arg)
843
 
    :sys_var_bool_ptr(chain, name_arg, value_arg), log_type(log_type_arg) {}
844
 
  bool update(Session *session, set_var *var);
845
 
  void set_default(Session *session, enum_var_type type);
846
 
};
847
 
 
848
 
 
849
 
class sys_var_set :public sys_var
850
 
{
851
 
protected:
852
 
  ulong *value;
853
 
  TYPELIB *enum_names;
854
 
public:
855
 
  sys_var_set(sys_var_chain *chain, const char *name_arg, ulong *value_arg,
856
 
              TYPELIB *typelib, sys_after_update_func func)
857
 
    :sys_var(name_arg, func), value(value_arg), enum_names(typelib)
858
 
  { chain_sys_var(chain); }
859
 
  virtual bool check(Session *session, set_var *var)
860
 
  {
861
 
    return check_set(session, var, enum_names);
862
 
  }
863
 
  virtual void set_default(Session *session __attribute__((unused)),
864
 
                           enum_var_type type __attribute__((unused)))
865
 
  {
866
 
    *value= 0;
867
 
  }
868
 
  bool update(Session *session, set_var *var);
869
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
870
 
  bool check_update_type(Item_result type __attribute__((unused)))
871
 
  { return 0; }
872
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
873
 
};
874
 
 
875
 
class sys_var_set_slave_mode :public sys_var_set
876
 
{
877
 
public:
878
 
  sys_var_set_slave_mode(sys_var_chain *chain, const char *name_arg,
879
 
                         ulong *value_arg,
880
 
                         TYPELIB *typelib, sys_after_update_func func) :
881
 
    sys_var_set(chain, name_arg, value_arg, typelib, func) {}
882
 
  void set_default(Session *session, enum_var_type type);
883
 
  bool check(Session *session, set_var *var);
884
 
  bool update(Session *session, set_var *var);
885
 
};
886
 
 
887
 
class sys_var_log_output :public sys_var
888
 
{
889
 
  ulong *value;
890
 
  TYPELIB *enum_names;
891
 
public:
892
 
  sys_var_log_output(sys_var_chain *chain, const char *name_arg, ulong *value_arg,
893
 
                     TYPELIB *typelib, sys_after_update_func func)
894
 
    :sys_var(name_arg,func), value(value_arg), enum_names(typelib)
895
 
  {
896
 
    chain_sys_var(chain);
897
 
    set_allow_empty_value(false);
898
 
  }
899
 
  virtual bool check(Session *session, set_var *var)
900
 
  {
901
 
    return check_set(session, var, enum_names);
902
 
  }
903
 
  bool update(Session *session, set_var *var);
904
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
905
 
  bool check_update_type(Item_result type __attribute__((unused)))
906
 
  { return 0; }
907
 
  void set_default(Session *session, enum_var_type type);
908
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
909
 
};
910
 
 
911
 
 
912
 
/* Variable that you can only read from */
913
 
 
914
 
class sys_var_readonly: public sys_var
915
 
{
916
 
public:
917
 
  enum_var_type var_type;
918
 
  SHOW_TYPE show_type_value;
919
 
  sys_value_ptr_func value_ptr_func;
920
 
  sys_var_readonly(sys_var_chain *chain, const char *name_arg, enum_var_type type,
921
 
                   SHOW_TYPE show_type_arg,
922
 
                   sys_value_ptr_func value_ptr_func_arg)
923
 
    :sys_var(name_arg), var_type(type), 
924
 
       show_type_value(show_type_arg), value_ptr_func(value_ptr_func_arg)
925
 
  { chain_sys_var(chain); }
926
 
  bool update(Session *session __attribute__((unused)),
927
 
              set_var *var __attribute__((unused)))
928
 
  { return 1; }
929
 
  bool check_default(enum_var_type type __attribute__((unused)))
930
 
  { return 1; }
931
 
  bool check_type(enum_var_type type) { return type != var_type; }
932
 
  bool check_update_type(Item_result type __attribute__((unused)))
933
 
  { return 1; }
934
 
  unsigned char *value_ptr(Session *session, enum_var_type type __attribute__((unused)),
935
 
                   LEX_STRING *base __attribute__((unused)))
936
 
  {
937
 
    return (*value_ptr_func)(session);
938
 
  }
939
 
  SHOW_TYPE show_type(void) { return show_type_value; }
940
 
  bool is_readonly(void) const { return 1; }
941
 
};
942
 
 
943
 
 
944
 
class sys_var_have_option: public sys_var
945
 
{
946
 
protected:
947
 
  virtual SHOW_COMP_OPTION get_option() = 0;
948
 
public:
949
 
  sys_var_have_option(sys_var_chain *chain, const char *variable_name):
950
 
    sys_var(variable_name)
951
 
  { chain_sys_var(chain); }
952
 
  unsigned char *value_ptr(Session *session __attribute__((unused)),
953
 
                   enum_var_type type __attribute__((unused)),
954
 
                   LEX_STRING *base __attribute__((unused)))
955
 
  {
956
 
    return (unsigned char*) show_comp_option_name[get_option()];
957
 
  }
958
 
  bool update(Session *session __attribute__((unused)),
959
 
              set_var *var __attribute__((unused))) { return 1; }
960
 
  bool check_default(enum_var_type type __attribute__((unused)))
961
 
  { return 1; }
962
 
  bool check_type(enum_var_type type) { return type != OPT_GLOBAL; }
963
 
  bool check_update_type(Item_result type __attribute__((unused)))
964
 
  { return 1; }
965
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
966
 
  bool is_readonly() const { return 1; }
967
 
};
968
 
 
969
 
 
970
 
class sys_var_have_variable: public sys_var_have_option
971
 
{
972
 
  SHOW_COMP_OPTION *have_variable;
973
 
 
974
 
public:
975
 
  sys_var_have_variable(sys_var_chain *chain, const char *variable_name,
976
 
                        SHOW_COMP_OPTION *have_variable_arg):
977
 
    sys_var_have_option(chain, variable_name),
978
 
    have_variable(have_variable_arg)
979
 
  { }
980
 
  SHOW_COMP_OPTION get_option() { return *have_variable; }
981
 
};
982
 
 
983
 
 
984
 
class sys_var_have_plugin: public sys_var_have_option
985
 
{
986
 
  const char *plugin_name_str;
987
 
  const uint32_t plugin_name_len;
988
 
  const int plugin_type;
989
 
 
990
 
public:
991
 
  sys_var_have_plugin(sys_var_chain *chain, const char *variable_name,
992
 
                      const char *plugin_name_str_arg, uint32_t plugin_name_len_arg, 
993
 
                      int plugin_type_arg):
994
 
    sys_var_have_option(chain, variable_name), 
995
 
    plugin_name_str(plugin_name_str_arg), plugin_name_len(plugin_name_len_arg),
996
 
    plugin_type(plugin_type_arg)
997
 
  { }
998
 
  /* the following method is declared in sql_plugin.cc */
999
 
  SHOW_COMP_OPTION get_option();
1000
 
};
1001
 
 
1002
 
 
1003
 
class sys_var_session_time_zone :public sys_var_session
1004
 
{
1005
 
public:
1006
 
  sys_var_session_time_zone(sys_var_chain *chain, const char *name_arg,
1007
 
                        Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
1008
 
    :sys_var_session(name_arg, NULL, binlog_status_arg)
1009
 
  {
1010
 
    no_support_one_shot= 0;
1011
 
    chain_sys_var(chain);
1012
 
  }
1013
 
  bool check(Session *session, set_var *var);
1014
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1015
 
  bool check_update_type(Item_result type)
1016
 
  {
1017
 
    return type != STRING_RESULT;               /* Only accept strings */
1018
 
  }
1019
 
  bool check_default(enum_var_type type __attribute__((unused)))
1020
 
  { return 0; }
1021
 
  bool update(Session *session, set_var *var);
1022
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
1023
 
  virtual void set_default(Session *session, enum_var_type type);
1024
 
};
1025
 
 
1026
 
 
1027
 
class sys_var_max_user_conn : public sys_var_session
1028
 
{
1029
 
public:
1030
 
  sys_var_max_user_conn(sys_var_chain *chain, const char *name_arg):
1031
 
    sys_var_session(name_arg)
1032
 
  { chain_sys_var(chain); }
1033
 
  bool check(Session *session, set_var *var);
1034
 
  bool update(Session *session, set_var *var);
1035
 
  bool check_default(enum_var_type type)
1036
 
  {
1037
 
    return type != OPT_GLOBAL || !option_limits;
1038
 
  }
1039
 
  void set_default(Session *session, enum_var_type type);
1040
 
  SHOW_TYPE show_type() { return SHOW_INT; }
1041
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
1042
 
};
1043
 
 
1044
 
 
1045
 
class sys_var_microseconds :public sys_var_session
1046
 
{
1047
 
  uint64_t SV::*offset;
1048
 
public:
1049
 
  sys_var_microseconds(sys_var_chain *chain, const char *name_arg,
1050
 
                       uint64_t SV::*offset_arg):
1051
 
    sys_var_session(name_arg), offset(offset_arg)
1052
 
  { chain_sys_var(chain); }
1053
 
  bool check(Session *session __attribute__((unused)),
1054
 
             set_var *var __attribute__((unused))) {return 0;}
1055
 
  bool update(Session *session, set_var *var);
1056
 
  void set_default(Session *session, enum_var_type type);
1057
 
  SHOW_TYPE show_type() { return SHOW_DOUBLE; }
1058
 
  bool check_update_type(Item_result type)
1059
 
  {
1060
 
    return (type != INT_RESULT && type != REAL_RESULT && type != DECIMAL_RESULT);
1061
 
  }
1062
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
1063
 
};
1064
 
 
1065
 
/**
1066
 
  Handler for setting the system variable --read-only.
1067
 
*/
1068
 
 
1069
 
class sys_var_opt_readonly :public sys_var_bool_ptr
1070
 
{
1071
 
public:
1072
 
  sys_var_opt_readonly(sys_var_chain *chain, const char *name_arg, 
1073
 
                       bool *value_arg) :
1074
 
    sys_var_bool_ptr(chain, name_arg, value_arg) {};
1075
 
  ~sys_var_opt_readonly() {};
1076
 
  bool update(Session *session, set_var *var);
1077
 
};
1078
 
 
1079
 
 
1080
 
class sys_var_session_lc_time_names :public sys_var_session
1081
 
{
1082
 
public:
1083
 
  sys_var_session_lc_time_names(sys_var_chain *chain, const char *name_arg,
1084
 
                            Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
1085
 
    : sys_var_session(name_arg, NULL, binlog_status_arg)
1086
 
  {
1087
 
    chain_sys_var(chain);
1088
 
  }
1089
 
  bool check(Session *session, set_var *var);
1090
 
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1091
 
  bool check_update_type(Item_result type)
1092
 
  {
1093
 
    return ((type != STRING_RESULT) && (type != INT_RESULT));
1094
 
  }
1095
 
  bool check_default(enum_var_type type __attribute__((unused)))
1096
 
  { return 0; }
1097
 
  bool update(Session *session, set_var *var);
1098
 
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
1099
 
  virtual void set_default(Session *session, enum_var_type type);
1100
 
};
1101
 
 
1102
 
 
1103
 
extern void fix_binlog_format_after_update(Session *session, enum_var_type type);
1104
 
 
1105
 
class sys_var_session_binlog_format :public sys_var_session_enum
1106
 
{
1107
 
public:
1108
 
  sys_var_session_binlog_format(sys_var_chain *chain, const char *name_arg, 
1109
 
                            ulong SV::*offset_arg)
1110
 
    :sys_var_session_enum(chain, name_arg, offset_arg,
1111
 
                      &binlog_format_typelib,
1112
 
                      fix_binlog_format_after_update)
1113
 
  {};
1114
 
  bool is_readonly() const;
1115
 
};
1116
 
 
1117
 
/****************************************************************************
1118
 
  Classes for parsing of the SET command
1119
 
****************************************************************************/
1120
 
 
1121
 
class set_var_base :public Sql_alloc
1122
 
{
1123
 
public:
1124
 
  set_var_base() {}
1125
 
  virtual ~set_var_base() {}
1126
 
  virtual int check(Session *session)=0;        /* To check privileges etc. */
1127
 
  virtual int update(Session *session)=0;       /* To set the value */
1128
 
  /* light check for PS */
1129
 
  virtual bool no_support_one_shot() { return 1; }
1130
 
};
1131
 
 
1132
 
 
1133
 
/* MySQL internal variables */
1134
 
 
1135
 
class set_var :public set_var_base
1136
 
{
1137
 
public:
1138
 
  sys_var *var;
1139
 
  Item *value;
1140
 
  enum_var_type type;
1141
 
  union
1142
 
  {
1143
 
    const CHARSET_INFO *charset;
1144
 
    uint32_t uint32_t_value;
1145
 
    uint64_t uint64_t_value;
1146
 
    plugin_ref plugin;
1147
 
    DATE_TIME_FORMAT *date_time_format;
1148
 
    Time_zone *time_zone;
1149
 
    MY_LOCALE *locale_value;
1150
 
  } save_result;
1151
 
  LEX_STRING base;                      /* for structs */
1152
 
 
1153
 
  set_var(enum_var_type type_arg, sys_var *var_arg,
1154
 
          const LEX_STRING *base_name_arg, Item *value_arg)
1155
 
    :var(var_arg), type(type_arg), base(*base_name_arg)
1156
 
  {
1157
 
    /*
1158
 
      If the set value is a field, change it to a string to allow things like
1159
 
      SET table_type=MYISAM;
1160
 
    */
1161
 
    if (value_arg && value_arg->type() == Item::FIELD_ITEM)
1162
 
    {
1163
 
      Item_field *item= (Item_field*) value_arg;
1164
 
      if (!(value=new Item_string(item->field_name, 
1165
 
                  (uint) strlen(item->field_name),
1166
 
                                  item->collation.collation)))
1167
 
        value=value_arg;                        /* Give error message later */
1168
 
    }
1169
 
    else
1170
 
      value=value_arg;
1171
 
  }
1172
 
  int check(Session *session);
1173
 
  int update(Session *session);
1174
 
  bool no_support_one_shot() { return var->no_support_one_shot; }
1175
 
};
1176
 
 
1177
 
 
1178
 
/* User variables like @my_own_variable */
1179
 
 
1180
 
class set_var_user: public set_var_base
1181
 
{
1182
 
  Item_func_set_user_var *user_var_item;
1183
 
public:
1184
 
  set_var_user(Item_func_set_user_var *item)
1185
 
    :user_var_item(item)
1186
 
  {}
1187
 
  int check(Session *session);
1188
 
  int update(Session *session);
1189
 
};
1190
 
 
1191
 
/* For SET NAMES and SET CHARACTER SET */
1192
 
 
1193
 
class set_var_collation_client: public set_var_base
1194
 
{
1195
 
  const CHARSET_INFO *character_set_client;
1196
 
  const CHARSET_INFO *character_set_results;
1197
 
  const CHARSET_INFO *collation_connection;
1198
 
public:
1199
 
  set_var_collation_client(const CHARSET_INFO * const client_coll_arg,
1200
 
                           const CHARSET_INFO * const connection_coll_arg,
1201
 
                           const CHARSET_INFO * const result_coll_arg)
1202
 
    :character_set_client(client_coll_arg),
1203
 
     character_set_results(result_coll_arg),
1204
 
     collation_connection(connection_coll_arg)
1205
 
  {}
1206
 
  int check(Session *session);
1207
 
  int update(Session *session);
1208
 
};
1209
 
 
1210
 
 
1211
 
extern "C"
1212
 
{
1213
 
  typedef int (*process_key_cache_t) (const char *, KEY_CACHE *);
1214
 
}
1215
 
 
1216
 
/* Named lists (used for keycaches) */
1217
 
 
1218
 
class NAMED_LIST :public ilink
1219
 
{
1220
 
  const char *name;
1221
 
  uint32_t name_length;
1222
 
public:
1223
 
  unsigned char* data;
1224
 
 
1225
 
  NAMED_LIST(I_List<NAMED_LIST> *links, const char *name_arg,
1226
 
             uint32_t name_length_arg, unsigned char* data_arg)
1227
 
    :name_length(name_length_arg), data(data_arg)
1228
 
  {
1229
 
    name= my_strndup(name_arg, name_length, MYF(MY_WME));
1230
 
    links->push_back(this);
1231
 
  }
1232
 
  inline bool cmp(const char *name_cmp, uint32_t length)
1233
 
  {
1234
 
    return length == name_length && !memcmp(name, name_cmp, length);
1235
 
  }
1236
 
  ~NAMED_LIST()
1237
 
  {
1238
 
    free((unsigned char*) name);
1239
 
  }
1240
 
  friend bool process_key_caches(process_key_cache_t func);
1241
 
  friend void delete_elements(I_List<NAMED_LIST> *list,
1242
 
                              void (*free_element)(const char*, unsigned char*));
1243
 
};
1244
 
 
1245
 
/* updated in sql_acl.cc */
1246
 
 
1247
 
extern sys_var_session_bool sys_old_alter_table;
1248
 
extern LEX_STRING default_key_cache_base;
1249
 
 
1250
 
/* For sql_yacc */
1251
 
struct sys_var_with_base
1252
 
{
1253
 
  sys_var *var;
1254
 
  LEX_STRING base_name;
1255
 
};
1256
 
 
1257
 
/*
1258
 
  Prototypes for helper functions
1259
 
*/
1260
 
 
1261
 
int set_var_init();
1262
 
void set_var_free();
1263
 
int mysql_append_static_vars(const SHOW_VAR *show_vars, uint32_t count);
1264
 
SHOW_VAR* enumerate_sys_vars(Session *session, bool sorted);
1265
 
int mysql_add_sys_var_chain(sys_var *chain, struct my_option *long_options);
1266
 
int mysql_del_sys_var_chain(sys_var *chain);
1267
 
sys_var *find_sys_var(Session *session, const char *str, uint32_t length=0);
1268
 
int sql_set_variables(Session *session, List<set_var_base> *var_list);
1269
 
bool not_all_support_one_shot(List<set_var_base> *var_list);
1270
 
void fix_delay_key_write(Session *session, enum_var_type type);
1271
 
void fix_slave_exec_mode(enum_var_type type);
1272
 
extern sys_var_str sys_init_connect;
1273
 
extern sys_var_str sys_init_slave;
1274
 
extern sys_var_session_time_zone sys_time_zone;
1275
 
extern sys_var_session_bit sys_autocommit;
1276
 
const CHARSET_INFO *get_old_charset_by_name(const char *old_name);
1277
 
unsigned char* find_named(I_List<NAMED_LIST> *list, const char *name, uint32_t length,
1278
 
                NAMED_LIST **found);
1279
 
 
1280
 
extern sys_var_str sys_var_general_log_path, sys_var_slow_log_path;
1281
 
 
1282
 
/* key_cache functions */
1283
 
KEY_CACHE *get_key_cache(LEX_STRING *cache_name);
1284
 
KEY_CACHE *get_or_create_key_cache(const char *name, uint32_t length);
1285
 
void free_key_cache(const char *name, KEY_CACHE *key_cache);
1286
 
bool process_key_caches(process_key_cache_t func);
1287
 
void delete_elements(I_List<NAMED_LIST> *list,
1288
 
                     void (*free_element)(const char*, unsigned char*));
1289
 
 
1290
 
#endif /* DRIZZLED_ITEM_SET_H */