开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
set_var.h
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：27k
源码类别：

MySQL数据库

开发平台：

Visual C++

set_var.h：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /* Classes to support the SET command */
  19. #ifdef USE_PRAGMA_INTERFACE
  20. #pragma interface /* gcc class implementation */
  21. #endif
  23. /****************************************************************************
  24.   Variables that are changable runtime are declared using the
  25.   following classes
  26. ****************************************************************************/
  28. class sys_var;
  29. class set_var;
  30. typedef struct system_variables SV;
  31. extern TYPELIB bool_typelib, delay_key_write_typelib, sql_mode_typelib;
  33. typedef int (*sys_check_func)(THD *,  set_var *);
  34. typedef bool (*sys_update_func)(THD *, set_var *);
  35. typedef void (*sys_after_update_func)(THD *,enum_var_type);
  36. typedef void (*sys_set_default_func)(THD *, enum_var_type);
  37. typedef byte *(*sys_value_ptr_func)(THD *thd);
  39. class sys_var
  40. {
  41. public:
  42.   struct my_option *option_limits; /* Updated by by set_var_init() */
  43.   uint name_length; /* Updated by by set_var_init() */
  44.   const char *name;
  45.   
  46.   sys_after_update_func after_update;
  47. #if MYSQL_VERSION_ID < 50000
  48.   bool no_support_one_shot;
  49. #endif
  50.   sys_var(const char *name_arg)
  51.     :name(name_arg), after_update(0)
  52. #if MYSQL_VERSION_ID < 50000
  53.     , no_support_one_shot(1)
  54. #endif
  55.     {}
  56.   sys_var(const char *name_arg,sys_after_update_func func)
  57.     :name(name_arg), after_update(func)
  58. #if MYSQL_VERSION_ID < 50000
  59.     , no_support_one_shot(1)
  60. #endif
  61.   {}
  62.   virtual ~sys_var() {}
  63.   virtual bool check(THD *thd, set_var *var);
  64.   bool check_enum(THD *thd, set_var *var, TYPELIB *enum_names);
  65.   bool check_set(THD *thd, set_var *var, TYPELIB *enum_names);
  66.   virtual bool update(THD *thd, set_var *var)=0;
  67.   virtual void set_default(THD *thd, enum_var_type type) {}
  68.   virtual SHOW_TYPE type() { return SHOW_UNDEF; }
  69.   virtual byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  70.   { return 0; }
  71.   virtual bool check_type(enum_var_type type)
  72.   { return type != OPT_GLOBAL; } /* Error if not GLOBAL */
  73.   virtual bool check_update_type(Item_result type)
  74.   { return type != INT_RESULT; } /* Assume INT */
  75.   virtual bool check_default(enum_var_type type)
  76.   { return option_limits == 0; }
  77.   Item *item(THD *thd, enum_var_type type, LEX_STRING *base);
  78.   virtual bool is_struct() { return 0; }
  79. };
  82. class sys_var_long_ptr :public sys_var
  83. {
  84. public:
  85.   ulong *value;
  86.   sys_var_long_ptr(const char *name_arg, ulong *value_ptr)
  87.     :sys_var(name_arg),value(value_ptr) {}
  88.   sys_var_long_ptr(const char *name_arg, ulong *value_ptr,
  89.    sys_after_update_func func)
  90.     :sys_var(name_arg,func), value(value_ptr) {}
  91.   bool check(THD *thd, set_var *var);
  92.   bool update(THD *thd, set_var *var);
  93.   void set_default(THD *thd, enum_var_type type);
  94.   SHOW_TYPE type() { return SHOW_LONG; }
  95.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  96.   { return (byte*) value; }
  97. };
  100. class sys_var_ulonglong_ptr :public sys_var
  101. {
  102. public:
  103.   ulonglong *value;
  104.   sys_var_ulonglong_ptr(const char *name_arg, ulonglong *value_ptr)
  105.     :sys_var(name_arg),value(value_ptr) {}
  106.   sys_var_ulonglong_ptr(const char *name_arg, ulonglong *value_ptr,
  107.        sys_after_update_func func)
  108.     :sys_var(name_arg,func), value(value_ptr) {}
  109.   bool update(THD *thd, set_var *var);
  110.   void set_default(THD *thd, enum_var_type type);
  111.   SHOW_TYPE type() { return SHOW_LONGLONG; }
  112.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  113.   { return (byte*) value; }
  114. };
  117. class sys_var_bool_ptr :public sys_var
  118. {
  119. public:
  120.   my_bool *value;
  121.   sys_var_bool_ptr(const char *name_arg, my_bool *value_arg)
  122.     :sys_var(name_arg),value(value_arg)
  123.   {}
  124.   bool check(THD *thd, set_var *var)
  125.   {
  126.     return check_enum(thd, var, &bool_typelib);
  127.   }
  128.   bool update(THD *thd, set_var *var);
  129.   void set_default(THD *thd, enum_var_type type);
  130.   SHOW_TYPE type() { return SHOW_MY_BOOL; }
  131.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  132.   { return (byte*) value; }
  133.   bool check_update_type(Item_result type) { return 0; }
  134. };
  137. class sys_var_str :public sys_var
  138. {
  139. public:
  140.   char *value; // Pointer to allocated string
  141.   uint value_length;
  142.   sys_check_func check_func;
  143.   sys_update_func update_func;
  144.   sys_set_default_func set_default_func;
  145.   sys_var_str(const char *name_arg,
  146.       sys_check_func check_func_arg,
  147.       sys_update_func update_func_arg,
  148.       sys_set_default_func set_default_func_arg,
  149.               char *value_arg)
  150.     :sys_var(name_arg), value(value_arg), check_func(check_func_arg),
  151.     update_func(update_func_arg),set_default_func(set_default_func_arg)
  152.   {}
  153.   bool check(THD *thd, set_var *var);
  154.   bool update(THD *thd, set_var *var)
  155.   {
  156.     return (*update_func)(thd, var);
  157.   }
  158.   void set_default(THD *thd, enum_var_type type)
  159.   {
  160.     (*set_default_func)(thd, type);
  161.   }
  162.   SHOW_TYPE type() { return SHOW_CHAR; }
  163.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  164.   { return (byte*) value; }
  165.   bool check_update_type(Item_result type)
  166.   {
  167.     return type != STRING_RESULT; /* Only accept strings */
  168.   }
  169.   bool check_default(enum_var_type type) { return 0; }
  170. };
  173. class sys_var_const_str :public sys_var
  174. {
  175. public:
  176.   char *value; // Pointer to const value
  177.   sys_var_const_str(const char *name_arg, const char *value_arg)
  178.     :sys_var(name_arg), value((char*) value_arg)
  179.   {}
  180.   bool check(THD *thd, set_var *var)
  181.   {
  182.     return 1;
  183.   }
  184.   bool update(THD *thd, set_var *var)
  185.   {
  186.     return 1;
  187.   }
  188.   SHOW_TYPE type() { return SHOW_CHAR; }
  189.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  190.   {
  191.     return (byte*) value;
  192.   }
  193.   bool check_update_type(Item_result type)
  194.   {
  195.     return 1;
  196.   }
  197.   bool check_default(enum_var_type type) { return 1; }
  198. };
  201. class sys_var_enum :public sys_var
  202. {
  203.   uint *value; 
  204.   TYPELIB *enum_names;
  205. public:
  206.   sys_var_enum(const char *name_arg, uint *value_arg,
  207.        TYPELIB *typelib, sys_after_update_func func)
  208.     :sys_var(name_arg,func), value(value_arg), enum_names(typelib)
  209.   {}
  210.   bool check(THD *thd, set_var *var)
  211.   {
  212.     return check_enum(thd, var, enum_names);
  213.   }
  214.   bool update(THD *thd, set_var *var);
  215.   SHOW_TYPE type() { return SHOW_CHAR; }
  216.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  217.   bool check_update_type(Item_result type) { return 0; }
  218. };
  221. class sys_var_thd :public sys_var
  222. {
  223. public:
  224.   sys_var_thd(const char *name_arg)
  225.     :sys_var(name_arg)
  226.   {}
  227.   sys_var_thd(const char *name_arg, sys_after_update_func func)
  228.     :sys_var(name_arg,func)
  229.   {}
  230.   bool check_type(enum_var_type type) { return 0; }
  231.   bool check_default(enum_var_type type)
  232.   {
  233.     return type == OPT_GLOBAL && !option_limits;
  234.   }
  235. };
  238. class sys_var_thd_ulong :public sys_var_thd
  239. {
  240.   sys_check_func check_func;
  241. public:
  242.   ulong SV::*offset;
  243.   sys_var_thd_ulong(const char *name_arg, ulong SV::*offset_arg)
  244.     :sys_var_thd(name_arg), check_func(0), offset(offset_arg)
  245.   {}
  246.   sys_var_thd_ulong(const char *name_arg, ulong SV::*offset_arg,
  247.    sys_check_func c_func, sys_after_update_func au_func)
  248.     :sys_var_thd(name_arg,au_func), check_func(c_func), offset(offset_arg)
  249.   {}
  250.   bool check(THD *thd, set_var *var);
  251.   bool update(THD *thd, set_var *var);
  252.   void set_default(THD *thd, enum_var_type type);
  253.   SHOW_TYPE type() { return SHOW_LONG; }
  254.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  255. };
  258. class sys_var_thd_ha_rows :public sys_var_thd
  259. {
  260. public:
  261.   ha_rows SV::*offset;
  262.   sys_var_thd_ha_rows(const char *name_arg, ha_rows SV::*offset_arg)
  263.     :sys_var_thd(name_arg), offset(offset_arg)
  264.   {}
  265.   sys_var_thd_ha_rows(const char *name_arg, ha_rows SV::*offset_arg,
  266.       sys_after_update_func func)
  267.     :sys_var_thd(name_arg,func), offset(offset_arg)
  268.   {}
  269.   bool update(THD *thd, set_var *var);
  270.   void set_default(THD *thd, enum_var_type type);
  271.   SHOW_TYPE type() { return SHOW_HA_ROWS; }
  272.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  273. };
  276. class sys_var_thd_ulonglong :public sys_var_thd
  277. {
  278. public:
  279.   ulonglong SV::*offset;
  280.   bool only_global;
  281.   sys_var_thd_ulonglong(const char *name_arg, ulonglong SV::*offset_arg)
  282.     :sys_var_thd(name_arg), offset(offset_arg)
  283.   {}
  284.   sys_var_thd_ulonglong(const char *name_arg, ulonglong SV::*offset_arg,
  285. sys_after_update_func func, bool only_global_arg)
  286.     :sys_var_thd(name_arg, func), offset(offset_arg),
  287.     only_global(only_global_arg)
  288.   {}
  289.   bool update(THD *thd, set_var *var);
  290.   void set_default(THD *thd, enum_var_type type);
  291.   SHOW_TYPE type() { return SHOW_LONGLONG; }
  292.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  293.   bool check_default(enum_var_type type)
  294.   {
  295.     return type == OPT_GLOBAL && !option_limits;
  296.   }
  297.   bool check_type(enum_var_type type)
  298.   {
  299.     return (only_global && type != OPT_GLOBAL);
  300.   }
  301. };
  304. class sys_var_thd_bool :public sys_var_thd
  305. {
  306. public:
  307.   my_bool SV::*offset;
  308.   sys_var_thd_bool(const char *name_arg, my_bool SV::*offset_arg)
  309.     :sys_var_thd(name_arg), offset(offset_arg)
  310.   {}
  311.   sys_var_thd_bool(const char *name_arg, my_bool SV::*offset_arg,
  312.    sys_after_update_func func)
  313.     :sys_var_thd(name_arg,func), offset(offset_arg)
  314.   {}
  315.   bool update(THD *thd, set_var *var);
  316.   void set_default(THD *thd, enum_var_type type);
  317.   SHOW_TYPE type() { return SHOW_MY_BOOL; }
  318.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  319.   bool check(THD *thd, set_var *var)
  320.   {
  321.     return check_enum(thd, var, &bool_typelib);
  322.   }
  323.   bool check_update_type(Item_result type) { return 0; }
  324. };
  327. class sys_var_thd_enum :public sys_var_thd
  328. {
  329. protected:
  330.   ulong SV::*offset;
  331.   TYPELIB *enum_names;
  332. public:
  333.   sys_var_thd_enum(const char *name_arg, ulong SV::*offset_arg,
  334.    TYPELIB *typelib)
  335.     :sys_var_thd(name_arg), offset(offset_arg), enum_names(typelib)
  336.   {}
  337.   sys_var_thd_enum(const char *name_arg, ulong SV::*offset_arg,
  338.    TYPELIB *typelib,
  339.    sys_after_update_func func)
  340.     :sys_var_thd(name_arg,func), offset(offset_arg), enum_names(typelib)
  341.   {}
  342.   bool check(THD *thd, set_var *var)
  343.   {
  344.     return check_enum(thd, var, enum_names);
  345.   }
  346.   bool update(THD *thd, set_var *var);
  347.   void set_default(THD *thd, enum_var_type type);
  348.   SHOW_TYPE type() { return SHOW_CHAR; }
  349.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  350.   bool check_update_type(Item_result type) { return 0; }
  351. };
  354. extern void fix_sql_mode_var(THD *thd, enum_var_type type);
  356. class sys_var_thd_sql_mode :public sys_var_thd_enum
  357. {
  358. public:
  359.   sys_var_thd_sql_mode(const char *name_arg, ulong SV::*offset_arg)
  360.     :sys_var_thd_enum(name_arg, offset_arg, &sql_mode_typelib,
  361.       fix_sql_mode_var)
  362.   {}
  363.   bool check(THD *thd, set_var *var)
  364.   {
  365.     return check_set(thd, var, enum_names);
  366.   }
  367.   void set_default(THD *thd, enum_var_type type);
  368.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  369. };
  372. class sys_var_thd_storage_engine :public sys_var_thd
  373. {
  374. protected:
  375.   ulong SV::*offset;
  376. public:
  377.   sys_var_thd_storage_engine(const char *name_arg, ulong SV::*offset_arg)
  378.     :sys_var_thd(name_arg), offset(offset_arg)
  379.   {}
  380.   bool check(THD *thd, set_var *var);
  381. SHOW_TYPE type() { return SHOW_CHAR; }
  382.   bool check_update_type(Item_result type)
  383.   {
  384.     return type != STRING_RESULT; /* Only accept strings */
  385.   }
  386.   void set_default(THD *thd, enum_var_type type);
  387.   bool update(THD *thd, set_var *var);
  388.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  389. };
  391. class sys_var_thd_table_type :public sys_var_thd_storage_engine
  392. {
  393. public:
  394.   sys_var_thd_table_type(const char *name_arg, ulong SV::*offset_arg)
  395.     :sys_var_thd_storage_engine(name_arg, offset_arg)
  396.   {}
  397.   void warn_deprecated(THD *thd);
  398.   void set_default(THD *thd, enum_var_type type);
  399.   bool update(THD *thd, set_var *var);
  400. };
  402. class sys_var_thd_bit :public sys_var_thd
  403. {
  404.   sys_check_func check_func;
  405.   sys_update_func update_func;
  406. public:
  407.   ulong bit_flag;
  408.   bool reverse;
  409.   sys_var_thd_bit(const char *name_arg, 
  410.                   sys_check_func c_func, sys_update_func u_func,
  411.                   ulong bit, bool reverse_arg=0)
  412.     :sys_var_thd(name_arg), check_func(c_func), update_func(u_func),
  413.     bit_flag(bit), reverse(reverse_arg)
  414.   {}
  415.   bool check(THD *thd, set_var *var);
  416.   bool update(THD *thd, set_var *var);
  417.   bool check_update_type(Item_result type) { return 0; }
  418.   bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
  419.   SHOW_TYPE type() { return SHOW_MY_BOOL; }
  420.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  421. };
  424. /* some variables that require special handling */
  426. class sys_var_timestamp :public sys_var
  427. {
  428. public:
  429.   sys_var_timestamp(const char *name_arg) :sys_var(name_arg) {}
  430.   bool update(THD *thd, set_var *var);
  431.   void set_default(THD *thd, enum_var_type type);
  432.   bool check_type(enum_var_type type)    { return type == OPT_GLOBAL; }
  433.   bool check_default(enum_var_type type) { return 0; }
  434.   SHOW_TYPE type() { return SHOW_LONG; }
  435.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  436. };
  439. class sys_var_last_insert_id :public sys_var
  440. {
  441. public:
  442.   sys_var_last_insert_id(const char *name_arg) :sys_var(name_arg) {}
  443.   bool update(THD *thd, set_var *var);
  444.   bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
  445.   SHOW_TYPE type() { return SHOW_LONGLONG; }
  446.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  447. };
  450. class sys_var_insert_id :public sys_var
  451. {
  452. public:
  453.   sys_var_insert_id(const char *name_arg) :sys_var(name_arg) {}
  454.   bool update(THD *thd, set_var *var);
  455.   bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
  456.   SHOW_TYPE type() { return SHOW_LONGLONG; }
  457.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  458. };
  461. #ifdef HAVE_REPLICATION
  462. class sys_var_slave_skip_counter :public sys_var
  463. {
  464. public:
  465.   sys_var_slave_skip_counter(const char *name_arg) :sys_var(name_arg) {}
  466.   bool check(THD *thd, set_var *var);
  467.   bool update(THD *thd, set_var *var);
  468.   bool check_type(enum_var_type type) { return type != OPT_GLOBAL; }
  469.   /*
  470.     We can't retrieve the value of this, so we don't have to define
  471.     type() or value_ptr()
  472.   */
  473. };
  475. class sys_var_sync_binlog_period :public sys_var_long_ptr
  476. {
  477. public:
  478.   sys_var_sync_binlog_period(const char *name_arg, ulong *value_ptr)
  479.     :sys_var_long_ptr(name_arg,value_ptr) {}
  480.   bool update(THD *thd, set_var *var);
  481. };
  482. #endif
  484. class sys_var_rand_seed1 :public sys_var
  485. {
  486. public:
  487.   sys_var_rand_seed1(const char *name_arg) :sys_var(name_arg) {}
  488.   bool update(THD *thd, set_var *var);
  489.   bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
  490. };
  492. class sys_var_rand_seed2 :public sys_var
  493. {
  494. public:
  495.   sys_var_rand_seed2(const char *name_arg) :sys_var(name_arg) {}
  496.   bool update(THD *thd, set_var *var);
  497.   bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
  498. };
  501. class sys_var_collation :public sys_var_thd
  502. {
  503. public:
  504.   sys_var_collation(const char *name_arg) :sys_var_thd(name_arg)
  505.     {
  506. #if MYSQL_VERSION_ID < 50000
  507.     no_support_one_shot= 0;
  508. #endif
  509.     }
  510.   bool check(THD *thd, set_var *var);
  511. SHOW_TYPE type() { return SHOW_CHAR; }
  512.   bool check_update_type(Item_result type)
  513.   {
  514.     return ((type != STRING_RESULT) && (type != INT_RESULT));
  515.   }
  516.   bool check_default(enum_var_type type) { return 0; }
  517.   virtual void set_default(THD *thd, enum_var_type type)= 0;
  518. };
  520. class sys_var_character_set :public sys_var_thd
  521. {
  522. public:
  523.   bool nullable;
  524.   sys_var_character_set(const char *name_arg) :
  525.     sys_var_thd(name_arg)
  526.   {
  527.     nullable= 0;
  528. #if MYSQL_VERSION_ID < 50000
  529.     /*
  530.       In fact only almost all variables derived from sys_var_character_set
  531.       support ONE_SHOT; character_set_results doesn't. But that's good enough.
  532.     */
  533.     no_support_one_shot= 0;
  534. #endif
  535.   }
  536.   bool check(THD *thd, set_var *var);
  537.   SHOW_TYPE type() { return SHOW_CHAR; }
  538.   bool check_update_type(Item_result type)
  539.   {
  540.     return ((type != STRING_RESULT) && (type != INT_RESULT));
  541.   }
  542.   bool check_default(enum_var_type type) { return 0; }
  543.   bool update(THD *thd, set_var *var);
  544.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  545.   virtual void set_default(THD *thd, enum_var_type type)= 0;
  546.   virtual CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type)= 0;
  547. };
  549. class sys_var_character_set_client :public sys_var_character_set
  550. {
  551. public:
  552.   sys_var_character_set_client(const char *name_arg) :
  553.     sys_var_character_set(name_arg) {}
  554.   void set_default(THD *thd, enum_var_type type);
  555.   CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
  556. };
  558. class sys_var_character_set_results :public sys_var_character_set
  559. {
  560. public:
  561.   sys_var_character_set_results(const char *name_arg) :
  562.     sys_var_character_set(name_arg) 
  563.     { nullable= 1; }
  564.   void set_default(THD *thd, enum_var_type type);
  565.   CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
  566. };
  568. class sys_var_character_set_server :public sys_var_character_set
  569. {
  570. public:
  571.   sys_var_character_set_server(const char *name_arg) :
  572.     sys_var_character_set(name_arg) {}
  573. #if defined(HAVE_REPLICATION) && (MYSQL_VERSION_ID < 50000)
  574.   bool check(THD *thd, set_var *var);
  575. #endif
  576.   void set_default(THD *thd, enum_var_type type);
  577.   CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
  578. };
  580. class sys_var_character_set_database :public sys_var_character_set
  581. {
  582. public:
  583.   sys_var_character_set_database(const char *name_arg) :
  584.     sys_var_character_set(name_arg) {}
  585.   void set_default(THD *thd, enum_var_type type);
  586.   CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
  587. };
  589. class sys_var_character_set_connection :public sys_var_character_set
  590. {
  591. public:
  592.   sys_var_character_set_connection(const char *name_arg) :
  593.     sys_var_character_set(name_arg) {}
  594.   void set_default(THD *thd, enum_var_type type);
  595.   CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
  596. };
  598. class sys_var_collation_connection :public sys_var_collation
  599. {
  600. public:
  601.   sys_var_collation_connection(const char *name_arg) :sys_var_collation(name_arg) {}
  602.   bool update(THD *thd, set_var *var);
  603.   void set_default(THD *thd, enum_var_type type);
  604.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  605. };
  607. class sys_var_collation_server :public sys_var_collation
  608. {
  609. public:
  610.   sys_var_collation_server(const char *name_arg) :sys_var_collation(name_arg) {}
  611. #if defined(HAVE_REPLICATION) && (MYSQL_VERSION_ID < 50000)
  612.   bool check(THD *thd, set_var *var);
  613. #endif
  614.   bool update(THD *thd, set_var *var);
  615.   void set_default(THD *thd, enum_var_type type);
  616.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  617. };
  619. class sys_var_collation_database :public sys_var_collation
  620. {
  621. public:
  622.   sys_var_collation_database(const char *name_arg) :sys_var_collation(name_arg) {}
  623.   bool update(THD *thd, set_var *var);
  624.   void set_default(THD *thd, enum_var_type type);
  625.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  626. };
  629. class sys_var_key_cache_param :public sys_var
  630. {
  631. protected:
  632.   size_t offset;
  633. public:
  634.   sys_var_key_cache_param(const char *name_arg, size_t offset_arg)
  635.     :sys_var(name_arg), offset(offset_arg)
  636.   {}
  637.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  638.   bool check_default(enum_var_type type) { return 1; }
  639.   bool is_struct() { return 1; }
  640. };
  643. class sys_var_key_buffer_size :public sys_var_key_cache_param
  644. {
  645. public:
  646.   sys_var_key_buffer_size(const char *name_arg)
  647.     :sys_var_key_cache_param(name_arg, offsetof(KEY_CACHE, param_buff_size))
  648.   {}
  649.   bool update(THD *thd, set_var *var);
  650.   SHOW_TYPE type() { return SHOW_LONGLONG; }
  651. };
  654. class sys_var_key_cache_long :public sys_var_key_cache_param
  655. {
  656. public:
  657.   sys_var_key_cache_long(const char *name_arg, size_t offset_arg)
  658.     :sys_var_key_cache_param(name_arg, offset_arg)
  659.   {}
  660.   bool update(THD *thd, set_var *var);
  661.   SHOW_TYPE type() { return SHOW_LONG; }
  662. };
  665. class sys_var_thd_date_time_format :public sys_var_thd
  666. {
  667.   DATE_TIME_FORMAT *SV::*offset;
  668.   timestamp_type date_time_type;
  669. public:
  670.   sys_var_thd_date_time_format(const char *name_arg,
  671.        DATE_TIME_FORMAT *SV::*offset_arg,
  672.        timestamp_type date_time_type_arg)
  673.     :sys_var_thd(name_arg), offset(offset_arg),
  674.     date_time_type(date_time_type_arg)
  675.   {}
  676.   SHOW_TYPE type() { return SHOW_CHAR; }
  677.   bool check_update_type(Item_result type)
  678.   {
  679.     return type != STRING_RESULT; /* Only accept strings */
  680.   }
  681.   bool check_default(enum_var_type type) { return 0; }
  682.   bool check(THD *thd, set_var *var);
  683.   bool update(THD *thd, set_var *var);
  684.   void update2(THD *thd, enum_var_type type, DATE_TIME_FORMAT *new_value);
  685.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  686.   void set_default(THD *thd, enum_var_type type);
  687. };
  690. /* Variable that you can only read from */
  692. class sys_var_readonly: public sys_var
  693. {
  694. public:
  695.   enum_var_type var_type;
  696.   SHOW_TYPE show_type;
  697.   sys_value_ptr_func value_ptr_func;
  698.   sys_var_readonly(const char *name_arg, enum_var_type type,
  699.    SHOW_TYPE show_type_arg,
  700.    sys_value_ptr_func value_ptr_func_arg)
  701.     :sys_var(name_arg), var_type(type), 
  702.        show_type(show_type_arg), value_ptr_func(value_ptr_func_arg)
  703.   {}
  704.   bool update(THD *thd, set_var *var) { return 1; }
  705.   bool check_default(enum_var_type type) { return 1; }
  706.   bool check_type(enum_var_type type) { return type != var_type; }
  707.   bool check_update_type(Item_result type) { return 1; }
  708.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
  709.   {
  710.     return (*value_ptr_func)(thd);
  711.   }
  712.   SHOW_TYPE type() { return show_type; }
  713. };
  715. class sys_var_thd_time_zone :public sys_var_thd
  716. {
  717. public:
  718.   sys_var_thd_time_zone(const char *name_arg):
  719.     sys_var_thd(name_arg) 
  720.   {
  721. #if MYSQL_VERSION_ID < 50000
  722.     no_support_one_shot= 0;
  723. #endif
  724.   }
  725.   bool check(THD *thd, set_var *var);
  726.   SHOW_TYPE type() { return SHOW_CHAR; }
  727.   bool check_update_type(Item_result type)
  728.   {
  729.     return type != STRING_RESULT; /* Only accept strings */
  730.   }
  731.   bool check_default(enum_var_type type) { return 0; }
  732.   bool update(THD *thd, set_var *var);
  733.   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
  734.   virtual void set_default(THD *thd, enum_var_type type);
  735. };
  737. /****************************************************************************
  738.   Classes for parsing of the SET command
  739. ****************************************************************************/
  741. class set_var_base :public Sql_alloc
  742. {
  743. public:
  744.   set_var_base() {}
  745.   virtual ~set_var_base() {}
  746.   virtual int check(THD *thd)=0; /* To check privileges etc. */
  747.   virtual int update(THD *thd)=0; /* To set the value */
  748.   /* light check for PS */
  749.   virtual int light_check(THD *thd) { return check(thd); }
  750. #if MYSQL_VERSION_ID < 50000
  751.   virtual bool no_support_one_shot() { return 1; }
  752. #endif
  753. };
  756. /* MySQL internal variables, like query_cache_size */
  758. class set_var :public set_var_base
  759. {
  760. public:
  761.   sys_var *var;
  762.   Item *value;
  763.   enum_var_type type;
  764.   union
  765.   {
  766.     CHARSET_INFO *charset;
  767.     ulong ulong_value;
  768.     ulonglong ulonglong_value;
  769.     DATE_TIME_FORMAT *date_time_format;
  770.     Time_zone *time_zone;
  771.   } save_result;
  772.   LEX_STRING base; /* for structs */
  774.   set_var(enum_var_type type_arg, sys_var *var_arg, LEX_STRING *base_name_arg,
  775.   Item *value_arg)
  776.     :var(var_arg), type(type_arg), base(*base_name_arg)
  777.   {
  778.     /*
  779.       If the set value is a field, change it to a string to allow things like
  780.       SET table_type=MYISAM;
  781.     */
  782.     if (value_arg && value_arg->type() == Item::FIELD_ITEM)
  783.     {
  784.       Item_field *item= (Item_field*) value_arg;
  785.       if (!(value=new Item_string(item->field_name, strlen(item->field_name),
  786.   item->collation.collation)))
  787. value=value_arg; /* Give error message later */
  788.     }
  789.     else
  790.       value=value_arg;
  791.   }
  792.   int check(THD *thd);
  793.   int update(THD *thd);
  794.   int light_check(THD *thd);
  795. #if MYSQL_VERSION_ID < 50000
  796.   bool no_support_one_shot() { return var->no_support_one_shot; }
  797. #endif
  798. };
  801. /* User variables like @my_own_variable */
  803. class set_var_user: public set_var_base
  804. {
  805.   Item_func_set_user_var *user_var_item;
  806. public:
  807.   set_var_user(Item_func_set_user_var *item)
  808.     :user_var_item(item)
  809.   {}
  810.   int check(THD *thd);
  811.   int update(THD *thd);
  812.   int light_check(THD *thd);
  813. };
  815. /* For SET PASSWORD */
  817. class set_var_password: public set_var_base
  818. {
  819.   LEX_USER *user;
  820.   char *password;
  821. public:
  822.   set_var_password(LEX_USER *user_arg,char *password_arg)
  823.     :user(user_arg), password(password_arg)
  824.   {}
  825.   int check(THD *thd);
  826.   int update(THD *thd);
  827. };
  830. /* For SET NAMES and SET CHARACTER SET */
  832. class set_var_collation_client: public set_var_base
  833. {
  834.   CHARSET_INFO *character_set_client;
  835.   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.     :character_set_client(client_coll_arg),
  842.      character_set_results(result_coll_arg),
  843.      collation_connection(connection_coll_arg)
  844.   {}
  845.   int check(THD *thd);
  846.   int update(THD *thd);
  847. };
  850. /* Named lists (used for keycaches) */
  852. class NAMED_LIST :public ilink
  853. {
  854.   const char *name;
  855.   uint name_length;
  856. public:
  857.   gptr data;
  859.   NAMED_LIST(I_List<NAMED_LIST> *links, const char *name_arg,
  860.      uint name_length_arg, gptr data_arg)
  861.     :name_length(name_length_arg), data(data_arg)
  862.   {
  863.     name= my_strdup_with_length((byte*) name_arg, name_length, MYF(MY_WME));
  864.     links->push_back(this);
  865.   }
  866.   inline bool cmp(const char *name_cmp, uint length)
  867.   {
  868.     return length == name_length && !memcmp(name, name_cmp, length);
  869.   }
  870.   ~NAMED_LIST()
  871.   {
  872.     my_free((char*) name, MYF(0));
  873.   }
  874.   friend bool process_key_caches(int (* func) (const char *name,
  875.        KEY_CACHE *));
  876.   friend void delete_elements(I_List<NAMED_LIST> *list,
  877.       void (*free_element)(const char*, gptr));
  878. };
  880. /* updated in sql_acl.cc */
  882. extern sys_var_thd_bool sys_old_passwords;
  883. extern LEX_STRING default_key_cache_base;
  885. /* For sql_yacc */
  886. struct sys_var_with_base
  887. {
  888.   sys_var *var;
  889.   LEX_STRING base_name;
  890. };
  892. /*
  893.   Prototypes for helper functions
  894. */
  896. void set_var_init();
  897. void set_var_free();
  898. 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;
  904. extern sys_var_str sys_init_connect;
  905. 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);
  908. gptr find_named(I_List<NAMED_LIST> *list, const char *name, uint length,
  909. NAMED_LIST **found);
  911. /* key_cache functions */
  912. KEY_CACHE *get_key_cache(LEX_STRING *cache_name);
  913. KEY_CACHE *get_or_create_key_cache(const char *name, uint length);
  914. void free_key_cache(const char *name, KEY_CACHE *key_cache);
  915. bool process_key_caches(int (* func) (const char *name, KEY_CACHE *));
  916. void delete_elements(I_List<NAMED_LIST> *list,
  917.      void (*free_element)(const char*, gptr));