set_var.h 29 KB
Newer Older
unknown's avatar
unknown committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/* Classes to support the SET command */

19
#ifdef USE_PRAGMA_INTERFACE
unknown's avatar
unknown committed
20 21 22 23 24 25 26 27 28 29 30
#pragma interface			/* gcc class implementation */
#endif

/****************************************************************************
  Variables that are changable runtime are declared using the
  following classes
****************************************************************************/

class sys_var;
class set_var;
typedef struct system_variables SV;
31
extern TYPELIB bool_typelib, delay_key_write_typelib, sql_mode_typelib;
unknown's avatar
unknown committed
32

unknown's avatar
unknown committed
33
typedef int (*sys_check_func)(THD *,  set_var *);
unknown's avatar
unknown committed
34 35 36
typedef bool (*sys_update_func)(THD *, set_var *);
typedef void (*sys_after_update_func)(THD *,enum_var_type);
typedef void (*sys_set_default_func)(THD *, enum_var_type);
37
typedef byte *(*sys_value_ptr_func)(THD *thd);
unknown's avatar
unknown committed
38 39 40 41

class sys_var
{
public:
42 43 44
  static sys_var *first;
  static uint sys_vars;
  sys_var *next;
unknown's avatar
unknown committed
45 46 47
  struct my_option *option_limits;	/* Updated by by set_var_init() */
  uint name_length;			/* Updated by by set_var_init() */
  const char *name;
48
  
unknown's avatar
unknown committed
49
  sys_after_update_func after_update;
50 51 52 53
  bool no_support_one_shot;
  sys_var(const char *name_arg)
    :name(name_arg), after_update(0)
    , no_support_one_shot(1)
54
  { add_sys_var(); }
unknown's avatar
unknown committed
55
  sys_var(const char *name_arg,sys_after_update_func func)
56 57
    :name(name_arg), after_update(func)
    , no_support_one_shot(1)
58
  { add_sys_var(); }
unknown's avatar
unknown committed
59
  virtual ~sys_var() {}
60 61 62 63 64 65
  void add_sys_var()
  {
    next= first;
    first= this;
    sys_vars++;
  }
66
  virtual bool check(THD *thd, set_var *var);
unknown's avatar
unknown committed
67
  bool check_enum(THD *thd, set_var *var, TYPELIB *enum_names);
68
  bool check_set(THD *thd, set_var *var, TYPELIB *enum_names);
unknown's avatar
unknown committed
69 70 71
  virtual bool update(THD *thd, set_var *var)=0;
  virtual void set_default(THD *thd, enum_var_type type) {}
  virtual SHOW_TYPE type() { return SHOW_UNDEF; }
72 73
  virtual byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  { return 0; }
unknown's avatar
unknown committed
74 75 76 77 78 79
  virtual bool check_type(enum_var_type type)
  { return type != OPT_GLOBAL; }		/* Error if not GLOBAL */
  virtual bool check_update_type(Item_result type)
  { return type != INT_RESULT; }		/* Assume INT */
  virtual bool check_default(enum_var_type type)
  { return option_limits == 0; }
80 81
  Item *item(THD *thd, enum_var_type type, LEX_STRING *base);
  virtual bool is_struct() { return 0; }
82
  virtual bool is_readonly() const { return 0; }
unknown's avatar
unknown committed
83 84 85 86 87 88 89 90 91 92 93 94
};


class sys_var_long_ptr :public sys_var
{
public:
  ulong *value;
  sys_var_long_ptr(const char *name_arg, ulong *value_ptr)
    :sys_var(name_arg),value(value_ptr) {}
  sys_var_long_ptr(const char *name_arg, ulong *value_ptr,
		   sys_after_update_func func)
    :sys_var(name_arg,func), value(value_ptr) {}
unknown's avatar
unknown committed
95
  bool check(THD *thd, set_var *var);
unknown's avatar
unknown committed
96 97 98
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  SHOW_TYPE type() { return SHOW_LONG; }
99 100
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  { return (byte*) value; }
unknown's avatar
unknown committed
101 102 103
};


104 105 106 107 108 109 110 111 112 113 114 115
class sys_var_ulonglong_ptr :public sys_var
{
public:
  ulonglong *value;
  sys_var_ulonglong_ptr(const char *name_arg, ulonglong *value_ptr)
    :sys_var(name_arg),value(value_ptr) {}
  sys_var_ulonglong_ptr(const char *name_arg, ulonglong *value_ptr,
		       sys_after_update_func func)
    :sys_var(name_arg,func), value(value_ptr) {}
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  SHOW_TYPE type() { return SHOW_LONGLONG; }
116 117
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  { return (byte*) value; }
118 119 120
};


