set_var.h 26.8 KB
Newer Older
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
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;
32 33 34

enum enum_var_type
{
35
  OPT_DEFAULT= 0, OPT_SESSION, OPT_GLOBAL
36 37
};

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


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) {}
svoj@mysql.com's avatar
svoj@mysql.com committed
90
  bool check(THD *thd, set_var *var);
91 92 93
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  SHOW_TYPE type() { return SHOW_LONG; }
94 95
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  { return (byte*) value; }
96 97 98
};


99 100 101 102 103 104 105 106 107 108 109 110
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; }
111 112
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  { return (byte*) value; }
113 114 115
};


116 117 118 119 120 121 122 123 124 125 126 127 128 129
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; }
130 131
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  { return (byte*) value; }
132 133 134 135 136 137 138 139
  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
140
  uint value_length;
141 142 143 144 145 146
  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,
147 148
	      sys_set_default_func set_default_func_arg,
              char *value_arg)
149
    :sys_var(name_arg), value(value_arg), check_func(check_func_arg),
150 151
    update_func(update_func_arg),set_default_func(set_default_func_arg)
  {}
152
  bool check(THD *thd, set_var *var);
153 154 155 156 157 158
  bool update(THD *thd, set_var *var)
  {
    return (*update_func)(thd, var);
  }
  void set_default(THD *thd, enum_var_type type)
  {
159
    (*set_default_func)(thd, type);
160 161
  }
  SHOW_TYPE type() { return SHOW_CHAR; }
162 163
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  { return (byte*) value; }
164 165 166 167 168 169 170 171
  bool check_update_type(Item_result type)
  {
    return type != STRING_RESULT;		/* Only accept strings */
  }
  bool check_default(enum_var_type type) { return 0; }
};


172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
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; }
monty@mysql.com's avatar
monty@mysql.com committed
188 189 190 191
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  {
    return (byte*) value;
  }
192 193 194 195 196 197 198 199
  bool check_update_type(Item_result type)
  {
    return 1;
  }
  bool check_default(enum_var_type type) { return 1; }
};


200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
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; }
215
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
216 217 218 219
  bool check_update_type(Item_result type) { return 0; }
};


220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
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
{
239
  sys_check_func check_func;
240 241 242
public:
  ulong SV::*offset;
  sys_var_thd_ulong(const char *name_arg, ulong SV::*offset_arg)
243
    :sys_var_thd(name_arg), check_func(0), offset(offset_arg)
244 245
  {}
  sys_var_thd_ulong(const char *name_arg, ulong SV::*offset_arg,
246 247
		   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)
248
  {}
249
  bool check(THD *thd, set_var *var);
250 251 252
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  SHOW_TYPE type() { return SHOW_LONG; }
253
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
254 255 256
};


257 258 259 260 261 262 263 264 265 266 267 268 269 270
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; }
271
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
272 273 274
};


275 276 277 278
class sys_var_thd_ulonglong :public sys_var_thd
{
public:
  ulonglong SV::*offset;
279
  bool only_global;
280 281 282
  sys_var_thd_ulonglong(const char *name_arg, ulonglong SV::*offset_arg)
    :sys_var_thd(name_arg), offset(offset_arg)
  {}
283
  sys_var_thd_ulonglong(const char *name_arg, ulonglong SV::*offset_arg,
284 285 286
			sys_after_update_func func, bool only_global_arg)
    :sys_var_thd(name_arg, func), offset(offset_arg),
    only_global(only_global_arg)
287
  {}
288 289 290
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
  SHOW_TYPE type() { return SHOW_LONGLONG; }
291
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
292 293 294 295 296 297 298 299
  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);
  }
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
};


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; }
317
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
318 319 320 321 322 323 324 325 326 327
  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
{
328
protected:
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
  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; }
348
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
349 350 351 352
  bool check_update_type(Item_result type) { return 0; }
};


353 354
extern void fix_sql_mode_var(THD *thd, enum_var_type type);

355 356 357 358
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)
359 360
    :sys_var_thd_enum(name_arg, offset_arg, &sql_mode_typelib,
		      fix_sql_mode_var)
361 362 363 364 365 366
  {}
  bool check(THD *thd, set_var *var)
  {
    return check_set(thd, var, enum_names);
  }
  void set_default(THD *thd, enum_var_type type);
367
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
368 369 370
};


371
class sys_var_thd_storage_engine :public sys_var_thd
372 373 374 375
{
protected:
  ulong SV::*offset;
public:
376
  sys_var_thd_storage_engine(const char *name_arg, ulong SV::*offset_arg)
377 378 379 380 381 382 383 384 385 386 387 388 389
    :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);
};

390 391 392 393 394 395 396 397 398 399
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);
};
400

401 402
class sys_var_thd_bit :public sys_var_thd
{
403
  sys_check_func check_func;
404 405 406 407
  sys_update_func update_func;
public:
  ulong bit_flag;
  bool reverse;
408 409 410 411 412
  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)
