set_var.h 24.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
/* 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 */

#ifdef __GNUC__
#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;
32 33 34 35 36 37 38 39 40 41

enum enum_var_type
{
  OPT_DEFAULT, OPT_SESSION, OPT_GLOBAL
};

typedef bool (*sys_check_func)(THD *,  set_var *);
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);
42
typedef byte *(*sys_value_ptr_func)(THD *thd);
43 44 45 46 47 48 49

class sys_var
{
public:
  struct my_option *option_limits;	/* Updated by by set_var_init() */
  uint name_length;			/* Updated by by set_var_init() */
  const char *name;
50
  
51 52
  sys_after_update_func after_update;
  sys_var(const char *name_arg) :name(name_arg),after_update(0)
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
53
  {}
54 55
  sys_var(const char *name_arg,sys_after_update_func func)
    :name(name_arg),after_update(func)
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
56
  {}
57
  virtual ~sys_var() {}
58
  virtual bool check(THD *thd, set_var *var);
59
  bool check_enum(THD *thd, set_var *var, TYPELIB *enum_names);
60
  bool check_set(THD *thd, set_var *var, TYPELIB *enum_names);
61 62 63
  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; }
64 65
  virtual byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  { return 0; }
66 67 68 69 70 71
  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; }
72 73
  Item *item(THD *thd, enum_var_type type, LEX_STRING *base);
  virtual bool is_struct() { return 0; }
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
};


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) {}
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  SHOW_TYPE type() { return SHOW_LONG; }
89 90
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  { return (byte*) value; }
91 92 93
};


94 95 96 97 98 99 100 101 102 103 104 105
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; }
106 107
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  { return (byte*) value; }
108 109 110
};


111 112 113 114 115 116 117 118 119 120 121 122 123 124
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; }
125 126
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  { return (byte*) value; }
127 128 129 130 131 132 133 134
  bool check_update_type(Item_result type) { return 0; }
};


class sys_var_str :public sys_var
{
public:
  char *value;					// Pointer to allocated string
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
135
  uint value_length;
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
  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,
	      sys_set_default_func set_default_func_arg)
    :sys_var(name_arg), check_func(check_func_arg),
    update_func(update_func_arg),set_default_func(set_default_func_arg)
  {}
  bool check(THD *thd, set_var *var)
  {
    return check_func ? (*check_func)(thd, var) : 0;
  }
  bool update(THD *thd, set_var *var)
  {
    return (*update_func)(thd, var);
  }
  void set_default(THD *thd, enum_var_type type)
  {
156
    (*set_default_func)(thd, type);
157 158
  }
  SHOW_TYPE type() { return SHOW_CHAR; }
159 160
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  { return (byte*) value; }
161 162 163 164 165 166 167 168
  bool check_update_type(Item_result type)
  {
    return type != STRING_RESULT;		/* Only accept strings */
  }
  bool check_default(enum_var_type type) { return 0; }
};


169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
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; }
184
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
185 186 187 188
  bool check_update_type(Item_result type) { return 0; }
};


189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
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
{
public:
  ulong SV::*offset;
  sys_var_thd_ulong(const char *name_arg, ulong SV::*offset_arg)
    :sys_var_thd(name_arg), offset(offset_arg)
  {}
  sys_var_thd_ulong(const char *name_arg, ulong 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_LONG; }
220
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
221 222
};

223 224 225 226 227 228 229 230 231
class sys_var_pseudo_thread_id :public sys_var_thd_ulong
{
public:
  sys_var_pseudo_thread_id(const char *name_arg, ulong SV::*offset_arg)
    :sys_var_thd_ulong(name_arg, offset_arg) 
  {}
  bool check(THD *thd, set_var *var);
};

232

233 234 235 236 237 238 239 240 241 242 243 244 245 246
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; }
247
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
248 249 250
};


251 252 253 254
class sys_var_thd_ulonglong :public sys_var_thd
{
public:
  ulonglong SV::*offset;
255
  bool only_global;
256 257 258
  sys_var_thd_ulonglong(const char *name_arg, ulonglong SV::*offset_arg)
    :sys_var_thd(name_arg), offset(offset_arg)
  {}
259
  sys_var_thd_ulonglong(const char *name_arg, ulonglong SV::*offset_arg,
260 261 262
			sys_after_update_func func, bool only_global_arg)
    :sys_var_thd(name_arg, func), offset(offset_arg),
    only_global(only_global_arg)
263
  {}
264 265 266
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  SHOW_TYPE type() { return SHOW_LONGLONG; }
267
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
268 269 270 271 272 273 274 275
  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);
  }
276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
};


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; }
293
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
294 295 296 297 298 299 300 301 302 303
  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
{
304
protected:
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
  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; }
324
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
325 326 327 328
  bool check_update_type(Item_result type) { return 0; }
};


329 330
extern void fix_sql_mode_var(THD *thd, enum_var_type type);