unknown's avatar
unknown committed
121 122 123 124 125 126 127 128 129 130 131 132 133 134
class sys_var_bool_ptr :public sys_var
{
public:
  my_bool *value;
  sys_var_bool_ptr(const char *name_arg, my_bool *value_arg)
    :sys_var(name_arg),value(value_arg)
  {}
  bool check(THD *thd, set_var *var)
  {
    return check_enum(thd, var, &bool_typelib);
  }
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  SHOW_TYPE type() { return SHOW_MY_BOOL; }
135 136
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  { return (byte*) value; }
unknown's avatar
unknown committed
137 138 139 140 141 142 143 144
  bool check_update_type(Item_result type) { return 0; }
};


class sys_var_str :public sys_var
{
public:
  char *value;					// Pointer to allocated string
unknown's avatar
unknown committed
145
  uint value_length;
unknown's avatar
unknown committed
146 147 148 149 150 151
  sys_check_func check_func;
  sys_update_func update_func;
  sys_set_default_func set_default_func;
  sys_var_str(const char *name_arg,
	      sys_check_func check_func_arg,
	      sys_update_func update_func_arg,
152 153
	      sys_set_default_func set_default_func_arg,
              char *value_arg)
154
    :sys_var(name_arg), value(value_arg), check_func(check_func_arg),
unknown's avatar
unknown committed
155 156
    update_func(update_func_arg),set_default_func(set_default_func_arg)
  {}
unknown's avatar
unknown committed
157
  bool check(THD *thd, set_var *var);
unknown's avatar
unknown committed
158 159 160 161 162 163
  bool update(THD *thd, set_var *var)
  {
    return (*update_func)(thd, var);
  }
  void set_default(THD *thd, enum_var_type type)
  {
164
    (*set_default_func)(thd, type);
unknown's avatar
unknown committed
165 166
  }
  SHOW_TYPE type() { return SHOW_CHAR; }
167 168
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  { return (byte*) value; }
unknown's avatar
unknown committed
169 170 171 172 173 174 175 176
  bool check_update_type(Item_result type)
  {
    return type != STRING_RESULT;		/* Only accept strings */
  }
  bool check_default(enum_var_type type) { return 0; }
};


177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192
class sys_var_const_str :public sys_var
{
public:
  char *value;					// Pointer to const value
  sys_var_const_str(const char *name_arg, const char *value_arg)
    :sys_var(name_arg), value((char*) value_arg)
  {}
  bool check(THD *thd, set_var *var)
  {
    return 1;
  }
  bool update(THD *thd, set_var *var)
  {
    return 1;
  }
  SHOW_TYPE type() { return SHOW_CHAR; }
unknown's avatar
unknown committed
193 194 195 196
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  {
    return (byte*) value;
  }
197 198 199 200 201
  bool check_update_type(Item_result type)
  {
    return 1;
  }
  bool check_default(enum_var_type type) { return 1; }
202
  bool is_readonly() const { return 1; }
203 204 205
};


206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
class sys_var_enum :public sys_var
{
  uint	*value; 
  TYPELIB *enum_names;
public:
  sys_var_enum(const char *name_arg, uint *value_arg,
	       TYPELIB *typelib, sys_after_update_func func)
    :sys_var(name_arg,func), value(value_arg), enum_names(typelib)
  {}
  bool check(THD *thd, set_var *var)
  {
    return check_enum(thd, var, enum_names);
  }
  bool update(THD *thd, set_var *var);
  SHOW_TYPE type() { return SHOW_CHAR; }
221
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
222 223 224 225
  bool check_update_type(Item_result type) { return 0; }
};


unknown's avatar
unknown committed
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
class sys_var_thd :public sys_var
{
public:
  sys_var_thd(const char *name_arg)
    :sys_var(name_arg)
  {}
  sys_var_thd(const char *name_arg, sys_after_update_func func)
    :sys_var(name_arg,func)
  {}
  bool check_type(enum_var_type type) { return 0; }
  bool check_default(enum_var_type type)
  {
    return type == OPT_GLOBAL && !option_limits;
  }
};