413
  {}
414
  bool check(THD *thd, set_var *var);
415 416 417 418
  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; }
419
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
420 421 422 423 424 425 426 427 428 429 430 431 432 433
};


/* 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; }
434
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
435 436 437 438 439 440 441 442 443 444
};


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; }
445
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
446 447 448 449 450 451 452 453 454 455
};


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; }
456
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
457 458 459
};


460
#ifdef HAVE_REPLICATION
461 462 463 464 465 466 467 468 469 470 471 472
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()
  */
};
473 474 475 476 477 478 479 480

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);
};
481
#endif
482

483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
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; }
};


500
class sys_var_collation :public sys_var_thd
501 502
{
public:
503 504 505 506
  sys_var_collation(const char *name_arg) :sys_var_thd(name_arg)
    {
    no_support_one_shot= 0;
    }
507
  bool check(THD *thd, set_var *var);
508
SHOW_TYPE type() { return SHOW_CHAR; }
509 510
  bool check_update_type(Item_result type)
  {
511
    return ((type != STRING_RESULT) && (type != INT_RESULT));
512 513
  }
  bool check_default(enum_var_type type) { return 0; }
514 515 516
  virtual void set_default(THD *thd, enum_var_type type)= 0;
};

517
class sys_var_character_set :public sys_var_thd
518 519
{
public:
520
  bool nullable;
521 522 523 524 525 526 527 528 529 530
  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;
  }
531
  bool check(THD *thd, set_var *var);
532
  SHOW_TYPE type() { return SHOW_CHAR; }
533 534
  bool check_update_type(Item_result type)
  {
535
    return ((type != STRING_RESULT) && (type != INT_RESULT));
536 537
  }
  bool check_default(enum_var_type type) { return 0; }
538
  bool update(THD *thd, set_var *var);
539
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
540
  virtual void set_default(THD *thd, enum_var_type type)= 0;
541
  virtual CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type)= 0;
542 543 544 545 546 547 548
};

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) {}
549
  void set_default(THD *thd, enum_var_type type);
550
  CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
551 552
};

553
class sys_var_character_set_results :public sys_var_character_set
554 555
{
public:
556
  sys_var_character_set_results(const char *name_arg) :
557 558
    sys_var_character_set(name_arg) 
    { nullable= 1; }
559
  void set_default(THD *thd, enum_var_type type);
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
  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);
579 580
};

581 582 583 584 585 586 587 588 589
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);
};

590
class sys_var_collation_connection :public sys_var_collation
591 592
{
public:
593
  sys_var_collation_connection(const char *name_arg) :sys_var_collation(name_arg) {}
594 595
  bool update(THD *thd, set_var *var);
  void set_default(THD *thd, enum_var_type type);
596
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
597 598
};

599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
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);
};
616

617

618
class sys_var_key_cache_param :public sys_var
619
{
620
protected:
621
  size_t offset;
622
public:
623 624 625
  sys_var_key_cache_param(const char *name_arg, size_t offset_arg)
    :sys_var(name_arg), offset(offset_arg)
  {}
626
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
627 628
  bool check_default(enum_var_type type) { return 1; }
  bool is_struct() { return 1; }
629 630
};

631

632 633 634 635
class sys_var_key_buffer_size :public sys_var_key_cache_param
{
public:
  sys_var_key_buffer_size(const char *name_arg)
636
    :sys_var_key_cache_param(name_arg, offsetof(KEY_CACHE, param_buff_size))
637
  {}
638 639
  bool update(THD *thd, set_var *var);
  SHOW_TYPE type() { return SHOW_LONGLONG; }
640 641 642
};


643
class sys_var_key_cache_long :public sys_var_key_cache_param
644 645
{
public:
646 647 648
  sys_var_key_cache_long(const char *name_arg, size_t offset_arg)
    :sys_var_key_cache_param(name_arg, offset_arg)
  {}
649 650
  bool update(THD *thd, set_var *var);
  SHOW_TYPE type() { return SHOW_LONG; }
651 652 653
};


654
class sys_var_thd_date_time_format :public sys_var_thd
655
{
656
  DATE_TIME_FORMAT *SV::*offset;
657
  timestamp_type date_time_type;
658
public:
659 660 661 662 663
  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)
664 665 666 667 668 669 670
  {}
  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; }
671
  bool check(THD *thd, set_var *var);
672
  bool update(THD *thd, set_var *var);
673
  void update2(THD *thd, enum_var_type type, DATE_TIME_FORMAT *new_value);
674 675 676 677 678
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  void set_default(THD *thd, enum_var_type type);
};