331 332 333 334
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)
335 336
    :sys_var_thd_enum(name_arg, offset_arg, &sql_mode_typelib,
		      fix_sql_mode_var)
337 338 339 340 341 342
  {}
  bool check(THD *thd, set_var *var)
  {
    return check_set(thd, var, enum_names);
  }
  void set_default(THD *thd, enum_var_type type);
343
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
344 345 346
};


347
class sys_var_thd_storage_engine :public sys_var_thd
348 349 350 351
{
protected:
  ulong SV::*offset;
public:
352
  sys_var_thd_storage_engine(const char *name_arg, ulong SV::*offset_arg)
353 354 355 356 357 358 359 360 361 362 363 364 365
    :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);
};

366 367 368 369 370 371 372 373 374 375
class sys_var_thd_table_type :public sys_var_thd_storage_engine
{
public:
  sys_var_thd_table_type(const char *name_arg, ulong SV::*offset_arg)
    :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);
};
376

377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
class sys_var_thd_bit :public sys_var_thd
{
  sys_update_func update_func;
public:
  ulong bit_flag;
  bool reverse;
  sys_var_thd_bit(const char *name_arg, sys_update_func func, ulong bit,
		  bool reverse_arg=0)
    :sys_var_thd(name_arg), update_func(func), bit_flag(bit),
    reverse(reverse_arg)
  {}
  bool check(THD *thd, set_var *var)
  {
    return check_enum(thd, var, &bool_typelib);
  }
  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; }
396
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
397 398 399 400 401 402 403 404 405 406 407 408 409 410
};


/* 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; }
411
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
412 413 414 415 416 417 418 419 420 421
};


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; }
422
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
423 424 425 426 427 428 429 430 431 432
};


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; }
433
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
434 435 436
};


437
#ifndef EMBEDDED_LIBRARY
438 439 440 441 442 443 444 445 446 447 448 449
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()
  */
};
450
#endif
451

452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468
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; }
};


469
class sys_var_collation :public sys_var_thd
470 471
{
public:
472
  sys_var_collation(const char *name_arg) :sys_var_thd(name_arg) {}
473
  bool check(THD *thd, set_var *var);
474
SHOW_TYPE type() { return SHOW_CHAR; }
475 476 477 478 479
  bool check_update_type(Item_result type)
  {
    return type != STRING_RESULT;		/* Only accept strings */
  }
  bool check_default(enum_var_type type) { return 0; }
480 481 482
  virtual void set_default(THD *thd, enum_var_type type)= 0;
};

483
class sys_var_character_set :public sys_var_thd
484 485
{
public:
486 487 488
  bool nullable;
  sys_var_character_set(const char *name_arg) :sys_var_thd(name_arg) 
  { nullable= 0; }
489 490 491 492 493 494 495
  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; }
496
  bool update(THD *thd, set_var *var);
497
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
498
  virtual void set_default(THD *thd, enum_var_type type)= 0;
499
  virtual CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type)= 0;
500 501 502 503 504 505 506
};

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) {}
507
  void set_default(THD *thd, enum_var_type type);
508
  CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
509 510
};

511
class sys_var_character_set_results :public sys_var_character_set
512 513
{
public:
514
  sys_var_character_set_results(const char *name_arg) :
515 516
    sys_var_character_set(name_arg) 
    { nullable= 1; }
517
  void set_default(THD *thd, enum_var_type type);
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
  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);
537 538
};

539 540 541 542 543 544 545 546 547
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);
};

548
class sys_var_collation_connection :public sys_var_collation
549 550
{
public:
551
  sys_var_collation_connection(const char *name_arg) :sys_var_collation(name_arg) {}
552 553
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
554
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
555 556
};

557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573
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);
};
574

575

576
class sys_var_key_cache_param :public sys_var
577
{
578
protected:
579
  size_t offset;
580
public:
581 582 583
  sys_var_key_cache_param(const char *name_arg, size_t offset_arg)
    :sys_var(name_arg), offset(offset_arg)
  {}
584
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
585 586
  bool check_default(enum_var_type type) { return 1; }
  bool is_struct() { return 1; }
587 588
};

589

590 591 592 593
class sys_var_key_buffer_size :public sys_var_key_cache_param
{
public:
  sys_var_key_buffer_size(const char *name_arg)
594
    :sys_var_key_cache_param(name_arg, offsetof(KEY_CACHE, param_buff_size))
595
  {}
596 597
  bool update(THD *thd, set_var *var);
  SHOW_TYPE type() { return SHOW_LONGLONG; }
598 599 600
};


601
class sys_var_key_cache_long :public sys_var_key_cache_param
602 603
{
public:
604 605 606
  sys_var_key_cache_long(const char *name_arg, size_t offset_arg)
    :sys_var_key_cache_param(name_arg, offset_arg)
  {}
607 608
  bool update(THD *thd, set_var *var);
  SHOW_TYPE type() { return SHOW_LONG; }
609 610 611
};