class sys_var_thd_ulong :public sys_var_thd
{
245
  sys_check_func check_func;
unknown's avatar
unknown committed
246 247 248
public:
  ulong SV::*offset;
  sys_var_thd_ulong(const char *name_arg, ulong SV::*offset_arg)
249
    :sys_var_thd(name_arg), check_func(0), offset(offset_arg)
unknown's avatar
unknown committed
250 251
  {}
  sys_var_thd_ulong(const char *name_arg, ulong SV::*offset_arg,
252 253
		   sys_check_func c_func, sys_after_update_func au_func)
    :sys_var_thd(name_arg,au_func), check_func(c_func), offset(offset_arg)
unknown's avatar
unknown committed
254
  {}
255
  bool check(THD *thd, set_var *var);
unknown's avatar
unknown committed
256 257 258
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  SHOW_TYPE type() { return SHOW_LONG; }
259
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
unknown's avatar
unknown committed
260 261 262
};


263 264 265 266 267 268 269 270 271 272 273 274 275 276
class sys_var_thd_ha_rows :public sys_var_thd
{
public:
  ha_rows SV::*offset;
  sys_var_thd_ha_rows(const char *name_arg, ha_rows SV::*offset_arg)
    :sys_var_thd(name_arg), offset(offset_arg)
  {}
  sys_var_thd_ha_rows(const char *name_arg, ha_rows SV::*offset_arg,
		      sys_after_update_func func)
    :sys_var_thd(name_arg,func), offset(offset_arg)
  {}
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  SHOW_TYPE type() { return SHOW_HA_ROWS; }
277
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
278 279 280
};


unknown's avatar
unknown committed
281 282 283 284
class sys_var_thd_ulonglong :public sys_var_thd
{
public:
  ulonglong SV::*offset;
285
  bool only_global;
unknown's avatar
unknown committed
286 287 288
  sys_var_thd_ulonglong(const char *name_arg, ulonglong SV::*offset_arg)
    :sys_var_thd(name_arg), offset(offset_arg)
  {}
289
  sys_var_thd_ulonglong(const char *name_arg, ulonglong SV::*offset_arg,
290 291 292
			sys_after_update_func func, bool only_global_arg)
    :sys_var_thd(name_arg, func), offset(offset_arg),
    only_global(only_global_arg)
293
  {}
unknown's avatar
unknown committed
294 295 296
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  SHOW_TYPE type() { return SHOW_LONGLONG; }
297
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
298 299 300 301 302 303 304 305
  bool check_default(enum_var_type type)
  {
    return type == OPT_GLOBAL && !option_limits;
  }
  bool check_type(enum_var_type type)
  {
    return (only_global && type != OPT_GLOBAL);
  }
unknown's avatar
unknown committed
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
};


class sys_var_thd_bool :public sys_var_thd
{
public:
  my_bool SV::*offset;
  sys_var_thd_bool(const char *name_arg, my_bool SV::*offset_arg)
    :sys_var_thd(name_arg), offset(offset_arg)
  {}
  sys_var_thd_bool(const char *name_arg, my_bool SV::*offset_arg,
		   sys_after_update_func func)
    :sys_var_thd(name_arg,func), offset(offset_arg)
  {}
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  SHOW_TYPE type() { return SHOW_MY_BOOL; }
323
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
unknown's avatar
unknown committed
324 325 326 327 328 329 330 331 332 333
  bool check(THD *thd, set_var *var)
  {
    return check_enum(thd, var, &bool_typelib);
  }
  bool check_update_type(Item_result type) { return 0; }
};


class sys_var_thd_enum :public sys_var_thd
{
334
protected:
unknown's avatar
unknown committed
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
  ulong SV::*offset;
  TYPELIB *enum_names;
public:
  sys_var_thd_enum(const char *name_arg, ulong SV::*offset_arg,
		   TYPELIB *typelib)
    :sys_var_thd(name_arg), offset(offset_arg), enum_names(typelib)
  {}
  sys_var_thd_enum(const char *name_arg, ulong SV::*offset_arg,
		   TYPELIB *typelib,
		   sys_after_update_func func)
    :sys_var_thd(name_arg,func), offset(offset_arg), enum_names(typelib)
  {}
  bool check(THD *thd, set_var *var)
  {
    return check_enum(thd, var, enum_names);
  }
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  SHOW_TYPE type() { return SHOW_CHAR; }
354
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
unknown's avatar
unknown committed
355 356 357 358
  bool check_update_type(Item_result type) { return 0; }
};


359 360
extern void fix_sql_mode_var(THD *thd, enum_var_type type);

361 362 363 364
class sys_var_thd_sql_mode :public sys_var_thd_enum
{
public:
  sys_var_thd_sql_mode(const char *name_arg, ulong SV::*offset_arg)
365 366
    :sys_var_thd_enum(name_arg, offset_arg, &sql_mode_typelib,
		      fix_sql_mode_var)
367 368 369 370 371 372
  {}
  bool check(THD *thd, set_var *var)
  {
    return check_set(thd, var, enum_names);
  }
  void set_default(THD *thd, enum_var_type type);
373
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
374 375
  static byte *symbolic_mode_representation(THD *thd, ulong sql_mode,
                                            ulong *length);
376 377 378
};