679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
/* 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; }
697
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
698 699 700 701 702 703
  {
    return (*value_ptr_func)(thd);
  }
  SHOW_TYPE type() { return show_type; }
};

704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723
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);
};

724 725 726 727 728 729 730 731 732 733 734 735 736

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);
737
  SHOW_TYPE type() { return SHOW_INT; }
738 739 740
  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
};

741 742 743 744 745 746 747 748 749
/****************************************************************************
  Classes for parsing of the SET command
****************************************************************************/

class set_var_base :public Sql_alloc
{
public:
  set_var_base() {}
  virtual ~set_var_base() {}
750 751
  virtual int check(THD *thd)=0;	/* To check privileges etc. */
  virtual int update(THD *thd)=0;	/* To set the value */
752
  /* light check for PS */
753 754
  virtual int light_check(THD *thd) { return check(thd); }
  virtual bool no_support_one_shot() { return 1; }
755 756 757 758 759 760 761 762 763 764 765 766 767
};


/* 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
  {
768
    CHARSET_INFO *charset;
769
    ulong ulong_value;
770
    ulonglong ulonglong_value;
771
    DATE_TIME_FORMAT *date_time_format;
772
    Time_zone *time_zone;
773
  } save_result;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
774
  LEX_STRING base;			/* for structs */
775

776
  set_var(enum_var_type type_arg, sys_var *var_arg, const LEX_STRING *base_name_arg,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
777 778
	  Item *value_arg)
    :var(var_arg), type(type_arg), base(*base_name_arg)
779 780 781 782 783 784 785 786
  {
    /*
      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;
787
      if (!(value=new Item_string(item->field_name, strlen(item->field_name),
788
				  item->collation.collation)))
789 790 791 792 793
	value=value_arg;			/* Give error message later */
    }
    else
      value=value_arg;
  }
794 795
  int check(THD *thd);
  int update(THD *thd);
796
  int light_check(THD *thd);
797
  bool no_support_one_shot() { return var->no_support_one_shot; }
798 799 800 801 802 803 804 805 806 807 808 809
};


/* 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)
  {}
810 811
  int check(THD *thd);
  int update(THD *thd);
812
  int light_check(THD *thd);
813 814 815 816 817 818 819 820 821 822 823 824
};

/* 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)
  {}
825 826
  int check(THD *thd);
  int update(THD *thd);
827 828 829
};


830 831
/* For SET NAMES and SET CHARACTER SET */

832
class set_var_collation_client: public set_var_base
833
{
834 835
  CHARSET_INFO *character_set_client;
  CHARSET_INFO *character_set_results;
836
  CHARSET_INFO *collation_connection;
837
public:
838
  set_var_collation_client(CHARSET_INFO *client_coll_arg,
839
  			   CHARSET_INFO *connection_coll_arg,
840
  			   CHARSET_INFO *result_coll_arg)
841 842 843
    :character_set_client(client_coll_arg),
     character_set_results(result_coll_arg),
     collation_connection(connection_coll_arg)
844 845 846 847 848 849
  {}
  int check(THD *thd);
  int update(THD *thd);
};


850 851 852 853 854 855 856 857 858 859
/* 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
860 861 862
	     uint name_length_arg, gptr data_arg)
    :name_length(name_length_arg), data(data_arg)
  {
863
    name= my_strdup_with_length((byte*) name_arg, name_length, MYF(MY_WME));
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
864 865
    links->push_back(this);
  }
866 867 868 869 870 871 872 873
  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));
  }
874
  friend bool process_key_caches(int (* func) (const char *name,
875
					       KEY_CACHE *));
876 877
  friend void delete_elements(I_List<NAMED_LIST> *list,
			      void (*free_element)(const char*, gptr));
878 879
};

880 881 882
/* updated in sql_acl.cc */

extern sys_var_thd_bool sys_old_passwords;
883
extern LEX_STRING default_key_cache_base;
884

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
885 886 887 888 889 890 891
/* For sql_yacc */
struct sys_var_with_base
{
  sys_var *var;
  LEX_STRING base_name;
};

892 893 894 895 896 897 898
/*
  Prototypes for helper functions
*/

void set_var_init();
void set_var_free();
sys_var *find_sys_var(const char *str, uint length=0);
899
int sql_set_variables(THD *thd, List<set_var_base> *var_list);
900
bool not_all_support_one_shot(List<set_var_base> *var_list);
901
void fix_delay_key_write(THD *thd, enum_var_type type);
902
ulong fix_sql_mode(ulong sql_mode);
903
extern sys_var_str sys_charset_system;
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
904 905
extern sys_var_str sys_init_connect;
extern sys_var_str sys_init_slave;
906
extern sys_var_thd_time_zone sys_time_zone;
907
CHARSET_INFO *get_old_charset_by_name(const char *old_name);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
908 909
gptr find_named(I_List<NAMED_LIST> *list, const char *name, uint length,
		NAMED_LIST **found);
910 911

/* key_cache functions */
912 913 914 915
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 *));
916 917
void delete_elements(I_List<NAMED_LIST> *list,
		     void (*free_element)(const char*, gptr));