612
class sys_var_thd_date_time_format :public sys_var_thd
613
{
614 615
  DATE_TIME_FORMAT *SV::*offset;
  enum timestamp_type date_time_type;
616
public:
617 618 619 620 621
  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)
622 623 624 625 626 627 628
  {}
  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; }
629
  bool check(THD *thd, set_var *var);
630
  bool update(THD *thd, set_var *var);
631
  void update2(THD *thd, enum_var_type type, DATE_TIME_FORMAT *new_value);
632 633 634 635 636
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  void set_default(THD *thd, enum_var_type type);
};


637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
/* 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; }
655
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
656 657 658 659 660 661
  {
    return (*value_ptr_func)(thd);
  }
  SHOW_TYPE type() { return show_type; }
};

662 663 664 665 666 667 668 669 670
/****************************************************************************
  Classes for parsing of the SET command
****************************************************************************/

class set_var_base :public Sql_alloc
{
public:
  set_var_base() {}
  virtual ~set_var_base() {}
671 672
  virtual int check(THD *thd)=0;	/* To check privileges etc. */
  virtual int update(THD *thd)=0;	/* To set the value */
673 674 675 676 677 678 679 680 681 682 683 684 685
};


/* 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
  {
686
    CHARSET_INFO *charset;
687
    ulong ulong_value;
688
    ulonglong ulonglong_value;
689
    DATE_TIME_FORMAT *date_time_format;
690
  } save_result;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
691
  LEX_STRING base;			/* for structs */
692

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
693 694 695
  set_var(enum_var_type type_arg, sys_var *var_arg, LEX_STRING *base_name_arg,
	  Item *value_arg)
    :var(var_arg), type(type_arg), base(*base_name_arg)
696 697 698 699 700 701 702 703
  {
    /*
      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;
704
      if (!(value=new Item_string(item->field_name, strlen(item->field_name),
705
				  item->collation.collation)))
706 707 708 709 710
	value=value_arg;			/* Give error message later */
    }
    else
      value=value_arg;
  }
711 712
  int check(THD *thd);
  int update(THD *thd);
713 714 715 716 717 718 719 720 721 722 723 724
};


/* 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)
  {}
725 726
  int check(THD *thd);
  int update(THD *thd);
727 728 729 730 731 732 733 734 735 736 737 738
};

/* 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)
  {}
739 740
  int check(THD *thd);
  int update(THD *thd);
741 742 743
};


744 745
/* For SET NAMES and SET CHARACTER SET */

746
class set_var_collation_client: public set_var_base
747
{
748 749
  CHARSET_INFO *character_set_client;
  CHARSET_INFO *character_set_results;
750
  CHARSET_INFO *collation_connection;
751
public:
752
  set_var_collation_client(CHARSET_INFO *client_coll_arg,
753
  			   CHARSET_INFO *connection_coll_arg,
754
  			   CHARSET_INFO *result_coll_arg)
755 756 757
    :character_set_client(client_coll_arg),
     character_set_results(result_coll_arg),
     collation_connection(connection_coll_arg)
758 759 760 761 762 763
  {}
  int check(THD *thd);
  int update(THD *thd);
};


764 765 766 767 768 769 770 771 772 773
/* 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,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
774 775 776
	     uint name_length_arg, gptr data_arg)
    :name_length(name_length_arg), data(data_arg)
  {
777
    name= my_strdup_with_length((byte*) name_arg, name_length, MYF(MY_WME));
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
778 779
    links->push_back(this);
  }
780 781 782 783 784 785 786 787
  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));
  }
788
  friend bool process_key_caches(int (* func) (const char *name,
789
					       KEY_CACHE *));
790 791
  friend void delete_elements(I_List<NAMED_LIST> *list,
			      void (*free_element)(const char*, gptr));
792 793
};

794 795 796
/* updated in sql_acl.cc */

extern sys_var_thd_bool sys_old_passwords;
797
extern LEX_STRING default_key_cache_base;
798

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
799 800 801 802 803 804 805
/* For sql_yacc */
struct sys_var_with_base
{
  sys_var *var;
  LEX_STRING base_name;
};

806 807 808 809 810 811 812
/*
  Prototypes for helper functions
*/

void set_var_init();
void set_var_free();
sys_var *find_sys_var(const char *str, uint length=0);
813
int sql_set_variables(THD *thd, List<set_var_base> *var_list);
814
void fix_delay_key_write(THD *thd, enum_var_type type);
815
ulong fix_sql_mode(ulong sql_mode);
816
extern sys_var_str sys_charset_system;
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
817 818
extern sys_var_str sys_init_connect;
extern sys_var_str sys_init_slave;
819
CHARSET_INFO *get_old_charset_by_name(const char *old_name);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
820 821
gptr find_named(I_List<NAMED_LIST> *list, const char *name, uint length,
		NAMED_LIST **found);
822 823

/* key_cache functions */
824 825 826 827
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 *));
828 829
void delete_elements(I_List<NAMED_LIST> *list,
		     void (*free_element)(const char*, gptr));