unknown's avatar
unknown committed
379
class sys_var_thd_storage_engine :public sys_var_thd
380 381
{
protected:
unknown's avatar
unknown committed
382
  handlerton *SV::*offset;
383
public:
unknown's avatar
unknown committed
384
  sys_var_thd_storage_engine(const char *name_arg, handlerton *SV::*offset_arg)
385 386 387 388 389 390 391 392 393 394 395 396 397
    :sys_var_thd(name_arg), offset(offset_arg)
  {}
  bool check(THD *thd, set_var *var);
SHOW_TYPE type() { return SHOW_CHAR; }
  bool check_update_type(Item_result type)
  {
    return type != STRING_RESULT;		/* Only accept strings */
  }
  void set_default(THD *thd, enum_var_type type);
  bool update(THD *thd, set_var *var);
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
};

unknown's avatar
unknown committed
398 399 400
class sys_var_thd_table_type :public sys_var_thd_storage_engine
{
public:
unknown's avatar
unknown committed
401
  sys_var_thd_table_type(const char *name_arg, handlerton *SV::*offset_arg)
unknown's avatar
unknown committed
402 403 404 405 406 407
    :sys_var_thd_storage_engine(name_arg, offset_arg)
  {}
  void warn_deprecated(THD *thd);
  void set_default(THD *thd, enum_var_type type);
  bool update(THD *thd, set_var *var);
};
408

unknown's avatar
unknown committed
409 410
class sys_var_thd_bit :public sys_var_thd
{
411
  sys_check_func check_func;
unknown's avatar
unknown committed
412 413 414 415
  sys_update_func update_func;
public:
  ulong bit_flag;
  bool reverse;
416 417 418 419 420
  sys_var_thd_bit(const char *name_arg, 
                  sys_check_func c_func, sys_update_func u_func,
                  ulong bit, bool reverse_arg=0)
    :sys_var_thd(name_arg), check_func(c_func), update_func(u_func),
    bit_flag(bit), reverse(reverse_arg)
unknown's avatar
unknown committed
421
  {}
422
  bool check(THD *thd, set_var *var);
unknown's avatar
unknown committed
423 424 425 426
  bool update(THD *thd, set_var *var);
  bool check_update_type(Item_result type) { return 0; }
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
  SHOW_TYPE type() { return SHOW_MY_BOOL; }
427
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
unknown's avatar
unknown committed
428 429 430 431 432 433 434 435 436 437 438 439 440 441
};


/* some variables that require special handling */

class sys_var_timestamp :public sys_var
{
public:
  sys_var_timestamp(const char *name_arg) :sys_var(name_arg) {}
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  bool check_type(enum_var_type type)    { return type == OPT_GLOBAL; }
  bool check_default(enum_var_type type) { return 0; }
  SHOW_TYPE type() { return SHOW_LONG; }
442
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
unknown's avatar
unknown committed
443 444 445 446 447 448 449 450 451 452
};


class sys_var_last_insert_id :public sys_var
{
public:
  sys_var_last_insert_id(const char *name_arg) :sys_var(name_arg) {}
  bool update(THD *thd, set_var *var);
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
  SHOW_TYPE type() { return SHOW_LONGLONG; }
453
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
unknown's avatar
unknown committed
454 455 456 457 458 459 460 461 462 463
};


class sys_var_insert_id :public sys_var
{
public:
  sys_var_insert_id(const char *name_arg) :sys_var(name_arg) {}
  bool update(THD *thd, set_var *var);
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
  SHOW_TYPE type() { return SHOW_LONGLONG; }
464
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
unknown's avatar
unknown committed
465 466 467
};


468
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
469 470 471 472 473 474 475 476 477 478 479 480
class sys_var_slave_skip_counter :public sys_var
{
public:
  sys_var_slave_skip_counter(const char *name_arg) :sys_var(name_arg) {}
  bool check(THD *thd, set_var *var);
  bool update(THD *thd, set_var *var);
  bool check_type(enum_var_type type) { return type != OPT_GLOBAL; }
  /*
    We can't retrieve the value of this, so we don't have to define
    type() or value_ptr()
  */
};
481 482 483 484 485 486 487 488

