← 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-10 18:04:24 UTC
  • mfrom: (1286.1.5 build)
  • Revision ID: brian@gaz-20100210180424-03ypoyifmlc2lgcp
Merge of Brian/Padraig

Show diffs side-by-side

added added

removed removed

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