class sys_var_sync_binlog_period :public sys_var_long_ptr
{
public:
  sys_var_sync_binlog_period(const char *name_arg, ulong *value_ptr)
    :sys_var_long_ptr(name_arg,value_ptr) {}
  bool update(THD *thd, set_var *var);
};
489
#endif
unknown's avatar
unknown committed
490

491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
class sys_var_rand_seed1 :public sys_var
{
public:
  sys_var_rand_seed1(const char *name_arg) :sys_var(name_arg) {}
  bool update(THD *thd, set_var *var);
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
};

class sys_var_rand_seed2 :public sys_var
{
public:
  sys_var_rand_seed2(const char *name_arg) :sys_var(name_arg) {}
  bool update(THD *thd, set_var *var);
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
};


508
class sys_var_collation :public sys_var_thd
unknown's avatar
unknown committed
509 510
{
public:
511 512 513 514
  sys_var_collation(const char *name_arg) :sys_var_thd(name_arg)
    {
    no_support_one_shot= 0;
    }
unknown's avatar
unknown committed
515
  bool check(THD *thd, set_var *var);
516
SHOW_TYPE type() { return SHOW_CHAR; }
unknown's avatar
unknown committed
517 518
  bool check_update_type(Item_result type)
  {
519
    return ((type != STRING_RESULT) && (type != INT_RESULT));
unknown's avatar
unknown committed
520 521
  }
  bool check_default(enum_var_type type) { return 0; }
522 523 524
  virtual void set_default(THD *thd, enum_var_type type)= 0;
};

525
class sys_var_character_set :public sys_var_thd
526 527
{
public:
528
  bool nullable;
529 530 531 532 533 534 535 536 537 538
  sys_var_character_set(const char *name_arg) :
    sys_var_thd(name_arg)
  {
    nullable= 0;
    /*
      In fact only almost all variables derived from sys_var_character_set
      support ONE_SHOT; character_set_results doesn't. But that's good enough.
    */
    no_support_one_shot= 0;
  }
539
  bool check(THD *thd, set_var *var);
540
  SHOW_TYPE type() { return SHOW_CHAR; }
541 542
  bool check_update_type(Item_result type)
  {
543
    return ((type != STRING_RESULT) && (type != INT_RESULT));
544 545
  }
  bool check_default(enum_var_type type) { return 0; }
546
  bool update(THD *thd, set_var *var);
547
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
548
  virtual void set_default(THD *thd, enum_var_type type)= 0;
549
  virtual CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type)= 0;
550 551
};

unknown's avatar
unknown committed
552 553 554 555 556 557 558 559 560
class sys_var_character_set_filesystem :public sys_var_character_set
{
public:
  sys_var_character_set_filesystem(const char *name_arg) :
    sys_var_character_set(name_arg) {}
  void set_default(THD *thd, enum_var_type type);
  CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
};

561 562 563 564 565
class sys_var_character_set_client :public sys_var_character_set
{
public:
  sys_var_character_set_client(const char *name_arg) :
    sys_var_character_set(name_arg) {}
566
  void set_default(THD *thd, enum_var_type type);
567
  CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
568 569
};

570
class sys_var_character_set_results :public sys_var_character_set
571 572
{
public:
573
  sys_var_character_set_results(const char *name_arg) :
574 575
    sys_var_character_set(name_arg) 
    { nullable= 1; }
576
  void set_default(THD *thd, enum_var_type type);
577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
  CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
};

class sys_var_character_set_server :public sys_var_character_set
{
public:
  sys_var_character_set_server(const char *name_arg) :
    sys_var_character_set(name_arg) {}
  void set_default(THD *thd, enum_var_type type);
  CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
};

class sys_var_character_set_database :public sys_var_character_set
{
public:
  sys_var_character_set_database(const char *name_arg) :
    sys_var_character_set(name_arg) {}
  void set_default(THD *thd, enum_var_type type);
  CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
unknown's avatar
unknown committed
596 597
};

unknown's avatar
unknown committed
598 599 600 601 602 603 604 605 606
class sys_var_character_set_connection :public sys_var_character_set
{
public:
  sys_var_character_set_connection(const char *name_arg) :
    sys_var_character_set(name_arg) {}
  void set_default(THD *thd, enum_var_type type);
  CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
};

607
class sys_var_collation_connection :public sys_var_collation
608 609
{
public:
610
  sys_var_collation_connection(const char *name_arg) :sys_var_collation(name_arg) {}
611 612
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
613
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
614 615
};

616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632
class sys_var_collation_server :public sys_var_collation
{
public:
  sys_var_collation_server(const char *name_arg) :sys_var_collation(name_arg) {}
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
};

class sys_var_collation_database :public sys_var_collation
{
public:
  sys_var_collation_database(const char *name_arg) :sys_var_collation(name_arg) {}
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
};
633

634

635
class sys_var_key_cache_param :public sys_var
636
{
637
protected:
638
  size_t offset;
639
public:
640 641 642
  sys_var_key_cache_param(const char *name_arg, size_t offset_arg)
    :sys_var(name_arg), offset(offset_arg)
  {}
643
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
644 645
  bool check_default(enum_var_type type) { return 1; }
  bool is_struct() { return 1; }
646 647
};

648

649 650 651 652
class sys_var_key_buffer_size :public sys_var_key_cache_param
{
public:
  sys_var_key_buffer_size(const char *name_arg)
unknown's avatar
unknown committed
653
    :sys_var_key_cache_param(name_arg, offsetof(KEY_CACHE, param_buff_size))
654
  {}
655 656
  bool update(THD *thd, set_var *var);
  SHOW_TYPE type() { return SHOW_LONGLONG; }
657 658 659
};


660
class sys_var_key_cache_long :public sys_var_key_cache_param
661 662
{
public:
663 664 665
  sys_var_key_cache_long(const char *name_arg, size_t offset_arg)
    :sys_var_key_cache_param(name_arg, offset_arg)
  {}
666 667
  bool update(THD *thd, set_var *var);
  SHOW_TYPE type() { return SHOW_LONG; }
668 669 670
};


671
class sys_var_thd_date_time_format :public sys_var_thd
672
{
673
  DATE_TIME_FORMAT *SV::*offset;
674
  timestamp_type date_time_type;
675
public:
676 677 678 679 680
  sys_var_thd_date_time_format(const char *name_arg,
			       DATE_TIME_FORMAT *SV::*offset_arg,
			       timestamp_type date_time_type_arg)
    :sys_var_thd(name_arg), offset(offset_arg),
    date_time_type(date_time_type_arg)
681 682 683 684 685 686 687
  {}
  SHOW_TYPE type() { return SHOW_CHAR; }
  bool check_update_type(Item_result type)
  {
    return type != STRING_RESULT;		/* Only accept strings */
  }
  bool check_default(enum_var_type type) { return 0; }
688
  bool check(THD *thd, set_var *var);
689
  bool update(THD *thd, set_var *var);
690
  void update2(THD *thd, enum_var_type type, DATE_TIME_FORMAT *new_value);
691 692 693 694 695
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  void set_default(THD *thd, enum_var_type type);
};


696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713
/* Variable that you can only read from */

class sys_var_readonly: public sys_var
{
public:
  enum_var_type var_type;
  SHOW_TYPE show_type;
  sys_value_ptr_func value_ptr_func;
  sys_var_readonly(const char *name_arg, enum_var_type type,
		   SHOW_TYPE show_type_arg,
		   sys_value_ptr_func value_ptr_func_arg)
    :sys_var(name_arg), var_type(type), 
       show_type(show_type_arg), value_ptr_func(value_ptr_func_arg)
  {}
  bool update(THD *thd, set_var *var) { return 1; }
  bool check_default(enum_var_type type) { return 1; }
  bool check_type(enum_var_type type) { return type != var_type; }
  bool check_update_type(Item_result type) { return 1; }
714
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
715 716 717 718
  {
    return (*value_ptr_func)(thd);
  }
  SHOW_TYPE type() { return show_type; }
719
  bool is_readonly() const { return 1; }
720 721
};

722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745

class sys_var_have_variable: public sys_var
{
  SHOW_COMP_OPTION *have_variable;

public:
  sys_var_have_variable(const char *variable_name,
                        SHOW_COMP_OPTION *have_variable_arg):
    sys_var(variable_name),
    have_variable(have_variable_arg)
  { }
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  {
    return (byte*) show_comp_option_name[*have_variable];
  }
  bool update(THD *thd, set_var *var) { return 1; }
  bool check_default(enum_var_type type) { return 1; }
  bool check_type(enum_var_type type) { return type != OPT_GLOBAL; }
  bool check_update_type(Item_result type) { return 1; }
  SHOW_TYPE type() { return SHOW_CHAR; }
  bool is_readonly() const { return 1; }
};


746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
class sys_var_thd_time_zone :public sys_var_thd
{
public:
  sys_var_thd_time_zone(const char *name_arg):
    sys_var_thd(name_arg) 
  {
    no_support_one_shot= 0;
  }
  bool check(THD *thd, set_var *var);
  SHOW_TYPE type() { return SHOW_CHAR; }
  bool check_update_type(Item_result type)
  {
    return type != STRING_RESULT;		/* Only accept strings */
  }
  bool check_default(enum_var_type type) { return 0; }
  bool update(THD *thd, set_var *var);
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  virtual void set_default(THD *thd, enum_var_type type);
};

766 767 768 769 770 771 772 773 774 775 776 777 778

class sys_var_max_user_conn : public sys_var_thd
{
public:
  sys_var_max_user_conn(const char *name_arg):
    sys_var_thd(name_arg) {}
  bool check(THD *thd, set_var *var);
  bool update(THD *thd, set_var *var);
  bool check_default(enum_var_type type)
  {
    return type != OPT_GLOBAL || !option_limits;
  }
  void set_default(THD *thd, enum_var_type type);
779
  SHOW_TYPE type() { return SHOW_INT; }
780 781 782
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
};

783 784 785 786 787 788 789 790 791 792 793
class sys_var_trust_routine_creators :public sys_var_bool_ptr
{
  /* We need a derived class only to have a warn_deprecated() */
public:
  sys_var_trust_routine_creators(const char *name_arg, my_bool *value_arg) :
    sys_var_bool_ptr(name_arg, value_arg) {};
  void warn_deprecated(THD *thd);
  void set_default(THD *thd, enum_var_type type);
  bool update(THD *thd, set_var *var);
};

unknown's avatar
unknown committed
794 795 796 797 798 799 800 801 802 803 804

class sys_var_event_executor :public sys_var_bool_ptr
{
  /* We need a derived class only to have a warn_deprecated() */
public:
  sys_var_event_executor(const char *name_arg, my_bool *value_arg) :
    sys_var_bool_ptr(name_arg, value_arg) {};
  bool update(THD *thd, set_var *var);
};


unknown's avatar
unknown committed
805 806 807 808 809 810 811 812 813
/****************************************************************************
  Classes for parsing of the SET command
****************************************************************************/

class set_var_base :public Sql_alloc
{
public:
  set_var_base() {}
  virtual ~set_var_base() {}
814 815
  virtual int check(THD *thd)=0;	/* To check privileges etc. */
  virtual int update(THD *thd)=0;	/* To set the value */
816
  /* light check for PS */
817 818
  virtual int light_check(THD *thd) { return check(thd); }
  virtual bool no_support_one_shot() { return 1; }
unknown's avatar
unknown committed
819 820 821 822 823 824 825 826 827 828 829 830 831
};


/* MySQL internal variables, like query_cache_size */

class set_var :public set_var_base
{
public:
  sys_var *var;
  Item *value;
  enum_var_type type;
  union
  {
unknown's avatar
unknown committed
832
    CHARSET_INFO *charset;
unknown's avatar
unknown committed
833
    ulong ulong_value;
834
    ulonglong ulonglong_value;
unknown's avatar
unknown committed
835
    handlerton *hton;
836
    DATE_TIME_FORMAT *date_time_format;
837
    Time_zone *time_zone;
unknown's avatar
unknown committed
838
  } save_result;
unknown's avatar
unknown committed
839
  LEX_STRING base;			/* for structs */
unknown's avatar
unknown committed
840

841
  set_var(enum_var_type type_arg, sys_var *var_arg, const LEX_STRING *base_name_arg,
unknown's avatar
unknown committed
842 843
	  Item *value_arg)
    :var(var_arg), type(type_arg), base(*base_name_arg)
unknown's avatar
unknown committed
844 845 846 847 848 849 850 851
  {
    /*
      If the set value is a field, change it to a string to allow things like
      SET table_type=MYISAM;
    */
    if (value_arg && value_arg->type() == Item::FIELD_ITEM)
    {
      Item_field *item= (Item_field*) value_arg;
852 853
      if (!(value=new Item_string(item->field_name, 
                  (uint) strlen(item->field_name),
854
				  item->collation.collation)))
unknown's avatar
unknown committed
855 856 857 858 859
	value=value_arg;			/* Give error message later */
    }
    else
      value=value_arg;
  }
860 861
  int check(THD *thd);
  int update(THD *thd);
862
  int light_check(THD *thd);
863
  bool no_support_one_shot() { return var->no_support_one_shot; }
unknown's avatar
unknown committed
864 865 866 867 868 869 870 871 872 873 874 875
};


/* User variables like @my_own_variable */

class set_var_user: public set_var_base
{
  Item_func_set_user_var *user_var_item;
public:
  set_var_user(Item_func_set_user_var *item)
    :user_var_item(item)
  {}
876 877
  int check(THD *thd);
  int update(THD *thd);
878
  int light_check(THD *thd);
unknown's avatar
unknown committed
879 880 881 882 883 884 885 886 887 888 889 890
};

/* For SET PASSWORD */

class set_var_password: public set_var_base
{
  LEX_USER *user;
  char *password;
public:
  set_var_password(LEX_USER *user_arg,char *password_arg)
    :user(user_arg), password(password_arg)
  {}
891 892
  int check(THD *thd);
  int update(THD *thd);
unknown's avatar
unknown committed
893 894 895
};


896 897
/* For SET NAMES and SET CHARACTER SET */

unknown's avatar
unknown committed
898
class set_var_collation_client: public set_var_base
899
{
900 901
  CHARSET_INFO *character_set_client;
  CHARSET_INFO *character_set_results;
unknown's avatar
unknown committed
902
  CHARSET_INFO *collation_connection;
903
public:
unknown's avatar
unknown committed
904
  set_var_collation_client(CHARSET_INFO *client_coll_arg,
905
  			   CHARSET_INFO *connection_coll_arg,
906
  			   CHARSET_INFO *result_coll_arg)
907 908 909
    :character_set_client(client_coll_arg),
     character_set_results(result_coll_arg),
     collation_connection(connection_coll_arg)
910 911 912 913 914 915
  {}
  int check(THD *thd);
  int update(THD *thd);
};


916 917 918 919 920 921 922 923 924 925
/* Named lists (used for keycaches) */

class NAMED_LIST :public ilink
{
  const char *name;
  uint name_length;
public:
  gptr data;

  NAMED_LIST(I_List<NAMED_LIST> *links, const char *name_arg,
unknown's avatar
unknown committed
926 927 928
	     uint name_length_arg, gptr data_arg)
    :name_length(name_length_arg), data(data_arg)
  {
929
    name= my_strdup_with_length((byte*) name_arg, name_length, MYF(MY_WME));
unknown's avatar
unknown committed
930 931
    links->push_back(this);
  }
932 933 934 935 936 937 938 939
  inline bool cmp(const char *name_cmp, uint length)
  {
    return length == name_length && !memcmp(name, name_cmp, length);
  }
  ~NAMED_LIST()
  {
    my_free((char*) name, MYF(0));
  }
940
  friend bool process_key_caches(int (* func) (const char *name,
unknown's avatar
unknown committed
941
					       KEY_CACHE *));
942 943
  friend void delete_elements(I_List<NAMED_LIST> *list,
			      void (*free_element)(const char*, gptr));
944 945
};

946 947
/* updated in sql_acl.cc */

unknown's avatar
unknown committed
948
extern sys_var_thd_bool sys_old_alter_table;
949
extern sys_var_thd_bool sys_old_passwords;
950
extern LEX_STRING default_key_cache_base;
951

unknown's avatar
unknown committed
952 953 954 955 956 957 958
/* For sql_yacc */
struct sys_var_with_base
{
  sys_var *var;
  LEX_STRING base_name;
};

unknown's avatar
unknown committed
959 960 961 962 963 964 965
/*
  Prototypes for helper functions
*/

void set_var_init();
void set_var_free();
sys_var *find_sys_var(const char *str, uint length=0);
966
int sql_set_variables(THD *thd, List<set_var_base> *var_list);
967
bool not_all_support_one_shot(List<set_var_base> *var_list);
968
void fix_delay_key_write(THD *thd, enum_var_type type);
969
ulong fix_sql_mode(ulong sql_mode);
970
extern sys_var_const_str sys_charset_system;
unknown's avatar
unknown committed
971 972
extern sys_var_str sys_init_connect;
extern sys_var_str sys_init_slave;
973
extern sys_var_thd_time_zone sys_time_zone;
974
extern sys_var_thd_bit sys_autocommit;
unknown's avatar
unknown committed
975
CHARSET_INFO *get_old_charset_by_name(const char *old_name);
unknown's avatar
unknown committed
976 977
gptr find_named(I_List<NAMED_LIST> *list, const char *name, uint length,
		NAMED_LIST **found);
978 979

/* key_cache functions */
unknown's avatar
unknown committed
980 981 982 983
KEY_CACHE *get_key_cache(LEX_STRING *cache_name);
KEY_CACHE *get_or_create_key_cache(const char *name, uint length);
void free_key_cache(const char *name, KEY_CACHE *key_cache);
bool process_key_caches(int (* func) (const char *name, KEY_CACHE *));
unknown's avatar
unknown committed
984 985
void delete_elements(I_List<NAMED_LIST> *list,
		     void (*free_element)(const char*, gptr));