WL#2936

"Server Variables for Plugins"
  Implement support for plugins to declare server variables.
  Demonstrate functionality by removing InnoDB specific code from sql/*
  New feature for HASH - HASH_UNIQUE flag
  New feature for DYNAMIC_ARRAY - initializer accepts preallocated ptr.
  Completed support for plugin reference counting.

include/hash.h

@@ -27,6 +27,9 @@ extern "C" {
  */
 #define HASH_OVERHEAD (sizeof(char*)*2)
 
+/* flags for hash_init */
+#define HASH_UNIQUE     1       /* hash_insert fails on duplicate key */
+
 typedef byte *(*hash_get_key)(const byte *,uint*,my_bool);
 typedef void (*hash_free_key)(void *);
 

include/my_getopt.h

@@ -29,12 +29,16 @@ C_MODE_START
 #define GET_STR        9
 #define GET_STR_ALLOC 10
 #define GET_DISABLED  11
+#define GET_ENUM      12
+#define GET_SET       13
 
 #define GET_ASK_ADDR	 128
 #define GET_TYPE_MASK	 127
 
 enum get_opt_arg_type { NO_ARG, OPT_ARG, REQUIRED_ARG };
 
+struct st_typelib;
+
 struct my_option
 {
   const char *name;                     /* Name of the option */
@@ -42,7 +46,7 @@ struct my_option
   const char *comment;                  /* option comment, for autom. --help */
   gptr       *value;                    /* The variable value */
   gptr       *u_max_value;              /* The user def. max variable value */
-  const char **str_values;              /* Pointer to possible values */
+  struct st_typelib *typelib;           /* Pointer to possible values */
   ulong     var_type;
   enum get_opt_arg_type arg_type;
   longlong   def_value;                 /* Default value */
@@ -50,7 +54,7 @@ struct my_option
   longlong   max_value;                 /* Max allowed value */
   longlong   sub_size;                  /* Subtract this from given value */
   long       block_size;                /* Value should be a mult. of this */
-  int        app_type;                  /* To be used by an application */
+  long       app_type;                  /* To be used by an application */
 };
 
 typedef my_bool (* my_get_one_option) (int, const struct my_option *, char * );
@@ -58,6 +62,7 @@ typedef void (* my_error_reporter) (enum loglevel level, const char *format, ...
 
 extern char *disabled_my_option;
 extern my_bool my_getopt_print_errors;
+extern my_bool my_getopt_skip_unknown;
 extern my_error_reporter my_getopt_error_reporter;
 
 extern int handle_options (int *argc, char ***argv, 

include/my_sys.h

@@ -758,8 +758,15 @@ extern my_bool real_open_cached_file(IO_CACHE *cache);
 extern void close_cached_file(IO_CACHE *cache);
 File create_temp_file(char *to, const char *dir, const char *pfx,
 		      int mode, myf MyFlags);
-#define my_init_dynamic_array(A,B,C,D) init_dynamic_array(A,B,C,D CALLER_INFO)
+#define my_init_dynamic_array(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D CALLER_INFO)
-#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array(A,B,C,D ORIG_CALLER_INFO)
+#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D ORIG_CALLER_INFO)
+#define my_init_dynamic_array2(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E CALLER_INFO)
+#define my_init_dynamic_array2_ci(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E ORIG_CALLER_INFO)
+extern my_bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint element_size,
+                                   void *init_buffer, uint init_alloc, 
+                                   uint alloc_increment
+                                   CALLER_INFO_PROTO);
+/* init_dynamic_array() function is deprecated */
 extern my_bool init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size,
                                   uint init_alloc,uint alloc_increment
                                   CALLER_INFO_PROTO);

include/mysql.h

@@ -67,7 +67,6 @@ typedef int my_socket;
 #include "mysql_version.h"
 #include "mysql_com.h"
 #include "mysql_time.h"
-#include "typelib.h"
 
 #include "my_list.h" /* for LISTs used in 'MYSQL' and 'MYSQL_STMT' */
 
@@ -126,6 +125,8 @@ typedef unsigned long long my_ulonglong;
 #endif
 #endif
 
+#include "typelib.h"
+
 #define MYSQL_COUNT_ERROR (~(my_ulonglong) 0)
 
 /* backward compatibility define - to be removed eventually */

include/mysql/plugin.h

@@ -16,6 +16,15 @@
 #ifndef _my_plugin_h
 #define _my_plugin_h
 
+#ifdef __cplusplus
+class THD;
+class Item;
+#define MYSQL_THD THD*
+#else
+#define MYSQL_THD void*
+#endif
+
+
 /*************************************************************************
   Plugin API. Common for all plugin types.
 */
@@ -85,7 +94,225 @@ struct st_mysql_show_var {
 };
 
 #define SHOW_VAR_FUNC_BUFF_SIZE 1024
-typedef int (*mysql_show_var_func)(void *, struct st_mysql_show_var*, char *);
+typedef int (*mysql_show_var_func)(MYSQL_THD, struct st_mysql_show_var*, char *);
+
+
+/*
+  declarations for server variables and command line options
+*/
+
+
+#define PLUGIN_VAR_BOOL         0x0001
+#define PLUGIN_VAR_INT          0x0002
+#define PLUGIN_VAR_LONG         0x0003
+#define PLUGIN_VAR_LONGLONG     0x0004
+#define PLUGIN_VAR_STR          0x0005
+#define PLUGIN_VAR_ENUM         0x0006
+#define PLUGIN_VAR_SET          0x0007
+#define PLUGIN_VAR_UNSIGNED     0x0080
+#define PLUGIN_VAR_THDLOCAL     0x0100 /* Variable is per-connection */
+#define PLUGIN_VAR_READONLY     0x0200 /* Server variable is read only */
+#define PLUGIN_VAR_NOSYSVAR     0x0400 /* Not a server variable */
+#define PLUGIN_VAR_NOCMDOPT     0x0800 /* Not a command line option */
+#define PLUGIN_VAR_NOCMDARG     0x1000 /* No argument for cmd line */
+#define PLUGIN_VAR_RQCMDARG     0x0000 /* Argument required for cmd line */
+#define PLUGIN_VAR_OPCMDARG     0x2000 /* Argument optional for cmd line */
+#define PLUGIN_VAR_MEMALLOC     0x8000 /* String needs memory allocated */
+
+struct st_mysql_sys_var;
+struct st_mysql_value;
+
+typedef int (*mysql_var_check_func)(MYSQL_THD thd,
+                                    struct st_mysql_sys_var *var,
+                                    void *save, struct st_mysql_value *value);
+typedef void (*mysql_var_update_func)(MYSQL_THD thd,
+                                      struct st_mysql_sys_var *var,
+                                      void *var_ptr, void *save);
+
+
+/* the following declarations are for internal use only */
+
+
+#define PLUGIN_VAR_MASK \
+        (PLUGIN_VAR_READONLY | PLUGIN_VAR_NOSYSVAR | \
+         PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_NOCMDARG | \
+         PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_MEMALLOC)
+
+#define MYSQL_PLUGIN_VAR_HEADER \
+  int flags;                    \
+  const char *name;             \
+  const char *comment;          \
+  mysql_var_check_func check;   \
+  mysql_var_update_func update
+
+#define MYSQL_SYSVAR_NAME(name) mysql_sysvar_ ## name
+#define MYSQL_SYSVAR(name) \
+  ((struct st_mysql_sys_var *)&(MYSQL_SYSVAR_NAME(name)))
+
+/*
+  for global variables, the value pointer is the first
+  element after the header, the default value is the second.
+  for thread variables, the value offset is the first
+  element after the header, the default value is the second.
+*/
+   
+
+#define DECLARE_MYSQL_SYSVAR_BASIC(name, type) struct { \
+  MYSQL_PLUGIN_VAR_HEADER;      \
+  type *value, def_val;         \
+} MYSQL_SYSVAR_NAME(name)
+
+#define DECLARE_MYSQL_SYSVAR_SIMPLE(name, type) struct { \
+  MYSQL_PLUGIN_VAR_HEADER;      \
+  type *value, def_val, min_val,\
+       max_val, blk_sz;         \
+} MYSQL_SYSVAR_NAME(name)
+
+#define DECLARE_MYSQL_SYSVAR_TYPELIB(name) struct { \
+  MYSQL_PLUGIN_VAR_HEADER;      \
+  unsigned long *value, def_val;\
+  TYPELIB *typelib;             \
+} MYSQL_SYSVAR_NAME(name)
+
+#define DECLARE_THDVAR_FUNC(type) \
+  type *(*resolve)(MYSQL_THD thd, int offset)
+
+#define DECLARE_MYSQL_THDVAR_BASIC(name, type) struct { \
+  MYSQL_PLUGIN_VAR_HEADER;      \
+  int offset;                   \
+  type def_val;                 \
+  DECLARE_THDVAR_FUNC(type);    \
+} MYSQL_SYSVAR_NAME(name)
+
+#define DECLARE_MYSQL_THDVAR_SIMPLE(name, type) struct { \
+  MYSQL_PLUGIN_VAR_HEADER;      \
+  int offset;                   \
+  type def_val, min_val, max_val, blk_sz;  \
+  DECLARE_THDVAR_FUNC(type);    \
+} MYSQL_SYSVAR_NAME(name)
+
+#define DECLARE_MYSQL_THDVAR_TYPELIB(name) struct { \
+  MYSQL_PLUGIN_VAR_HEADER;      \
+  int offset;                   \
+  unsigned long def_val;        \
+  DECLARE_THDVAR_FUNC(unsigned long); \
+  TYPELIB *typelib;             \
+} MYSQL_SYSVAR_NAME(name)
+
+
+/*
+  the following declarations are for use by plugin implementors
+*/
+
+#define MYSQL_SYSVAR_BOOL(name, varname, opt, comment, check, update, def) \
+DECLARE_MYSQL_SYSVAR_BASIC(name, char) = { \
+  PLUGIN_VAR_BOOL | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, &varname, def}
+
+#define MYSQL_SYSVAR_STR(name, varname, opt, comment, check, update, def) \
+DECLARE_MYSQL_SYSVAR_BASIC(name, char *) = { \
+  PLUGIN_VAR_STR | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, &varname, def}
+
+#define MYSQL_SYSVAR_INT(name, varname, opt, comment, check, update, def, min, max, blk) \
+DECLARE_MYSQL_SYSVAR_SIMPLE(name, int) = { \
+  PLUGIN_VAR_INT | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, &varname, def, min, max, blk }
+
+#define MYSQL_SYSVAR_UINT(name, varname, opt, comment, check, update, def, min, max, blk) \
+DECLARE_MYSQL_SYSVAR_SIMPLE(name, unsigned int) = { \
+  PLUGIN_VAR_INT | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, &varname, def, min, max, blk }
+
+#define MYSQL_SYSVAR_LONG(name, varname, opt, comment, check, update, def, min, max, blk) \
+DECLARE_MYSQL_SYSVAR_SIMPLE(name, long) = { \
+  PLUGIN_VAR_LONG | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, &varname, def, min, max, blk }
+
+#define MYSQL_SYSVAR_ULONG(name, varname, opt, comment, check, update, def, min, max, blk) \
+DECLARE_MYSQL_SYSVAR_SIMPLE(name, unsigned long) = { \
+  PLUGIN_VAR_LONG | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, &varname, def, min, max, blk }
+
+#define MYSQL_SYSVAR_LONGLONG(name, varname, opt, comment, check, update, def, min, max, blk) \
+DECLARE_MYSQL_SYSVAR_SIMPLE(name, longlong) = { \
+  PLUGIN_VAR_LONGLONG | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, &varname, def, min, max, blk }
+
+#define MYSQL_SYSVAR_ULONGLONG(name, varname, opt, comment, check, update, def, min, max, blk) \
+DECLARE_MYSQL_SYSVAR_SIMPLE(name, ulonglong) = { \
+  PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, &varname, def, min, max, blk }
+
+#define MYSQL_SYSVAR_ENUM(name, varname, opt, comment, check, update, def, typelib) \
+DECLARE_MYSQL_SYSVAR_TYPELIB(name) = { \
+  PLUGIN_VAR_ENUM | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, &varname, def, typelib }
+
+#define MYSQL_SYSVAR_SET(name, varname, opt, comment, check, update, def, typelib) \
+DECLARE_MYSQL_SYSVAR_TYPELIB(name) = { \
+  PLUGIN_VAR_SET | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, &varname, def, typelib }
+
+#define MYSQL_THDVAR_BOOL(name, opt, comment, check, update, def) \
+DECLARE_MYSQL_THDVAR_BASIC(name, char) = { \
+  PLUGIN_VAR_BOOL | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, -1, def, NULL}
+
+#define MYSQL_THDVAR_STR(name, opt, comment, check, update, def) \
+DECLARE_MYSQL_THDVAR_BASIC(name, char *) = { \
+  PLUGIN_VAR_STR | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, -1, def, NULL}
+
+#define MYSQL_THDVAR_INT(name, opt, comment, check, update, def, min, max, blk) \
+DECLARE_MYSQL_THDVAR_SIMPLE(name, int) = { \
+  PLUGIN_VAR_INT | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, -1, def, min, max, blk, NULL }
+
+#define MYSQL_THDVAR_UINT(name, opt, comment, check, update, def, min, max, blk) \
+DECLARE_MYSQL_THDVAR_SIMPLE(name, unsigned int) = { \
+  PLUGIN_VAR_INT | PLUGIN_VAR_THDLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, -1, def, min, max, blk, NULL }
+
+#define MYSQL_THDVAR_LONG(name, opt, comment, check, update, def, min, max, blk) \
+DECLARE_MYSQL_THDVAR_SIMPLE(name, long) = { \
+  PLUGIN_VAR_LONG | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, -1, def, min, max, blk, NULL }
+
+#define MYSQL_THDVAR_ULONG(name, opt, comment, check, update, def, min, max, blk) \
+DECLARE_MYSQL_THDVAR_SIMPLE(name, unsigned long) = { \
+  PLUGIN_VAR_LONG | PLUGIN_VAR_THDLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, -1, def, min, max, blk, NULL }
+
+#define MYSQL_THDVAR_LONGLONG(name, opt, comment, check, update, def, min, max, blk) \
+DECLARE_MYSQL_THDVAR_SIMPLE(name, longlong) = { \
+  PLUGIN_VAR_LONGLONG | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, -1, def, min, max, blk, NULL }
+
+#define MYSQL_THDVAR_ULONGLONG(name, opt, comment, check, update, def, min, max, blk) \
+DECLARE_MYSQL_THDVAR_SIMPLE(name, ulonglong) = { \
+  PLUGIN_VAR_LONGLONG | PLUGIN_VAR_THDLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, -1, def, min, max, blk, NULL }
+
+#define MYSQL_THDVAR_ENUM(name, opt, comment, check, update, def, typelib) \
+DECLARE_MYSQL_THDVAR_TYPELIB(name) = { \
+  PLUGIN_VAR_ENUM | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, -1, def, NULL, typelib }
+
+#define MYSQL_THDVAR_SET(name, opt, comment, check, update, def, typelib) \
+DECLARE_MYSQL_THDVAR_TYPELIB(name) = { \
+  PLUGIN_VAR_SET | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
+  #name, comment, check, update, -1, def, NULL, typelib }
+
+/* accessor macros */
+
+#define SYSVAR(name) \
+  (*(MYSQL_SYSVAR_NAME(name).value))
+
+/* when thd == null, result points to global value */
+#define THDVAR(thd, name) \
+  (*(MYSQL_SYSVAR_NAME(name).resolve(thd, MYSQL_SYSVAR_NAME(name).offset)))
+
 
 /*
   Plugin description structure.
@@ -103,8 +330,8 @@ struct st_mysql_plugin
   int (*deinit)(void *);/* the function to invoke when plugin is unloaded */
   unsigned int version; /* plugin version (for SHOW PLUGINS)            */
   struct st_mysql_show_var *status_vars;
-  void * __reserved1;   /* placeholder for system variables             */
+  struct st_mysql_sys_var **system_vars;
-  void * __reserved2;   /* placeholder for config options               */
+  void * __reserved1;   /* reserved for dependency checking             */
 };
 
 /*************************************************************************
@@ -328,6 +555,8 @@ struct st_mysql_storage_engine
   int interface_version;
 };
 
+struct handlerton;
+
 /*
   Here we define only the descriptor structure, that is referred from
   st_mysql_plugin.
@@ -348,5 +577,47 @@ struct st_mysql_information_schema
   int interface_version;
 };
 
+
+/*
+  st_mysql_value struct for reading values from mysqld.
+  Used by server variables framework to parse user-provided values.
+  Will be used for arguments when implementing UDFs.
+*/
+
+#define MYSQL_VALUE_TYPE_STRING 0
+#define MYSQL_VALUE_TYPE_REAL   1
+#define MYSQL_VALUE_TYPE_INT    2
+
+struct st_mysql_value
+{
+  int (*value_type)(struct st_mysql_value *);
+  const char *(*val_str)(struct st_mysql_value *, char *buffer, int *length);
+  int (*val_real)(struct st_mysql_value *, void *realbuf, int realsize);
+  int (*val_int)(struct st_mysql_value *, void *intbuf, int intsize);
+};
+
+
+/*************************************************************************
+  Miscellaneous functions for plugin implementors
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int thd_in_lock_tables(const MYSQL_THD thd);
+int thd_tablespace_op(const MYSQL_THD thd);
+long long thd_test_options(const MYSQL_THD thd, long long test_options);
+int thd_sql_command(const MYSQL_THD thd);
+const char *thd_proc_info(MYSQL_THD thd, const char *info);
+void **thd_ha_data(const MYSQL_THD thd, const struct handlerton *hton);
+char *thd_security_context(MYSQL_THD thd, char *buffer, int length,
+                           int max_query_len);
+
+
+#ifdef __cplusplus
+};
+#endif
+
 #endif
 

include/mysys_err.h

@@ -79,6 +79,7 @@ extern const char * NEAR globerrs[];	/* my_error_messages is here */
 #define EXIT_NO_PTR_TO_VARIABLE		10
 #define EXIT_CANNOT_CONNECT_TO_SERVICE	11
 #define EXIT_OPTION_DISABLED            12
+#define EXIT_ARGUMENT_INVALID           13
 
 
 #ifdef	__cplusplus

include/typelib.h

@@ -26,6 +26,7 @@ typedef struct st_typelib {	/* Different types saved here */
   unsigned int *type_lengths;
 } TYPELIB;
 
+extern my_ulonglong find_typeset(char *x, TYPELIB *typelib,int *error_position);
 extern int find_type(char *x,TYPELIB *typelib,unsigned int full_name);
 extern void make_type(char *to,unsigned int nr,TYPELIB *typelib);
 extern const char *get_type(TYPELIB *typelib,unsigned int nr);

mysql-test/r/im_utils.result

@@ -20,8 +20,8 @@ character-sets-dir	VALUE
 basedir	VALUE
 server_id	VALUE
 skip-stack-trace	VALUE
-skip-innodb	VALUE
+skip-plugin-innodb	VALUE
-skip-ndbcluster	VALUE
+skip-plugin-ndbcluster	VALUE
 log-output	VALUE
 SHOW INSTANCE OPTIONS mysqld2;
 option_name	value
@@ -38,8 +38,8 @@ character-sets-dir	VALUE
 basedir	VALUE
 server_id	VALUE
 skip-stack-trace	VALUE
-skip-innodb	VALUE
+skip-plugin-innodb	VALUE
-skip-ndbcluster	VALUE
+skip-plugin-ndbcluster	VALUE
 nonguarded	VALUE
 log-output	VALUE
 START INSTANCE mysqld2;

mysql-test/r/log_tables.result

@@ -169,6 +169,8 @@ lock tables mysql.slow_log READ LOCAL, mysql.general_log READ LOCAL;
 unlock tables;
 set global general_log='OFF';
 set global slow_query_log='OFF';
+set @save_storage_engine= @@session.storage_engine;
+set storage_engine= MEMORY;
 alter table mysql.slow_log engine=ndb;
 ERROR HY000: This storage engine cannot be used for log tables"
 alter table mysql.slow_log engine=innodb;
@@ -177,6 +179,7 @@ alter table mysql.slow_log engine=archive;
 ERROR HY000: This storage engine cannot be used for log tables"
 alter table mysql.slow_log engine=blackhole;
 ERROR HY000: This storage engine cannot be used for log tables"
+set storage_engine= @save_storage_engine;
 drop table mysql.slow_log;
 drop table mysql.general_log;
 drop table mysql.general_log;

mysql-test/r/ndb_dd_basic.result

@@ -10,9 +10,7 @@ ALTER LOGFILE GROUP lg1
 ADD UNDOFILE 'undofile02.dat'
 INITIAL_SIZE = 4M 
 ENGINE=XYZ;
-Warnings:
+ERROR 42000: Unknown table engine 'XYZ'
-Error	1286	Unknown table engine 'XYZ'
-Error	1466	Table storage engine 'MyISAM' does not support the create option 'TABLESPACE or LOGFILE GROUP'
 CREATE TABLESPACE ts1
 ADD DATAFILE 'datafile.dat'
 USE LOGFILE GROUP lg1

mysql-test/r/partition_innodb.result

@@ -54,7 +54,7 @@ create table t1 (a int)
 engine = x
 partition by key (a);
 Warnings:
-Error	1286	Unknown table engine 'x'
+Warning	1266	Using storage engine MyISAM for table 't1'
 show create table t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
@@ -66,8 +66,7 @@ engine = innodb
 partition by list (a)
 (partition p0 values in (0));
 alter table t1 engine = x;
-Warnings:
+ERROR 42000: Unknown table engine 'x'
-Error	1286	Unknown table engine 'x'
 show create table t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (

mysql-test/r/ps_1general.result

@@ -303,8 +303,9 @@ prepare stmt4 from ' show variables like ''sql_mode'' ';
 execute stmt4;
 Variable_name	Value
 sql_mode	
-prepare stmt4 from ' show engine bdb logs ';
+prepare stmt4 from ' show engine myisam logs ';
 execute stmt4;
+Type	Name	Status
 prepare stmt4 from ' show grants for user ';
 prepare stmt4 from ' show create table t2 ';
 prepare stmt4 from ' show master status ';

mysql-test/r/variables.result

@@ -236,7 +236,7 @@ net_buffer_length	1024
 net_read_timeout	300
 net_retry_count	10
 net_write_timeout	200
-select * from information_schema.global_variables where variable_name like 'net_%';
+select * from information_schema.global_variables where variable_name like 'net_%' order by 1;
 VARIABLE_NAME	VARIABLE_VALUE
 NET_BUFFER_LENGTH	1024
 NET_READ_TIMEOUT	300
@@ -248,7 +248,7 @@ net_buffer_length	2048
 net_read_timeout	600
 net_retry_count	10
 net_write_timeout	500
-select * from information_schema.session_variables where variable_name like 'net_%';
+select * from information_schema.session_variables where variable_name like 'net_%' order by 1;
 VARIABLE_NAME	VARIABLE_VALUE
 NET_BUFFER_LENGTH	2048
 NET_READ_TIMEOUT	600
@@ -261,7 +261,7 @@ net_buffer_length	1024
 net_read_timeout	900
 net_retry_count	10
 net_write_timeout	1000
-select * from information_schema.global_variables where variable_name like 'net_%';
+select * from information_schema.global_variables where variable_name like 'net_%' order by 1;
 VARIABLE_NAME	VARIABLE_VALUE
 NET_BUFFER_LENGTH	1024
 NET_READ_TIMEOUT	900
@@ -273,7 +273,7 @@ net_buffer_length	7168
 net_read_timeout	600
 net_retry_count	10
 net_write_timeout	500
-select * from information_schema.session_variables where variable_name like 'net_%';
+select * from information_schema.session_variables where variable_name like 'net_%' order by 1;
 VARIABLE_NAME	VARIABLE_VALUE
 NET_BUFFER_LENGTH	7168
 NET_READ_TIMEOUT	600
@@ -314,7 +314,7 @@ query_prealloc_size	8192
 range_alloc_block_size	2048
 transaction_alloc_block_size	8192
 transaction_prealloc_size	4096
-select * from information_schema.session_variables where variable_name like '%alloc%';
+select * from information_schema.session_variables where variable_name like '%alloc%' order by 1;
 VARIABLE_NAME	VARIABLE_VALUE
 QUERY_ALLOC_BLOCK_SIZE	8192
 QUERY_PREALLOC_SIZE	8192
@@ -336,7 +336,7 @@ query_prealloc_size	18432
 range_alloc_block_size	16384
 transaction_alloc_block_size	19456
 transaction_prealloc_size	20480
-select * from information_schema.session_variables where variable_name like '%alloc%';
+select * from information_schema.session_variables where variable_name like '%alloc%' order by 1;
 VARIABLE_NAME	VARIABLE_VALUE
 QUERY_ALLOC_BLOCK_SIZE	17408
 QUERY_PREALLOC_SIZE	18432
@@ -353,7 +353,7 @@ query_prealloc_size	8192
 range_alloc_block_size	2048
 transaction_alloc_block_size	8192
 transaction_prealloc_size	4096
-select * from information_schema.session_variables where variable_name like '%alloc%';
+select * from information_schema.session_variables where variable_name like '%alloc%' order by 1;
 VARIABLE_NAME	VARIABLE_VALUE
 QUERY_ALLOC_BLOCK_SIZE	8192
 QUERY_PREALLOC_SIZE	8192
@@ -881,7 +881,7 @@ ssl_capath	#
 ssl_cert	#
 ssl_cipher	#
 ssl_key	#
-select * from information_schema.session_variables where variable_name like 'ssl%';
+select * from information_schema.session_variables where variable_name like 'ssl%' order by 1;
 VARIABLE_NAME	VARIABLE_VALUE
 SSL_CA	#
 SSL_CAPATH	#

mysql-test/t/log_tables.test

@@ -252,6 +252,8 @@ set global general_log='OFF';
 set global slow_query_log='OFF';
 
 # check that alter table doesn't work for other engines
+set @save_storage_engine= @@session.storage_engine;
+set storage_engine= MEMORY;
 --error ER_UNSUPORTED_LOG_ENGINE
 alter table mysql.slow_log engine=ndb;
 --error ER_UNSUPORTED_LOG_ENGINE
@@ -260,6 +262,7 @@ alter table mysql.slow_log engine=innodb;
 alter table mysql.slow_log engine=archive;
 --error ER_UNSUPORTED_LOG_ENGINE
 alter table mysql.slow_log engine=blackhole;
+set storage_engine= @save_storage_engine;
 
 drop table mysql.slow_log;
 drop table mysql.general_log;

mysql-test/t/ndb_dd_basic.test

@@ -21,6 +21,7 @@ INITIAL_SIZE 16M
 UNDO_BUFFER_SIZE = 1M
 ENGINE=MYISAM;
 
+--error ER_UNKNOWN_STORAGE_ENGINE
 ALTER LOGFILE GROUP lg1
 ADD UNDOFILE 'undofile02.dat'
 INITIAL_SIZE = 4M 

mysql-test/t/partition_innodb.test

@@ -71,6 +71,7 @@ engine = innodb
 partition by list (a)
 (partition p0 values in (0));
 
+--error ER_UNKNOWN_STORAGE_ENGINE
 alter table t1 engine = x;
 show create table t1;
 drop table t1;

mysql-test/t/ps_1general.test

@@ -321,14 +321,8 @@ prepare stmt4 from ' show status like ''Threads_running'' ';
 execute stmt4;
 prepare stmt4 from ' show variables like ''sql_mode'' ';
 execute stmt4;
-# The output depends on the bdb being enabled and on the history
+prepare stmt4 from ' show engine myisam logs ';
-# history (actions of the bdb engine).
-# That is the reason why, we switch the output here off.
-#   (The real output will be tested in ps_6bdb.test)
---disable_result_log
-prepare stmt4 from ' show engine bdb logs ';
 execute stmt4;
---enable_result_log
 prepare stmt4 from ' show grants for user ';
 prepare stmt4 from ' show create table t2 ';
 prepare stmt4 from ' show master status ';

mysql-test/t/variables.test

@@ -151,14 +151,14 @@ set global net_retry_count=10, session net_retry_count=10;
 set global net_buffer_length=1024, net_write_timeout=200, net_read_timeout=300;
 set session net_buffer_length=2048, net_write_timeout=500, net_read_timeout=600;
 show global variables like 'net_%';
-select * from information_schema.global_variables where variable_name like 'net_%';
+select * from information_schema.global_variables where variable_name like 'net_%' order by 1;
 show session variables like 'net_%';
-select * from information_schema.session_variables where variable_name like 'net_%';
+select * from information_schema.session_variables where variable_name like 'net_%' order by 1;
 set session net_buffer_length=8000, global net_read_timeout=900, net_write_timeout=1000;
 show global variables like 'net_%';
-select * from information_schema.global_variables where variable_name like 'net_%';
+select * from information_schema.global_variables where variable_name like 'net_%' order by 1;
 show session variables like 'net_%';
-select * from information_schema.session_variables where variable_name like 'net_%';
+select * from information_schema.session_variables where variable_name like 'net_%' order by 1;
 set net_buffer_length=1;
 show variables like 'net_buffer_length';
 select * from information_schema.session_variables where variable_name like 'net_buffer_length';
@@ -175,7 +175,7 @@ set @@rand_seed1=10000000,@@rand_seed2=1000000;
 select ROUND(RAND(),5);
 
 show variables like '%alloc%';
-select * from information_schema.session_variables where variable_name like '%alloc%';
+select * from information_schema.session_variables where variable_name like '%alloc%' order by 1;
 set @@range_alloc_block_size=1024*16;
 set @@query_alloc_block_size=1024*17+2;
 set @@query_prealloc_size=1024*18;
@@ -183,12 +183,12 @@ set @@transaction_alloc_block_size=1024*20-1;
 set @@transaction_prealloc_size=1024*21-1;
 select @@query_alloc_block_size;
 show variables like '%alloc%';
-select * from information_schema.session_variables where variable_name like '%alloc%';
+select * from information_schema.session_variables where variable_name like '%alloc%' order by 1;
 set @@range_alloc_block_size=default;
 set @@query_alloc_block_size=default, @@query_prealloc_size=default;
 set transaction_alloc_block_size=default, @@transaction_prealloc_size=default;
 show variables like '%alloc%';
-select * from information_schema.session_variables where variable_name like '%alloc%';
+select * from information_schema.session_variables where variable_name like '%alloc%' order by 1;
 
 #
 # Bug #10904 Illegal mix of collations between
@@ -669,7 +669,7 @@ select @@ssl_ca, @@ssl_capath, @@ssl_cert, @@ssl_cipher, @@ssl_key;
 --replace_column 2 #
 show variables like 'ssl%';
 --replace_column 2 #
-select * from information_schema.session_variables where variable_name like 'ssl%';
+select * from information_schema.session_variables where variable_name like 'ssl%' order by 1;
 
 #
 # Bug #19616: make log_queries_not_using_indexes available in SHOW VARIABLES

mysql-test/t/warnings_engine_disabled-master.opt

@@ -1 +1 @@
---loose-skip-ndb
+--loose-skip-plugin-ndbcluster

mysys/array.c

@@ -26,9 +26,10 @@
   Initiate dynamic array
 
   SYNOPSIS
-    init_dynamic_array()
+    init_dynamic_array2()
       array		Pointer to an array
       element_size	Size of element
+      init_buffer       Initial buffer pointer
       init_alloc	Number of initial elements
       alloc_increment	Increment for adding new elements
 
@@ -36,14 +37,15 @@
     init_dynamic_array() initiates array and allocate space for 
     init_alloc eilements. 
     Array is usable even if space allocation failed.
+    Static buffers must begin immediately after the array structure.
 
   RETURN VALUE
     TRUE	my_malloc_ci() failed
     FALSE	Ok
 */
 
-my_bool init_dynamic_array(DYNAMIC_ARRAY *array, uint element_size,
+my_bool init_dynamic_array2(DYNAMIC_ARRAY *array, uint element_size,
-			    uint init_alloc,
+			    void *init_buffer, uint init_alloc, 
 			    uint alloc_increment CALLER_INFO_PROTO)
 {
   DBUG_ENTER("init_dynamic_array");
@@ -56,10 +58,14 @@ my_bool init_dynamic_array(DYNAMIC_ARRAY *array, uint element_size,
 
   if (!init_alloc)
     init_alloc=alloc_increment;
+  else
+    init_buffer= 0;
   array->elements=0;
   array->max_element=init_alloc;
   array->alloc_increment=alloc_increment;
   array->size_of_element=element_size;
+  if ((array->buffer= init_buffer))
+    DBUG_RETURN(FALSE);
   if (!(array->buffer=(char*) my_malloc_ci(element_size*init_alloc,MYF(MY_WME))))
   {
     array->max_element=0;
@@ -68,6 +74,14 @@ my_bool init_dynamic_array(DYNAMIC_ARRAY *array, uint element_size,
   DBUG_RETURN(FALSE);
 } 
 
+my_bool init_dynamic_array(DYNAMIC_ARRAY *array, uint element_size,
+			   uint init_alloc, 
+			   uint alloc_increment CALLER_INFO_PROTO)
+{
+  /* placeholder to preserve ABI */
+  return my_init_dynamic_array_ci(array, element_size, init_alloc, 
+                                  alloc_increment);
+}
 /*
   Insert element at the end of array. Allocate memory if needed.
 
@@ -121,6 +135,21 @@ byte *alloc_dynamic(DYNAMIC_ARRAY *array)
   if (array->elements == array->max_element)
   {
     char *new_ptr;
+    if (array->buffer == (char *)(array + 1))
+    {
+      /*
+        In this senerio, the buffer is statically preallocated,
+        so we have to create an all-new malloc since we overflowed
+      */
+      if (!(new_ptr= (char *) my_malloc((array->max_element+
+				         array->alloc_increment) *
+				        array->size_of_element,
+				        MYF(MY_WME))))
+        return 0;
+      memcpy(new_ptr, array->buffer, 
+             array->elements * array->size_of_element);
+    }
+    else
     if (!(new_ptr=(char*) my_realloc(array->buffer,(array->max_element+
 				     array->alloc_increment)*
 				     array->size_of_element,
@@ -180,6 +209,20 @@ my_bool set_dynamic(DYNAMIC_ARRAY *array, gptr element, uint idx)
       char *new_ptr;
       size=(idx+array->alloc_increment)/array->alloc_increment;
       size*= array->alloc_increment;
+      if (array->buffer == (char *)(array + 1))
+      {
+        /*
+          In this senerio, the buffer is statically preallocated,
+          so we have to create an all-new malloc since we overflowed
+        */
+        if (!(new_ptr= (char *) my_malloc(size *
+				          array->size_of_element,
+				          MYF(MY_WME))))
+          return 0;
+        memcpy(new_ptr, array->buffer, 
+               array->elements * array->size_of_element);
+      }
+      else
       if (!(new_ptr=(char*) my_realloc(array->buffer,size*
 				       array->size_of_element,
 				       MYF(MY_WME | MY_ALLOW_ZERO_PTR))))
@@ -230,6 +273,12 @@ void get_dynamic(DYNAMIC_ARRAY *array, gptr element, uint idx)
 
 void delete_dynamic(DYNAMIC_ARRAY *array)
 {
+  /*
+    Just mark as empty if we are using a static buffer
+  */
+  if (array->buffer == (char *)(array + 1))
+    array->elements= 0;
+  else
   if (array->buffer)
   {
     my_free(array->buffer,MYF(MY_WME));
@@ -269,6 +318,12 @@ void freeze_size(DYNAMIC_ARRAY *array)
 {
   uint elements=max(array->elements,1);
 
+  /*
+    Do nothing if we are using a static buffer
+  */
+  if (array->buffer == (char *)(array + 1))
+    return;
+    
   if (array->buffer && array->max_element != elements)
   {
     array->buffer=(char*) my_realloc(array->buffer,

mysys/hash.c

@@ -315,6 +315,10 @@ my_bool my_hash_insert(HASH *info,const byte *record)
   LINT_INIT(gpos); LINT_INIT(gpos2);
   LINT_INIT(ptr_to_rec); LINT_INIT(ptr_to_rec2);
 
+  if (HASH_UNIQUE & info->flags &&
+      hash_search(info, hash_key(info, record, &idx, 1), idx))
+    return(TRUE);				/* Duplicate entry */
+
   flag=0;
   if (!(empty=(HASH_LINK*) alloc_dynamic(&info->array)))
     return(TRUE);				/* No more memory */
@@ -530,6 +534,19 @@ my_bool hash_update(HASH *hash,byte *record,byte *old_key,uint old_key_length)
   uint idx,new_index,new_pos_index,blength,records,empty;
   HASH_LINK org_link,*data,*previous,*pos;
   DBUG_ENTER("hash_update");
+  
+  if (HASH_UNIQUE & hash->flags)
+  {
+    HASH_SEARCH_STATE state;
+    byte *found, *new_key= hash_key(hash, record, &idx, 1);
+    if ((found= hash_first(hash, new_key, idx, &state)))
+      do 
+      {
+        if (found != record)
+          DBUG_RETURN(1);		/* Duplicate entry */
+      } 
+      while ((found= hash_next(hash, new_key, idx, &state)));
+  }
 
   data=dynamic_element(&hash->array,0,HASH_LINK*);
   blength=hash->blength; records=hash->records;

mysys/my_getopt.c

@@ -58,6 +58,13 @@ char *disabled_my_option= (char*) "0";
 
 my_bool my_getopt_print_errors= 1;
 
+/* 
+   This is a flag that can be set in client programs. 1 means that
+   my_getopt will skip over options it does not know how to handle.
+*/
+
+my_bool my_getopt_skip_unknown= 0;
+
 static void default_reporter(enum loglevel level,
                              const char *format, ...)
 {
@@ -110,6 +117,7 @@ int handle_options(int *argc, char ***argv,
 
   for (pos= *argv, pos_end=pos+ *argc; pos != pos_end ; pos++)
   {
+    char **first= pos;
     char *cur_arg= *pos;
     if (cur_arg[0] == '-' && cur_arg[1] && !end_of_options) /* must be opt */
     {
@@ -259,6 +267,19 @@ int handle_options(int *argc, char ***argv,
 	  }
 	  if (!opt_found)
 	  {
+            if (my_getopt_skip_unknown)
+            {
+              /*
+                preserve all the components of this unknown option, this may
+                occurr when the user provides options like: "-O foo" or
+                "--set-variable foo" (note that theres a space in there)
+                Generally, these kind of options are to be avoided
+              */
+              do {
+                (*argv)[argvpos++]= *first++;
+              } while (first <= pos);
+              continue;
+            }
 	    if (must_be_var)
 	    {
 	      if (my_getopt_print_errors)
@@ -596,6 +617,15 @@ static int setval(const struct my_option *opts, gptr *value, char *argument,
       if (!(*((char**) result_pos)= my_strdup(argument, MYF(MY_WME))))
 	return EXIT_OUT_OF_MEMORY;
       break;
+    case GET_ENUM:
+      if (((*(int*)result_pos)= find_type(argument, opts->typelib, 2) - 1) < 0)
+        return EXIT_ARGUMENT_INVALID;
+      break;
+    case GET_SET:
+      *((ulonglong*)result_pos)= find_typeset(argument, opts->typelib, &err);
+      if (err)
+        return EXIT_ARGUMENT_INVALID;
+      break;
     default:    /* dummy default to avoid compiler warnings */
       break;
     }
@@ -788,6 +818,7 @@ static void init_one_value(const struct my_option *option, gptr *variable,
     *((int*) variable)= (int) value;
     break;
   case GET_UINT:
+  case GET_ENUM:
     *((uint*) variable)= (uint) value;
     break;
   case GET_LONG:
@@ -800,6 +831,7 @@ static void init_one_value(const struct my_option *option, gptr *variable,
     *((longlong*) variable)= (longlong) value;
     break;
   case GET_ULL:
+  case GET_SET:
     *((ulonglong*) variable)=  (ulonglong) value;
     break;
   default: /* dummy default to avoid compiler warnings */
@@ -928,7 +960,8 @@ void my_print_help(const struct my_option *options)
 
 void my_print_variables(const struct my_option *options)
 {
-  uint name_space= 34, length;
+  uint name_space= 34, length, nr;
+  ulonglong bit, llvalue;
   char buff[255];
   const struct my_option *optp;
 
@@ -946,6 +979,21 @@ void my_print_variables(const struct my_option *options)
       for (; length < name_space; length++)
 	putchar(' ');
       switch ((optp->var_type & GET_TYPE_MASK)) {
+      case GET_SET:
+        if (!(llvalue= *(ulonglong*) value))
+	  printf("%s\n", "(No default value)");
+	else
+        for (nr= 0, bit= 1; llvalue && nr < optp->typelib->count; nr++, bit<<=1)
+	{
+	  if (!(bit & llvalue))
+	    continue;
+	  llvalue&= ~bit;
+	  printf( llvalue ? "%s," : "%s\n", get_type(optp->typelib, nr));
+	}
+	break;
+      case GET_ENUM:
+        printf("%s\n", get_type(optp->typelib, *(uint*) value));
+	break;
       case GET_STR:
       case GET_STR_ALLOC:                    /* fall through */
 	printf("%s\n", *((char**) value) ? *((char**) value) :

mysys/typelib.c

@@ -120,6 +120,54 @@ const char *get_type(TYPELIB *typelib, uint nr)
 }
 
 
+static const char field_separator=',';
+
+/*
+  Create an integer value to represent the supplied comma-seperated
+  string where each string in the TYPELIB denotes a bit position.
+
+  SYNOPSIS
+    find_typeset()
+    x		string to decompose
+    lib		TYPELIB (struct of pointer to values + count)
+    err		index (not char position) of string element which was not 
+                found or 0 if there was no error
+
+  RETURN
+    a integer representation of the supplied string
+*/
+
+my_ulonglong find_typeset(my_string x, TYPELIB *lib, int *err)
+{
+  my_ulonglong result;
+  int find;
+  my_string i;
+  DBUG_ENTER("find_set");
+  DBUG_PRINT("enter",("x: '%s'  lib: 0x%lx", x, (long) lib));
+
+  if (!lib->count)
+  {
+    DBUG_PRINT("exit",("no count"));
+    DBUG_RETURN(0);
+  }
+  result= 0;
+  *err= 0;
+  while (*x)
+  {
+    (*err)++;
+    i= x;
+    while (*x && *x != field_separator) x++;
+    if (*x)
+      *x++= 0;
+    if ((find= find_type(i, lib, 2) - 1) < 0)
+      DBUG_RETURN(0);
+    result|= (ULL(1) << find);
+  }
+  *err= 0;
+  DBUG_RETURN(result);
+} /* find_set */
+
+
 /*
   Create a copy of a specified TYPELIB structure.
 

sql/ha_ndbcluster.cc

@@ -2629,7 +2629,7 @@ int ha_ndbcluster::write_row(byte *record)
       DBUG_RETURN(peek_res);
   }
 
-  statistic_increment(thd->status_var.ha_write_count, &LOCK_status);
+  ha_statistic_increment(&SSV::ha_write_count);
   if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
     table->timestamp_field->set_time();
 
@@ -2849,7 +2849,7 @@ int ha_ndbcluster::update_row(const byte *old_data, byte *new_data)
       DBUG_RETURN(peek_res);
   }
 
-  statistic_increment(thd->status_var.ha_update_count, &LOCK_status);
+  ha_statistic_increment(&SSV::ha_update_count);
   if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
   {
     table->timestamp_field->set_time();
@@ -3016,7 +3016,7 @@ int ha_ndbcluster::delete_row(const byte *record)
   DBUG_ENTER("delete_row");
   m_write_op= TRUE;
 
-  statistic_increment(thd->status_var.ha_delete_count,&LOCK_status);
+  ha_statistic_increment(&SSV::ha_delete_count);
   m_rows_changed++;
 
   if (m_use_partition_function &&
@@ -3372,7 +3372,7 @@ int ha_ndbcluster::index_read_idx(byte *buf, uint index_no,
                               const byte *key, uint key_len, 
                               enum ha_rkey_function find_flag)
 {
-  statistic_increment(current_thd->status_var.ha_read_key_count, &LOCK_status);
+  ha_statistic_increment(&SSV::ha_read_key_count);
   DBUG_ENTER("ha_ndbcluster::index_read_idx");
   DBUG_PRINT("enter", ("index_no: %u, key_len: %u", index_no, key_len));  
   close_scan();
@@ -3384,8 +3384,7 @@ int ha_ndbcluster::index_read_idx(byte *buf, uint index_no,
 int ha_ndbcluster::index_next(byte *buf)
 {
   DBUG_ENTER("ha_ndbcluster::index_next");
-  statistic_increment(current_thd->status_var.ha_read_next_count,
+  ha_statistic_increment(&SSV::ha_read_next_count);
-                      &LOCK_status);
   DBUG_RETURN(next_result(buf));
 }
 
@@ -3393,8 +3392,7 @@ int ha_ndbcluster::index_next(byte *buf)
 int ha_ndbcluster::index_prev(byte *buf)
 {
   DBUG_ENTER("ha_ndbcluster::index_prev");
-  statistic_increment(current_thd->status_var.ha_read_prev_count,
+  ha_statistic_increment(&SSV::ha_read_prev_count);
-                      &LOCK_status);
   DBUG_RETURN(next_result(buf));
 }
 
@@ -3402,8 +3400,7 @@ int ha_ndbcluster::index_prev(byte *buf)
 int ha_ndbcluster::index_first(byte *buf)
 {
   DBUG_ENTER("ha_ndbcluster::index_first");
-  statistic_increment(current_thd->status_var.ha_read_first_count,
+  ha_statistic_increment(&SSV::ha_read_first_count);
-                      &LOCK_status);
   // Start the ordered index scan and fetch the first row
 
   // Only HA_READ_ORDER indexes get called by index_first
@@ -3414,7 +3411,7 @@ int ha_ndbcluster::index_first(byte *buf)
 int ha_ndbcluster::index_last(byte *buf)
 {
   DBUG_ENTER("ha_ndbcluster::index_last");
-  statistic_increment(current_thd->status_var.ha_read_last_count,&LOCK_status);
+  ha_statistic_increment(&SSV::ha_read_last_count);
   DBUG_RETURN(ordered_index_scan(0, 0, TRUE, TRUE, buf, NULL));
 }
 
@@ -3600,8 +3597,7 @@ int ha_ndbcluster::rnd_end()
 int ha_ndbcluster::rnd_next(byte *buf)
 {
   DBUG_ENTER("rnd_next");
-  statistic_increment(current_thd->status_var.ha_read_rnd_next_count,
+  ha_statistic_increment(&SSV::ha_read_rnd_next_count);
-                      &LOCK_status);
 
   if (!m_active_cursor)
     DBUG_RETURN(full_table_scan(buf));
@@ -3619,8 +3615,7 @@ int ha_ndbcluster::rnd_next(byte *buf)
 int ha_ndbcluster::rnd_pos(byte *buf, byte *pos)
 {
   DBUG_ENTER("rnd_pos");
-  statistic_increment(current_thd->status_var.ha_read_rnd_count,
+  ha_statistic_increment(&SSV::ha_read_rnd_count);
-                      &LOCK_status);
   // The primary key for the record is stored in pos
   // Perform a pk_read using primary key "index"
   {
@@ -6743,7 +6738,7 @@ static int ndbcluster_init(void *p)
 
   {
     handlerton *h= ndbcluster_hton;
-    h->state=            have_ndbcluster;
+    h->state=            SHOW_OPTION_YES;
     h->db_type=          DB_TYPE_NDBCLUSTER;
     h->close_connection= ndbcluster_close_connection;
     h->commit=           ndbcluster_commit;
@@ -6765,9 +6760,6 @@ static int ndbcluster_init(void *p)
     h->table_exists_in_engine= ndbcluster_table_exists_in_engine;
   }
 
-  if (have_ndbcluster != SHOW_OPTION_YES)
-    DBUG_RETURN(0); // nothing else to do
-
   // Initialize ndb interface
   ndb_init_internal();
 
@@ -6883,7 +6875,6 @@ ndbcluster_init_error:
   if (g_ndb_cluster_connection)
     delete g_ndb_cluster_connection;
   g_ndb_cluster_connection= NULL;
-  have_ndbcluster= SHOW_OPTION_DISABLED;	// If we couldn't use handler
   ndbcluster_hton->state= SHOW_OPTION_DISABLED;               // If we couldn't use handler
 
   DBUG_RETURN(TRUE);
@@ -10220,10 +10211,6 @@ ndbcluster_show_status(handlerton *hton, THD* thd, stat_print_fn *stat_print,
   uint buflen;
   DBUG_ENTER("ndbcluster_show_status");
   
-  if (have_ndbcluster != SHOW_OPTION_YES) 
-  {
-    DBUG_RETURN(FALSE);
-  }
   if (stat_type != HA_ENGINE_STATUS)
   {
     DBUG_RETURN(FALSE);

sql/ha_partition.cc

@@ -1987,6 +1987,8 @@ bool ha_partition::create_handler_file(const char *name)
 
 void ha_partition::clear_handler_file()
 {
+  if (m_engine_array)
+    plugin_unlock_list(NULL, m_engine_array, m_tot_parts);
   my_free((char*) m_file_buffer, MYF(MY_ALLOW_ZERO_PTR));
   my_free((char*) m_engine_array, MYF(MY_ALLOW_ZERO_PTR));
   m_file_buffer= NULL;
@@ -2009,6 +2011,7 @@ bool ha_partition::create_handlers(MEM_ROOT *mem_root)
 {
   uint i;
   uint alloc_len= (m_tot_parts + 1) * sizeof(handler*);
+  handlerton *hton0;
   DBUG_ENTER("create_handlers");
 
   if (!(m_file= (handler **) alloc_root(mem_root, alloc_len)))
@@ -2017,19 +2020,21 @@ bool ha_partition::create_handlers(MEM_ROOT *mem_root)
   bzero((char*) m_file, alloc_len);
   for (i= 0; i < m_tot_parts; i++)
   {
+    handlerton *hton= plugin_data(m_engine_array[i], handlerton*);
     if (!(m_file[i]= get_new_handler(table_share, mem_root,
-                                     m_engine_array[i])))
+                                     hton)))
       DBUG_RETURN(TRUE);
-    DBUG_PRINT("info", ("engine_type: %u", m_engine_array[i]->db_type));
+    DBUG_PRINT("info", ("engine_type: %u", hton->db_type));
   }
   /* For the moment we only support partition over the same table engine */
-  if (m_engine_array[0] == myisam_hton)
+  hton0= plugin_data(m_engine_array[0], handlerton*);
+  if (hton0 == myisam_hton)
   {
     DBUG_PRINT("info", ("MyISAM"));
     m_myisam= TRUE;
   }
   /* INNODB may not be compiled in... */
-  else if (ha_legacy_type(m_engine_array[0]) == DB_TYPE_INNODB)
+  else if (ha_legacy_type(hton0) == DB_TYPE_INNODB)
   {
     DBUG_PRINT("info", ("InnoDB"));
     m_innodb= TRUE;
@@ -2160,8 +2165,7 @@ bool ha_partition::get_from_handler_file(const char *name, MEM_ROOT *mem_root)
   m_tot_parts= uint4korr((file_buffer) + 8);
   DBUG_PRINT("info", ("No of parts = %u", m_tot_parts));
   tot_partition_words= (m_tot_parts + 3) / 4;
-  if (!(engine_array= (handlerton **) my_malloc(m_tot_parts * sizeof(handlerton*),MYF(0))))
+  engine_array= (handlerton **) my_alloca(m_tot_parts * sizeof(handlerton*));
-    goto err2;
   for (i= 0; i < m_tot_parts; i++)
     engine_array[i]= ha_resolve_by_legacy_type(current_thd,
                                                (enum legacy_db_type)
@@ -2174,7 +2178,14 @@ bool ha_partition::get_from_handler_file(const char *name, MEM_ROOT *mem_root)
   VOID(my_close(file, MYF(0)));
   m_file_buffer= file_buffer;          // Will be freed in clear_handler_file()
   m_name_buffer_ptr= name_buffer_ptr;
-  m_engine_array= engine_array;
+  
+  if (!(m_engine_array= (plugin_ref*)
+                my_malloc(m_tot_parts * sizeof(plugin_ref), MYF(MY_WME))))
+    goto err2;
+
+  for (i= 0; i < m_tot_parts; i++)
+    m_engine_array[i]= ha_lock_engine(NULL, engine_array[i]);
+    
   if (!m_file && create_handlers(mem_root))
   {
     clear_handler_file();

sql/ha_partition.h

@@ -27,6 +27,7 @@ enum partition_keywords
   The partition implements the minimum of what you will probably need.
 */
 
+#ifdef NOT_USED
 typedef struct st_partition_share
 {
   char *table_name;
@@ -34,6 +35,7 @@ typedef struct st_partition_share
   pthread_mutex_t mutex;
   THR_LOCK lock;
 } PARTITION_SHARE;
+#endif
 
 
 #define PARTITION_BYTES_IN_POS 2
@@ -54,7 +56,7 @@ private:
   uint m_open_test_lock;                // Open test_if_locked
   char *m_file_buffer;                  // Buffer with names
   char *m_name_buffer_ptr;		// Pointer to first partition name
-  handlerton **m_engine_array;          // Array of types of the handlers
+  plugin_ref *m_engine_array;           // Array of types of the handlers
   handler **m_file;                     // Array of references to handler inst.
   uint m_file_tot_parts;                // Debug
   handler **m_new_file;                 // Array of references to new handlers
@@ -130,7 +132,9 @@ private:
     Variables for lock structures.
   */
   THR_LOCK_DATA lock;                   /* MySQL lock */
+#ifdef NOT_USED
   PARTITION_SHARE *share;               /* Shared lock info */
+#endif
 
 public:
   virtual void set_part_info(partition_info *part_info)

sql/handler.cc

@@ -77,6 +77,15 @@ static TYPELIB known_extensions= {0,"known_exts", NULL, NULL};
 uint known_extensions_id= 0;
 
 
+
+static plugin_ref ha_default_plugin(THD *thd)
+{
+  if (thd->variables.table_plugin)
+    return thd->variables.table_plugin;
+  return my_plugin_lock(thd, &global_system_variables.table_plugin);
+}
+
+
 /** @brief
   Return the default storage engine handlerton for thread
 
@@ -89,10 +98,11 @@ uint known_extensions_id= 0;
 */
 handlerton *ha_default_handlerton(THD *thd)
 {
-  return (thd->variables.table_type != NULL) ?
+  plugin_ref plugin= ha_default_plugin(thd);
-          thd->variables.table_type :
+  DBUG_ASSERT(plugin);
-          (global_system_variables.table_type != NULL ?
+  handlerton *hton= plugin_data(plugin, handlerton*);
-           global_system_variables.table_type : myisam_hton);
+  DBUG_ASSERT(hton);
+  return hton;
 }
 
 
@@ -105,26 +115,30 @@ handlerton *ha_default_handlerton(THD *thd)
     name        name of storage engine
   
   RETURN
-    pointer to handlerton
+    pointer to storage engine plugin handle
 */
-handlerton *ha_resolve_by_name(THD *thd, const LEX_STRING *name)
+plugin_ref ha_resolve_by_name(THD *thd, const LEX_STRING *name)
 {
   const LEX_STRING *table_alias;
-  st_plugin_int *plugin;
+  plugin_ref plugin;
 
 redo:
   /* my_strnncoll is a macro and gcc doesn't do early expansion of macro */
   if (thd && !my_charset_latin1.coll->strnncoll(&my_charset_latin1,
                            (const uchar *)name->str, name->length,
                            (const uchar *)STRING_WITH_LEN("DEFAULT"), 0))
-    return ha_default_handlerton(thd);
+    return ha_default_plugin(thd);
 
-  if ((plugin= plugin_lock(name, MYSQL_STORAGE_ENGINE_PLUGIN)))
+  if ((plugin= my_plugin_lock_by_name(thd, name, MYSQL_STORAGE_ENGINE_PLUGIN)))
   {
-    handlerton *hton= (handlerton *)plugin->data;
+    handlerton *hton= plugin_data(plugin, handlerton *);
     if (!(hton->flags & HTON_NOT_USER_SELECTABLE))
-      return hton;
+      return plugin;
-    plugin_unlock(plugin);
+      
+    /*
+      unlocking plugin immediately after locking is relatively low cost.
+    */
+    plugin_unlock(thd, plugin);
   }
 
   /*
@@ -145,19 +159,19 @@ redo:
 }
 
 
-const char *ha_get_storage_engine(enum legacy_db_type db_type)
+plugin_ref ha_lock_engine(THD *thd, handlerton *hton)
 {
-  switch (db_type) {
+  if (hton)
-  case DB_TYPE_DEFAULT:
+  {
-    return "DEFAULT";
+    st_plugin_int **plugin= hton2plugin + hton->slot;
-  default:
+    
-    if (db_type > DB_TYPE_UNKNOWN && db_type < DB_TYPE_DEFAULT &&
+#ifdef DBUG_OFF;
-        installed_htons[db_type])
+    return my_plugin_lock(thd, plugin);
-      return hton2plugin[installed_htons[db_type]->slot]->name.str;
+#else
-    /* fall through */
+    return my_plugin_lock(thd, &plugin);
-  case DB_TYPE_UNKNOWN:
+#endif
-    return "UNKNOWN";
   }
+  return NULL;
 }
 
 
@@ -172,14 +186,16 @@ static handler *create_default(TABLE_SHARE *table, MEM_ROOT *mem_root)
 
 handlerton *ha_resolve_by_legacy_type(THD *thd, enum legacy_db_type db_type)
 {
+  plugin_ref plugin;
   switch (db_type) {
   case DB_TYPE_DEFAULT:
     return ha_default_handlerton(thd);
-  case DB_TYPE_UNKNOWN:
-    return NULL;
   default:
-    if (db_type > DB_TYPE_UNKNOWN && db_type < DB_TYPE_DEFAULT)
+    if (db_type > DB_TYPE_UNKNOWN && db_type < DB_TYPE_DEFAULT &&
-      return installed_htons[db_type];
+        (plugin= ha_lock_engine(thd, installed_htons[db_type])))
+      return plugin_data(plugin, handlerton*);
+    /* fall through */
+  case DB_TYPE_UNKNOWN:
     return NULL;
   }
 }
@@ -199,7 +215,7 @@ handlerton *ha_checktype(THD *thd, enum legacy_db_type database_type,
   {
     if (report_error)
     {
-      const char *engine_name= ha_get_storage_engine(database_type);
+      const char *engine_name= ha_resolve_storage_engine_name(hton);
       my_error(ER_FEATURE_DISABLED,MYF(0),engine_name,engine_name);
     }
     return NULL;
@@ -238,8 +254,7 @@ handler *get_new_handler(TABLE_SHARE *share, MEM_ROOT *alloc,
     Here the call to current_thd() is ok as we call this function a lot of
     times but we enter this branch very seldom.
   */
-  DBUG_RETURN(get_new_handler(share, alloc,
+  DBUG_RETURN(get_new_handler(share, alloc, ha_default_handlerton(current_thd)));
-                              current_thd->variables.table_type));
 }
 
 
@@ -522,10 +537,10 @@ int ha_end()
   DBUG_RETURN(error);
 }
 
-static my_bool dropdb_handlerton(THD *unused1, st_plugin_int *plugin,
+static my_bool dropdb_handlerton(THD *unused1, plugin_ref plugin,
                                  void *path)
 {
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
   if (hton->state == SHOW_OPTION_YES && hton->drop_database)
     hton->drop_database(hton, (char *)path);
   return FALSE;
@@ -538,10 +553,10 @@ void ha_drop_database(char* path)
 }
 
 
-static my_bool closecon_handlerton(THD *thd, st_plugin_int *plugin,
+static my_bool closecon_handlerton(THD *thd, plugin_ref plugin,
                                    void *unused)
 {
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
   /*
     there's no need to rollback here as all transactions must
     be rolled back already
@@ -638,7 +653,7 @@ int ha_prepare(THD *thd)
       {
         push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                             ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
-                            hton2plugin[(*ht)->slot]->name.str);
+                            ha_resolve_storage_engine_name(*ht));
       }
     }
   }
@@ -886,10 +901,10 @@ struct xahton_st {
   int result;
 };
 
-static my_bool xacommit_handlerton(THD *unused1, st_plugin_int *plugin,
+static my_bool xacommit_handlerton(THD *unused1, plugin_ref plugin,
                                    void *arg)
 {
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
   if (hton->state == SHOW_OPTION_YES && hton->recover)
   {
     hton->commit_by_xid(hton, ((struct xahton_st *)arg)->xid);
@@ -898,10 +913,10 @@ static my_bool xacommit_handlerton(THD *unused1, st_plugin_int *plugin,
   return FALSE;
 }
 
-static my_bool xarollback_handlerton(THD *unused1, st_plugin_int *plugin,
+static my_bool xarollback_handlerton(THD *unused1, plugin_ref plugin,
                                      void *arg)
 {
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
   if (hton->state == SHOW_OPTION_YES && hton->recover)
   {
     hton->rollback_by_xid(hton, ((struct xahton_st *)arg)->xid);
@@ -1004,10 +1019,10 @@ struct xarecover_st
   bool dry_run;
 };
 
-static my_bool xarecover_handlerton(THD *unused, st_plugin_int *plugin,
+static my_bool xarecover_handlerton(THD *unused, plugin_ref plugin,
                                     void *arg)
 {
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
   struct xarecover_st *info= (struct xarecover_st *) arg;
   int got;
 
@@ -1016,7 +1031,7 @@ static my_bool xarecover_handlerton(THD *unused, st_plugin_int *plugin,
     while ((got= hton->recover(hton, info->list, info->len)) > 0 )
     {
       sql_print_information("Found %d prepared transaction(s) in %s",
-                            got, hton2plugin[hton->slot]->name.str);
+                            got, ha_resolve_storage_engine_name(hton));
       for (int i=0; i < got; i ++)
       {
         my_xid x=info->list[i].get_my_xid();
@@ -1192,10 +1207,10 @@ bool mysql_xa_recover(THD *thd)
   thd:           the thread handle of the current connection
   return value:  always 0
 */
-static my_bool release_temporary_latches(THD *thd, st_plugin_int *plugin,
+static my_bool release_temporary_latches(THD *thd, plugin_ref plugin,
                                  void *unused)
 {
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
 
   if (hton->state == SHOW_OPTION_YES && hton->release_temporary_latches)
     hton->release_temporary_latches(hton, thd);
@@ -1318,10 +1333,10 @@ int ha_release_savepoint(THD *thd, SAVEPOINT *sv)
 }
 
 
-static my_bool snapshot_handlerton(THD *thd, st_plugin_int *plugin,
+static my_bool snapshot_handlerton(THD *thd, plugin_ref plugin,
                                    void *arg)
 {
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
   if (hton->state == SHOW_OPTION_YES &&
       hton->start_consistent_snapshot)
   {
@@ -1349,10 +1364,10 @@ int ha_start_consistent_snapshot(THD *thd)
 }
 
 
-static my_bool flush_handlerton(THD *thd, st_plugin_int *plugin,
+static my_bool flush_handlerton(THD *thd, plugin_ref plugin,
                                 void *arg)
 {
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
   if (hton->state == SHOW_OPTION_YES && hton->flush_logs && 
       hton->flush_logs(hton))
     return TRUE;
@@ -1397,7 +1412,7 @@ int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
 
   /* DB_TYPE_UNKNOWN is used in ALTER TABLE when renaming only .frm files */
   if (table_type == NULL ||
-      ! (file=get_new_handler(&dummy_share, thd->mem_root, table_type)))
+      ! (file=get_new_handler((TABLE_SHARE*)0, thd->mem_root, table_type)))
     DBUG_RETURN(ENOENT);
 
   if (lower_case_table_names == 2 && !(file->ha_table_flags() & HA_FILE_BASED))
@@ -1438,6 +1453,8 @@ int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
     dummy_share.table_name.length= strlen(alias);
     dummy_table.alias= alias;
 
+    file->table_share= &dummy_share;
+    file->table= &dummy_table;
     file->print_error(error, 0);
     strmake(new_error, thd->net.last_error, sizeof(buff)-1);
 
@@ -1458,7 +1475,7 @@ int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
 ****************************************************************************/
 handler *handler::clone(MEM_ROOT *mem_root)
 {
-  handler *new_handler= get_new_handler(table->s, mem_root, table->s->db_type);
+  handler *new_handler= get_new_handler(table->s, mem_root, table->s->db_type());
   if (new_handler && !new_handler->ha_open(table,
                                            table->s->normalized_path.str,
                                            table->db_stat,
@@ -1474,6 +1491,26 @@ void handler::ha_statistic_increment(ulong SSV::*offset) const
   statistic_increment(table->in_use->status_var.*offset, &LOCK_status);
 }
 
+enum enum_tx_isolation  handler::ha_tx_isolation(void) const
+{
+  return (enum_tx_isolation) ha_thd()->variables.tx_isolation;
+}
+
+uint handler::ha_sql_command(void) const
+{
+  return (uint) ha_thd()->lex->sql_command;
+}
+
+void **handler::ha_data(void) const
+{
+  return (void **) ha_thd()->ha_data + ht->slot;
+}
+
+THD *handler::ha_thd(void) const
+{
+  return (table && table->in_use) ? table->in_use : current_thd;
+}
+
 
 bool handler::check_if_log_table_locking_is_allowed(uint sql_command,
                                                     ulong type, TABLE *table)
@@ -1567,8 +1604,7 @@ int handler::read_first_row(byte * buf, uint primary_key)
   register int error;
   DBUG_ENTER("handler::read_first_row");
 
-  statistic_increment(table->in_use->status_var.ha_read_first_count,
+  ha_statistic_increment(&SSV::ha_read_first_count);
-                      &LOCK_status);
 
   /*
     If there is very few deleted rows in the table, find the first row by
@@ -2785,11 +2821,11 @@ struct st_discover_args
   uint* frmlen;
 };
 
-static my_bool discover_handlerton(THD *thd, st_plugin_int *plugin,
+static my_bool discover_handlerton(THD *thd, plugin_ref plugin,
                                    void *arg)
 {
   st_discover_args *vargs= (st_discover_args *)arg;
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
   if (hton->state == SHOW_OPTION_YES && hton->discover &&
       (!(hton->discover(hton, thd, vargs->db, vargs->name, 
                         vargs->frmblob, 
@@ -2834,11 +2870,11 @@ struct st_find_files_args
   List<char> *files;
 };
 
-static my_bool find_files_handlerton(THD *thd, st_plugin_int *plugin,
+static my_bool find_files_handlerton(THD *thd, plugin_ref plugin,
                                    void *arg)
 {
   st_find_files_args *vargs= (st_find_files_args *)arg;
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
 
 
   if (hton->state == SHOW_OPTION_YES && hton->find_files)
@@ -2881,11 +2917,11 @@ struct st_table_exists_in_engine_args
   const char *name;
 };
 
-static my_bool table_exists_in_engine_handlerton(THD *thd, st_plugin_int *plugin,
+static my_bool table_exists_in_engine_handlerton(THD *thd, plugin_ref plugin,
                                    void *arg)
 {
   st_table_exists_in_engine_args *vargs= (st_table_exists_in_engine_args *)arg;
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
 
   if (hton->state == SHOW_OPTION_YES && hton->table_exists_in_engine)
     if ((hton->table_exists_in_engine(hton, thd, vargs->db, vargs->name)) == 1)
@@ -2929,10 +2965,10 @@ struct binlog_func_st
 /** @brief
   Listing handlertons first to avoid recursive calls and deadlock
 */
-static my_bool binlog_func_list(THD *thd, st_plugin_int *plugin, void *arg)
+static my_bool binlog_func_list(THD *thd, plugin_ref plugin, void *arg)
 {
   hton_list_st *hton_list= (hton_list_st *)arg;
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
   if (hton->state == SHOW_OPTION_YES && hton->binlog_func)
   {
     uint sz= hton_list->sz;
@@ -3019,10 +3055,10 @@ static my_bool binlog_log_query_handlerton2(THD *thd,
 }
 
 static my_bool binlog_log_query_handlerton(THD *thd,
-                                           st_plugin_int *plugin,
+                                           plugin_ref plugin,
                                            void *args)
 {
-  return binlog_log_query_handlerton2(thd, (handlerton *)plugin->data, args);
+  return binlog_log_query_handlerton2(thd, plugin_data(plugin, handlerton *), args);
 }
 
 void ha_binlog_log_query(THD *thd, handlerton *hton,
@@ -3310,11 +3346,11 @@ int handler::index_read_idx(byte * buf, uint index, const byte * key,
   RETURN VALUE
     pointer		pointer to TYPELIB structure
 */
-static my_bool exts_handlerton(THD *unused, st_plugin_int *plugin,
+static my_bool exts_handlerton(THD *unused, plugin_ref plugin,
                                void *arg)
 {
   List<char> *found_exts= (List<char> *) arg;
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
   handler *file;
   if (hton->state == SHOW_OPTION_YES && hton->create &&
       (file= hton->create(hton, (TABLE_SHARE*) 0, current_thd->mem_root)))
@@ -3385,11 +3421,11 @@ static bool stat_print(THD *thd, const char *type, uint type_len,
 }
 
 
-static my_bool showstat_handlerton(THD *thd, st_plugin_int *plugin,
+static my_bool showstat_handlerton(THD *thd, plugin_ref plugin,
                                    void *arg)
 {
   enum ha_stat_type stat= *(enum ha_stat_type *) arg;
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
   if (hton->state == SHOW_OPTION_YES && hton->show_status &&
       hton->show_status(hton, thd, stat_print, stat))
     return TRUE;

sql/handler.h

@@ -876,6 +876,8 @@ public:
 class handler :public Sql_alloc
 {
   friend class ha_partition;
+  friend int ha_delete_table(THD*,handlerton*,const char*,const char*,
+                             const char*,bool);
 
  protected:
   struct st_table_share *table_share;   /* The table definition */
@@ -894,7 +896,12 @@ class handler :public Sql_alloc
   virtual int rnd_init(bool scan) =0;
   virtual int rnd_end() { return 0; }
   virtual ulonglong table_flags(void) const =0;
+
   void ha_statistic_increment(ulong SSV::*offset) const;
+  enum enum_tx_isolation ha_tx_isolation(void) const;
+  uint ha_sql_command(void) const;
+  void **ha_data(void) const;
+  THD *ha_thd(void) const;
 
   ha_rows estimation_rows_to_insert;
   virtual void start_bulk_insert(ha_rows rows) {}
@@ -1626,9 +1633,9 @@ extern ulong total_ha, total_ha_2pc;
 
 /* lookups */
 handlerton *ha_default_handlerton(THD *thd);
-handlerton *ha_resolve_by_name(THD *thd, const LEX_STRING *name);
+plugin_ref ha_resolve_by_name(THD *thd, const LEX_STRING *name);
+plugin_ref ha_lock_engine(THD *thd, handlerton *hton);
 handlerton *ha_resolve_by_legacy_type(THD *thd, enum legacy_db_type db_type);
-const char *ha_get_storage_engine(enum legacy_db_type db_type);
 handler *get_new_handler(TABLE_SHARE *share, MEM_ROOT *alloc,
                          handlerton *db_type);
 handlerton *ha_checktype(THD *thd, enum legacy_db_type database_type,

sql/item_func.cc

@@ -4887,7 +4887,7 @@ Item *get_system_var(THD *thd, enum_var_type var_type, LEX_STRING name,
     component_name= &component;			// Empty string
   }
 
-  if (!(var= find_sys_var(base_name->str, base_name->length)))
+  if (!(var= find_sys_var(thd, base_name->str, base_name->length)))
     return 0;
   if (component.str)
   {

sql/item_sum.cc

@@ -2469,7 +2469,7 @@ bool Item_sum_count_distinct::setup(THD *thd)
   table->file->extra(HA_EXTRA_NO_ROWS);		// Don't update rows
   table->no_rows=1;
 
-  if (table->s->db_type == heap_hton)
+  if (table->s->db_type() == heap_hton)
   {
     /*
       No blobs, otherwise it would have been MyISAM: set up a compare

sql/mysql_priv.h

@@ -546,11 +546,6 @@ inline THD *_current_thd(void)
 }
 #define current_thd _current_thd()
 
-/* below functions are required for plugins as THD class is opaque */
-my_bool thd_in_lock_tables(const THD *thd);
-my_bool thd_tablespace_op(const THD *thd);
-const char *thd_proc_info(THD *thd, const char *info);
-void **thd_ha_data(const THD *thd, const struct handlerton *hton);
 
 /*
   External variables
@@ -1098,6 +1093,7 @@ int add_status_vars(SHOW_VAR *list);
 void remove_status_vars(SHOW_VAR *list);
 void init_status_vars();
 void free_status_vars();
+void reset_status_vars();
 
 /* information schema */
 extern LEX_STRING information_schema_name;
@@ -1659,6 +1655,7 @@ extern pthread_mutex_t LOCK_server_started;
 extern pthread_cond_t COND_server_started;
 extern int mysqld_server_started;
 extern rw_lock_t LOCK_grant, LOCK_sys_init_connect, LOCK_sys_init_slave;
+extern rw_lock_t LOCK_system_variables_hash;
 extern pthread_cond_t COND_refresh, COND_thread_count, COND_manager;
 extern pthread_cond_t COND_global_read_lock;
 extern pthread_attr_t connection_attrib;
@@ -1667,7 +1664,7 @@ extern I_List<NAMED_LIST> key_caches;
 extern MY_BITMAP temp_pool;
 extern String my_empty_string;
 extern const String my_null_string;
-extern SHOW_VAR init_vars[], status_vars[], internal_vars[];
+extern SHOW_VAR status_vars[];
 extern struct system_variables global_system_variables;
 extern struct system_variables max_system_variables;
 extern struct system_status_var global_status_var;
@@ -1690,11 +1687,6 @@ extern TYPELIB log_output_typelib;
 
 /* optional things, have_* variables */
 
-extern SHOW_COMP_OPTION have_innodb;
-extern SHOW_COMP_OPTION have_csv_db;
-extern SHOW_COMP_OPTION have_ndbcluster;
-extern SHOW_COMP_OPTION have_partition_db;
-
 extern handlerton *partition_hton;
 extern handlerton *myisam_hton;
 extern handlerton *heap_hton;

sql/mysqld.cc

@@ -29,22 +29,13 @@
 
 #include "rpl_injector.h"
 
-#ifdef WITH_INNOBASE_STORAGE_ENGINE
-#define OPT_INNODB_DEFAULT 1
-#else
-#define OPT_INNODB_DEFAULT 0
-#endif
-#define OPT_BDB_DEFAULT 0
 #ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
-#define OPT_NDBCLUSTER_DEFAULT 0
 #if defined(NOT_ENOUGH_TESTED) \
   && defined(NDB_SHM_TRANSPORTER) && MYSQL_VERSION_ID >= 50000
 #define OPT_NDB_SHM_DEFAULT 1
 #else
 #define OPT_NDB_SHM_DEFAULT 0
 #endif
-#else
-#define OPT_NDBCLUSTER_DEFAULT 0
 #endif
 
 #ifndef DEFAULT_SKIP_THREAD_PRIORITY
@@ -323,7 +314,6 @@ static bool lower_case_table_names_used= 0;
 static bool volatile select_thread_in_use, signal_thread_in_use;
 static bool volatile ready_to_exit;
 static my_bool opt_debugging= 0, opt_external_locking= 0, opt_console= 0;
-static my_bool opt_ndbcluster;
 static my_bool opt_short_log_format= 0;
 static uint kill_cached_threads, wake_thread;
 static ulong killed_threads, thread_created;
@@ -366,7 +356,6 @@ my_bool opt_local_infile, opt_slave_compressed_protocol;
 my_bool opt_safe_user_create = 0, opt_no_mix_types = 0;
 my_bool opt_show_slave_auth_info, opt_sql_bin_update = 0;
 my_bool opt_log_slave_updates= 0;
-my_bool	opt_innodb;
 
 /*
   Legacy global handlerton. These will be removed (please do not add more).
@@ -375,44 +364,6 @@ handlerton *heap_hton;
 handlerton *myisam_hton;
 handlerton *partition_hton;
 
-#ifdef WITH_INNOBASE_STORAGE_ENGINE
-extern ulong innobase_fast_shutdown;
-extern ulong innobase_large_page_size;
-extern char *innobase_home, *innobase_tmpdir, *innobase_logdir;
-extern long innobase_lock_scan_time;
-extern long innobase_mirrored_log_groups, innobase_log_files_in_group;
-extern longlong innobase_log_file_size;
-extern long innobase_log_buffer_size;
-extern longlong innobase_buffer_pool_size;
-extern long innobase_additional_mem_pool_size;
-extern long innobase_file_io_threads, innobase_lock_wait_timeout;
-extern long innobase_force_recovery;
-extern long innobase_open_files;
-extern char *innobase_data_home_dir, *innobase_data_file_path;
-extern char *innobase_log_group_home_dir, *innobase_log_arch_dir;
-extern char *innobase_unix_file_flush_method;
-/* The following variables have to be my_bool for SHOW VARIABLES to work */
-extern my_bool innobase_log_archive,
-               innobase_use_doublewrite,
-               innobase_use_checksums,
-               innobase_use_large_pages,
-               innobase_use_native_aio,
-               innobase_file_per_table, innobase_locks_unsafe_for_binlog,
-               innobase_rollback_on_timeout,
-               innobase_create_status_file;
-extern "C" {
-extern ulong srv_max_buf_pool_modified_pct;
-extern ulong srv_max_purge_lag;
-extern ulong srv_auto_extend_increment;
-extern ulong srv_n_spin_wait_rounds;
-extern ulong srv_n_free_tickets_to_enter;
-extern ulong srv_thread_sleep_delay;
-extern ulong srv_thread_concurrency;
-extern ulong srv_commit_concurrency;
-extern ulong srv_flush_log_at_trx_commit;
-}
-#endif
-
 #ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
 const char *opt_ndbcluster_connectstring= 0;
 const char *opt_ndb_connectstring= 0;
@@ -594,6 +545,7 @@ pthread_mutex_t LOCK_prepared_stmt_count;
 pthread_mutex_t LOCK_des_key_file;
 #endif
 rw_lock_t	LOCK_grant, LOCK_sys_init_connect, LOCK_sys_init_slave;
+rw_lock_t	LOCK_system_variables_hash;
 pthread_cond_t COND_refresh, COND_thread_count, COND_global_read_lock;
 pthread_t signal_thread;
 pthread_attr_t connection_attrib;
@@ -625,6 +577,7 @@ static ulong opt_specialflag, opt_myisam_block_size;
 static char *opt_update_logname, *opt_binlog_index_name;
 static char *opt_tc_heuristic_recover;
 static char *mysql_home_ptr, *pidfile_name_ptr;
+static int defaults_argc;
 static char **defaults_argv;
 static char *opt_bin_logname;
 
@@ -716,7 +669,9 @@ struct st_VioSSLFd *ssl_acceptor_fd;
 
 pthread_handler_t signal_hand(void *arg);
 static void mysql_init_variables(void);
-static void get_options(int argc,char **argv);
+static void get_options(int *argc,char **argv);
+static my_bool get_one_option(int, const struct my_option *, char *);
+static void usage(void);
 static void set_server_version(void);
 static int init_thread_environment();
 static char *get_relative_path(const char *path);
@@ -1161,6 +1116,8 @@ void unireg_end(void)
 extern "C" void unireg_abort(int exit_code)
 {
   DBUG_ENTER("unireg_abort");
+  if (opt_help)
+    usage();
   if (exit_code)
     sql_print_error("Aborting\n");
   clean_up(exit_code || !opt_bootstrap); /* purecov: inspected */
@@ -1347,6 +1304,7 @@ static void clean_up_mutexes()
   (void) rwlock_destroy(&LOCK_sys_init_connect);
   (void) rwlock_destroy(&LOCK_sys_init_slave);
   (void) pthread_mutex_destroy(&LOCK_global_system_variables);
+  (void) rwlock_destroy(&LOCK_system_variables_hash);
   (void) pthread_mutex_destroy(&LOCK_global_read_lock);
   (void) pthread_mutex_destroy(&LOCK_uuid_generator);
   (void) pthread_mutex_destroy(&LOCK_prepared_stmt_count);
@@ -2753,7 +2711,8 @@ static int init_common_variables(const char *conf_file_name, int argc,
 
   load_defaults(conf_file_name, groups, &argc, &argv);
   defaults_argv=argv;
-  get_options(argc,argv);
+  defaults_argc=argc;
+  get_options(&defaults_argc, defaults_argv);
   set_server_version();
 
   DBUG_PRINT("info",("%s  Ver %s for %s on %s\n",my_progname,
@@ -2765,10 +2724,6 @@ static int init_common_variables(const char *conf_file_name, int argc,
   {
       my_use_large_pages= 1;
       my_large_page_size= opt_large_page_size;
-#ifdef WITH_INNOBASE_STORAGE_ENGINE
-      innobase_use_large_pages= 1;
-      innobase_large_page_size= opt_large_page_size;
-#endif
   }
 #endif /* HAVE_LARGE_PAGES */
 
@@ -2831,7 +2786,12 @@ static int init_common_variables(const char *conf_file_name, int argc,
   if (item_create_init())
     return 1;
   item_init();
-  set_var_init();
+  if (set_var_init())
+    return 1;
+#ifdef HAVE_REPLICATION
+  if (init_replication_sys_vars())
+    return 1;
+#endif
   mysys_uses_curses=0;
 #ifdef USE_REGEX
   my_regex_init(&my_charset_latin1);
@@ -2984,6 +2944,7 @@ static int init_thread_environment()
   (void) pthread_mutex_init(&LOCK_user_conn, MY_MUTEX_INIT_FAST);
   (void) pthread_mutex_init(&LOCK_active_mi, MY_MUTEX_INIT_FAST);
   (void) pthread_mutex_init(&LOCK_global_system_variables, MY_MUTEX_INIT_FAST);
+  (void) my_rwlock_init(&LOCK_system_variables_hash, NULL);
   (void) pthread_mutex_init(&LOCK_global_read_lock, MY_MUTEX_INIT_FAST);
   (void) pthread_mutex_init(&LOCK_prepared_stmt_count, MY_MUTEX_INIT_FAST);
   (void) pthread_mutex_init(&LOCK_uuid_generator, MY_MUTEX_INIT_FAST);
@@ -3319,10 +3280,42 @@ server.");
     using_update_log=1;
   }
 
-  if (plugin_init(opt_bootstrap))
+  if (plugin_init(&defaults_argc, defaults_argv, 
+                  (opt_noacl ? PLUGIN_INIT_SKIP_PLUGIN_TABLE : 0) |
+                  (opt_help ? PLUGIN_INIT_SKIP_INITIALIZATION : 0)))
   {
-    sql_print_error("Failed to init plugins.");
+    sql_print_error("Failed to initialize plugins.");
-    return 1;
+    unireg_abort(1);
+  }
+
+  if (opt_help)
+    unireg_abort(0);
+
+  /* we do want to exit if there are any other unknown options */
+  if (defaults_argc > 1)
+  {
+    int ho_error;
+    struct my_option no_opts[] =
+    {
+      {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
+    };
+    /*
+      We need to eat any 'loose' arguments first before we conclude
+      that there are unprocessed options
+    */
+    my_getopt_skip_unknown= 0;
+    
+    if ((ho_error= handle_options(&defaults_argc, &defaults_argv, no_opts,
+                                  get_one_option)))
+      unireg_abort(ho_error);
+    
+    if (defaults_argc)
+    {
+      fprintf(stderr, "%s: Too many arguments (first extra is '%s').\n"
+              "Use --verbose --help to get a list of available options\n", 
+              my_progname, *defaults_argv);
+      unireg_abort(1);
+    }
   }
 
   /* We have to initialize the storage engines before CSV logging */
@@ -3353,7 +3346,8 @@ server.");
   else
   {
     /* fall back to the log files if tables are not present */
-    if (have_csv_db == SHOW_OPTION_NO)
+    LEX_STRING csv_name={C_STRING_WITH_LEN("csv")};
+    if (!plugin_is_ready(&csv_name, MYSQL_STORAGE_ENGINE_PLUGIN))
     {
       /* purecov: begin inspected */
       sql_print_error("CSV engine is not present, falling back to the "
@@ -3373,11 +3367,16 @@ server.");
   /*
     Check that the default storage engine is actually available.
   */
+  if (default_storage_engine_str)
   {
     LEX_STRING name= { default_storage_engine_str,
                        strlen(default_storage_engine_str) };
-    handlerton *hton= ha_resolve_by_name(0, &name);
+    plugin_ref plugin;
-    if (hton == NULL)
+    handlerton *hton;
+    
+    if ((plugin= ha_resolve_by_name(0, &name)))
+      hton= plugin_data(plugin, handlerton*);
+    else
     {
       sql_print_error("Unknown/unsupported table type: %s",
                       default_storage_engine_str);
@@ -3391,9 +3390,17 @@ server.");
                         default_storage_engine_str);
         unireg_abort(1);
       }
-      hton= myisam_hton;
+      DBUG_ASSERT(global_system_variables.table_plugin);
+    }
+    else
+    {
+      /*
+        Need to unlock as global_system_variables.table_plugin 
+        was acquired during plugin_init()
+      */
+      plugin_unlock(0, global_system_variables.table_plugin);
+      global_system_variables.table_plugin= plugin;
     }
-    global_system_variables.table_type= hton;
   }
 
   tc_log= (total_ha_2pc > 1 ? (opt_bin_log  ?
@@ -4797,11 +4804,6 @@ enum options_mysqld
   OPT_STORAGE_ENGINE,          OPT_INIT_FILE,
   OPT_DELAY_KEY_WRITE_ALL,     OPT_SLOW_QUERY_LOG,
   OPT_DELAY_KEY_WRITE,	       OPT_CHARSETS_DIR,
-  OPT_BDB_HOME,                OPT_BDB_LOG,
-  OPT_BDB_TMP,                 OPT_BDB_SYNC,
-  OPT_BDB_LOCK,                OPT_BDB,
-  OPT_BDB_NO_RECOVER,          OPT_BDB_SHARED,
-  OPT_BDB_DATA_DIRECT,         OPT_BDB_LOG_DIRECT,
   OPT_MASTER_HOST,             OPT_MASTER_USER,
   OPT_MASTER_PASSWORD,         OPT_MASTER_PORT,
   OPT_MASTER_INFO_FILE,        OPT_MASTER_CONNECT_RETRY,
@@ -4820,28 +4822,14 @@ enum options_mysqld
   OPT_WANT_CORE,               OPT_CONCURRENT_INSERT,
   OPT_MEMLOCK,                 OPT_MYISAM_RECOVER,
   OPT_REPLICATE_REWRITE_DB,    OPT_SERVER_ID,
-  OPT_SKIP_SLAVE_START,        OPT_SKIP_INNOBASE,
+  OPT_SKIP_SLAVE_START,        OPT_SAFE_SHOW_DB, 
   OPT_SAFEMALLOC_MEM_LIMIT,    OPT_REPLICATE_DO_TABLE,
   OPT_REPLICATE_IGNORE_TABLE,  OPT_REPLICATE_WILD_DO_TABLE,
   OPT_REPLICATE_WILD_IGNORE_TABLE, OPT_REPLICATE_SAME_SERVER_ID,
   OPT_DISCONNECT_SLAVE_EVENT_COUNT, OPT_TC_HEURISTIC_RECOVER,
   OPT_ABORT_SLAVE_EVENT_COUNT,
-  OPT_INNODB_DATA_HOME_DIR,
-  OPT_INNODB_DATA_FILE_PATH,
-  OPT_INNODB_LOG_GROUP_HOME_DIR,
-  OPT_INNODB_LOG_ARCH_DIR,
-  OPT_INNODB_LOG_ARCHIVE,
-  OPT_INNODB_FLUSH_LOG_AT_TRX_COMMIT,
-  OPT_INNODB_FLUSH_METHOD,
-  OPT_INNODB_DOUBLEWRITE,
-  OPT_INNODB_CHECKSUMS,
-  OPT_INNODB_FAST_SHUTDOWN,
-  OPT_INNODB_FILE_PER_TABLE, OPT_CRASH_BINLOG_INNODB,
-  OPT_INNODB_LOCKS_UNSAFE_FOR_BINLOG,
   OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,
-  OPT_SAFE_SHOW_DB, OPT_INNODB_SAFE_BINLOG,
+  OPT_ENGINE_CONDITION_PUSHDOWN, OPT_NDB_CONNECTSTRING, 
-  OPT_INNODB, OPT_ISAM,
-  OPT_ENGINE_CONDITION_PUSHDOWN, OPT_NDBCLUSTER, OPT_NDB_CONNECTSTRING, 
   OPT_NDB_USE_EXACT_COUNT, OPT_NDB_USE_TRANSACTIONS,
   OPT_NDB_FORCE_SEND, OPT_NDB_AUTOINCREMENT_PREFETCH_SZ,
   OPT_NDB_SHM, OPT_NDB_OPTIMIZED_NODE_SELECTION, OPT_NDB_CACHE_CHECK_TIME,
@@ -4904,33 +4892,6 @@ enum options_mysqld
   OPT_THREAD_CONCURRENCY, OPT_THREAD_CACHE_SIZE,
   OPT_TMP_TABLE_SIZE, OPT_THREAD_STACK,
   OPT_WAIT_TIMEOUT, OPT_MYISAM_REPAIR_THREADS,
-  OPT_INNODB_MIRRORED_LOG_GROUPS,
-  OPT_INNODB_LOG_FILES_IN_GROUP,
-  OPT_INNODB_LOG_FILE_SIZE,
-  OPT_INNODB_LOG_BUFFER_SIZE,
-  OPT_INNODB_BUFFER_POOL_SIZE,
-  OPT_INNODB_BUFFER_POOL_AWE_MEM_MB,
-  OPT_INNODB_ADDITIONAL_MEM_POOL_SIZE,
-  OPT_INNODB_MAX_PURGE_LAG,
-  OPT_INNODB_FILE_IO_THREADS,
-  OPT_INNODB_LOCK_WAIT_TIMEOUT,
-  OPT_INNODB_THREAD_CONCURRENCY,
-  OPT_INNODB_COMMIT_CONCURRENCY,
-  OPT_INNODB_FORCE_RECOVERY,
-  OPT_INNODB_STATUS_FILE,
-  OPT_INNODB_MAX_DIRTY_PAGES_PCT,
-  OPT_INNODB_TABLE_LOCKS,
-  OPT_INNODB_SUPPORT_XA,
-  OPT_INNODB_OPEN_FILES,
-  OPT_INNODB_AUTOEXTEND_INCREMENT,
-  OPT_INNODB_SYNC_SPIN_LOOPS,
-  OPT_INNODB_CONCURRENCY_TICKETS,
-  OPT_INNODB_THREAD_SLEEP_DELAY,
-  OPT_BDB_CACHE_SIZE,
-  OPT_BDB_CACHE_PARTS,
-  OPT_BDB_LOG_BUFFER_SIZE,
-  OPT_BDB_MAX_LOCK,
-  OPT_BDB_REGION_SIZE,
   OPT_ERROR_LOG_FILE,
   OPT_DEFAULT_WEEK_FORMAT,
   OPT_RANGE_ALLOC_BLOCK_SIZE, OPT_ALLOW_SUSPICIOUS_UDFS,
@@ -4940,7 +4901,6 @@ enum options_mysqld
   OPT_SYNC_REPLICATION,
   OPT_SYNC_REPLICATION_SLAVE_ID,
   OPT_SYNC_REPLICATION_TIMEOUT,
-  OPT_BDB_NOSYNC,
   OPT_ENABLE_SHARED_MEMORY,
   OPT_SHARED_MEMORY_BASE_NAME,
   OPT_OLD_PASSWORDS,
@@ -4970,12 +4930,12 @@ enum options_mysqld
   OPT_OLD_STYLE_USER_LIMITS,
   OPT_LOG_SLOW_ADMIN_STATEMENTS,
   OPT_TABLE_LOCK_WAIT_TIMEOUT,
+  OPT_PLUGIN_LOAD,
   OPT_PLUGIN_DIR,
   OPT_LOG_OUTPUT,
   OPT_PORT_OPEN_TIMEOUT,
   OPT_GENERAL_LOG,
   OPT_SLOW_LOG,
-  OPT_MERGE,
   OPT_THREAD_HANDLING,
   OPT_INNODB_ROLLBACK_ON_TIMEOUT
 };
@@ -5193,94 +5153,6 @@ Disable with --skip-large-pages.",
   {"init-slave", OPT_INIT_SLAVE, "Command(s) that are executed when a slave connects to this master",
    (gptr*) &opt_init_slave, (gptr*) &opt_init_slave, 0, GET_STR_ALLOC,
    REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"innodb", OPT_INNODB, "Enable InnoDB (if this version of MySQL supports it). \
-Disable with --skip-innodb (will save memory).",
-   (gptr*) &opt_innodb, (gptr*) &opt_innodb, 0, GET_BOOL, NO_ARG, OPT_INNODB_DEFAULT, 0, 0,
-   0, 0, 0},
-#ifdef WITH_INNOBASE_STORAGE_ENGINE
-  {"innodb_checksums", OPT_INNODB_CHECKSUMS, "Enable InnoDB checksums validation (enabled by default). \
-Disable with --skip-innodb-checksums.", (gptr*) &innobase_use_checksums,
-   (gptr*) &innobase_use_checksums, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
-#endif
-  {"innodb_data_file_path", OPT_INNODB_DATA_FILE_PATH,
-   "Path to individual files and their sizes.",
-   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-#ifdef WITH_INNOBASE_STORAGE_ENGINE
-  {"innodb_data_home_dir", OPT_INNODB_DATA_HOME_DIR,
-   "The common part for InnoDB table spaces.", (gptr*) &innobase_data_home_dir,
-   (gptr*) &innobase_data_home_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0,
-   0},
-  {"innodb_doublewrite", OPT_INNODB_DOUBLEWRITE, "Enable InnoDB doublewrite buffer (enabled by default). \
-Disable with --skip-innodb-doublewrite.", (gptr*) &innobase_use_doublewrite,
-   (gptr*) &innobase_use_doublewrite, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
-  {"innodb_fast_shutdown", OPT_INNODB_FAST_SHUTDOWN,
-   "Speeds up the shutdown process of the InnoDB storage engine. Possible "
-   "values are 0, 1 (faster)"
-   /*
-     NetWare can't close unclosed files, can't automatically kill remaining
-     threads, etc, so on this OS we disable the crash-like InnoDB shutdown.
-   */
-#ifndef __NETWARE__
-   " or 2 (fastest - crash-like)"
-#endif
-   ".",
-   (gptr*) &innobase_fast_shutdown,
-   (gptr*) &innobase_fast_shutdown, 0, GET_ULONG, OPT_ARG, 1, 0,
-   IF_NETWARE(1,2), 0, 0, 0},
-  {"innodb_file_per_table", OPT_INNODB_FILE_PER_TABLE,
-   "Stores each InnoDB table to an .ibd file in the database dir.",
-   (gptr*) &innobase_file_per_table,
-   (gptr*) &innobase_file_per_table, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
-  {"innodb_flush_log_at_trx_commit", OPT_INNODB_FLUSH_LOG_AT_TRX_COMMIT,
-   "Set to 0 (write and flush once per second), 1 (write and flush at each commit) or 2 (write at commit, flush once per second).",
-   (gptr*) &srv_flush_log_at_trx_commit,
-   (gptr*) &srv_flush_log_at_trx_commit,
-   0, GET_ULONG, OPT_ARG,  1, 0, 2, 0, 0, 0},
-  {"innodb_flush_method", OPT_INNODB_FLUSH_METHOD,
-   "With which method to flush data.", (gptr*) &innobase_unix_file_flush_method,
-   (gptr*) &innobase_unix_file_flush_method, 0, GET_STR, REQUIRED_ARG, 0, 0, 0,
-   0, 0, 0},
-  {"innodb_locks_unsafe_for_binlog", OPT_INNODB_LOCKS_UNSAFE_FOR_BINLOG,
-   "Force InnoDB to not use next-key locking, to use only row-level locking.",
-   (gptr*) &innobase_locks_unsafe_for_binlog,
-   (gptr*) &innobase_locks_unsafe_for_binlog, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
-  {"innodb_log_arch_dir", OPT_INNODB_LOG_ARCH_DIR,
-   "Where full logs should be archived.", (gptr*) &innobase_log_arch_dir,
-   (gptr*) &innobase_log_arch_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"innodb_log_archive", OPT_INNODB_LOG_ARCHIVE,
-   "Set to 1 if you want to have logs archived.", 0, 0, 0, GET_LONG, OPT_ARG,
-   0, 0, 0, 0, 0, 0},
-  {"innodb_log_group_home_dir", OPT_INNODB_LOG_GROUP_HOME_DIR,
-   "Path to InnoDB log files.", (gptr*) &innobase_log_group_home_dir,
-   (gptr*) &innobase_log_group_home_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0,
-   0, 0},
-  {"innodb_max_dirty_pages_pct", OPT_INNODB_MAX_DIRTY_PAGES_PCT,
-   "Percentage of dirty pages allowed in bufferpool.", (gptr*) &srv_max_buf_pool_modified_pct,
-   (gptr*) &srv_max_buf_pool_modified_pct, 0, GET_ULONG, REQUIRED_ARG, 90, 0, 100, 0, 0, 0},
-  {"innodb_max_purge_lag", OPT_INNODB_MAX_PURGE_LAG,
-   "Desired maximum length of the purge queue (0 = no limit)",
-   (gptr*) &srv_max_purge_lag,
-   (gptr*) &srv_max_purge_lag, 0, GET_LONG, REQUIRED_ARG, 0, 0, ~0L,
-   0, 1L, 0},
-  {"innodb_rollback_on_timeout", OPT_INNODB_ROLLBACK_ON_TIMEOUT,
-   "Roll back the complete transaction on lock wait timeout, for 4.x compatibility (disabled by default)",
-   (gptr*) &innobase_rollback_on_timeout, (gptr*) &innobase_rollback_on_timeout,
-   0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
-  {"innodb_status_file", OPT_INNODB_STATUS_FILE,
-   "Enable SHOW INNODB STATUS output in the innodb_status.<pid> file",
-   (gptr*) &innobase_create_status_file, (gptr*) &innobase_create_status_file,
-   0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
-  {"innodb_support_xa", OPT_INNODB_SUPPORT_XA,
-   "Enable InnoDB support for the XA two-phase commit",
-   (gptr*) &global_system_variables.innodb_support_xa,
-   (gptr*) &global_system_variables.innodb_support_xa,
-   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
-  {"innodb_table_locks", OPT_INNODB_TABLE_LOCKS,
-   "Enable InnoDB locking in LOCK TABLES",
-   (gptr*) &global_system_variables.innodb_table_locks,
-   (gptr*) &global_system_variables.innodb_table_locks,
-   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
-#endif /* End WITH_INNOBASE_STORAGE_ENGINE */
    {"language", 'L',
    "Client error messages in given language. May be given as a full path.",
    (gptr*) &language_ptr, (gptr*) &language_ptr, 0, GET_STR, REQUIRED_ARG,
@@ -5454,10 +5326,6 @@ master-ssl",
    "Syntax: myisam-recover[=option[,option...]], where option can be DEFAULT, BACKUP, FORCE or QUICK.",
    (gptr*) &myisam_recover_options_str, (gptr*) &myisam_recover_options_str, 0,
    GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
-  {"ndbcluster", OPT_NDBCLUSTER, "Enable NDB Cluster (if this version of MySQL supports it). \
-Disable with --skip-ndbcluster (will save memory).",
-   (gptr*) &opt_ndbcluster, (gptr*) &opt_ndbcluster, 0, GET_BOOL, NO_ARG,
-   OPT_NDBCLUSTER_DEFAULT, 0, 0, 0, 0, 0},
 #ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
   {"ndb-connectstring", OPT_NDB_CONNECTSTRING,
    "Connect string for ndbcluster.",
@@ -5913,84 +5781,6 @@ log and this option does nothing anymore.",
     (gptr*) &global_system_variables.group_concat_max_len,
     (gptr*) &max_system_variables.group_concat_max_len, 0, GET_ULONG,
     REQUIRED_ARG, 1024, 4, (long) ~0, 0, 1, 0},
-#ifdef WITH_INNOBASE_STORAGE_ENGINE
-  {"innodb_additional_mem_pool_size", OPT_INNODB_ADDITIONAL_MEM_POOL_SIZE,
-   "Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.",
-   (gptr*) &innobase_additional_mem_pool_size,
-   (gptr*) &innobase_additional_mem_pool_size, 0, GET_LONG, REQUIRED_ARG,
-   1*1024*1024L, 512*1024L, ~0L, 0, 1024, 0},
-  {"innodb_autoextend_increment", OPT_INNODB_AUTOEXTEND_INCREMENT,
-   "Data file autoextend increment in megabytes",
-   (gptr*) &srv_auto_extend_increment,
-   (gptr*) &srv_auto_extend_increment,
-   0, GET_LONG, REQUIRED_ARG, 8L, 1L, 1000L, 0, 1L, 0},
-  {"innodb_buffer_pool_size", OPT_INNODB_BUFFER_POOL_SIZE,
-   "The size of the memory buffer InnoDB uses to cache data and indexes of its tables.",
-   (gptr*) &innobase_buffer_pool_size, (gptr*) &innobase_buffer_pool_size, 0,
-   GET_LL, REQUIRED_ARG, 8*1024*1024L, 1024*1024L, LONGLONG_MAX, 0,
-   1024*1024L, 0},
-  {"innodb_commit_concurrency", OPT_INNODB_COMMIT_CONCURRENCY,
-   "Helps in performance tuning in heavily concurrent environments.",
-   (gptr*) &srv_commit_concurrency, (gptr*) &srv_commit_concurrency,
-   0, GET_LONG, REQUIRED_ARG, 0, 0, 1000, 0, 1, 0},
-  {"innodb_concurrency_tickets", OPT_INNODB_CONCURRENCY_TICKETS,
-   "Number of times a thread is allowed to enter InnoDB within the same \
-    SQL query after it has once got the ticket",
-   (gptr*) &srv_n_free_tickets_to_enter,
-   (gptr*) &srv_n_free_tickets_to_enter,
-   0, GET_LONG, REQUIRED_ARG, 500L, 1L, ~0L, 0, 1L, 0},
-  {"innodb_file_io_threads", OPT_INNODB_FILE_IO_THREADS,
-   "Number of file I/O threads in InnoDB.", (gptr*) &innobase_file_io_threads,
-   (gptr*) &innobase_file_io_threads, 0, GET_LONG, REQUIRED_ARG, 4, 4, 64, 0,
-   1, 0},
-  {"innodb_force_recovery", OPT_INNODB_FORCE_RECOVERY,
-   "Helps to save your data in case the disk image of the database becomes corrupt.",
-   (gptr*) &innobase_force_recovery, (gptr*) &innobase_force_recovery, 0,
-   GET_LONG, REQUIRED_ARG, 0, 0, 6, 0, 1, 0},
-  {"innodb_lock_wait_timeout", OPT_INNODB_LOCK_WAIT_TIMEOUT,
-   "Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back.",
-   (gptr*) &innobase_lock_wait_timeout, (gptr*) &innobase_lock_wait_timeout,
-   0, GET_LONG, REQUIRED_ARG, 50, 1, 1024 * 1024 * 1024, 0, 1, 0},
-  {"innodb_log_buffer_size", OPT_INNODB_LOG_BUFFER_SIZE,
-   "The size of the buffer which InnoDB uses to write log to the log files on disk.",
-   (gptr*) &innobase_log_buffer_size, (gptr*) &innobase_log_buffer_size, 0,
-   GET_LONG, REQUIRED_ARG, 1024*1024L, 256*1024L, ~0L, 0, 1024, 0},
-  {"innodb_log_file_size", OPT_INNODB_LOG_FILE_SIZE,
-   "Size of each log file in a log group.",
-   (gptr*) &innobase_log_file_size, (gptr*) &innobase_log_file_size, 0,
-   GET_LL, REQUIRED_ARG, 5*1024*1024L, 1*1024*1024L, LONGLONG_MAX, 0,
-   1024*1024L, 0},
-  {"innodb_log_files_in_group", OPT_INNODB_LOG_FILES_IN_GROUP,
-   "Number of log files in the log group. InnoDB writes to the files in a circular fashion. Value 3 is recommended here.",
-   (gptr*) &innobase_log_files_in_group, (gptr*) &innobase_log_files_in_group,
-   0, GET_LONG, REQUIRED_ARG, 2, 2, 100, 0, 1, 0},
-  {"innodb_mirrored_log_groups", OPT_INNODB_MIRRORED_LOG_GROUPS,
-   "Number of identical copies of log groups we keep for the database. Currently this should be set to 1.",
-   (gptr*) &innobase_mirrored_log_groups,
-   (gptr*) &innobase_mirrored_log_groups, 0, GET_LONG, REQUIRED_ARG, 1, 1, 10,
-   0, 1, 0},
-  {"innodb_open_files", OPT_INNODB_OPEN_FILES,
-   "How many files at the maximum InnoDB keeps open at the same time.",
-   (gptr*) &innobase_open_files, (gptr*) &innobase_open_files, 0,
-   GET_LONG, REQUIRED_ARG, 300L, 10L, ~0L, 0, 1L, 0},
-  {"innodb_sync_spin_loops", OPT_INNODB_SYNC_SPIN_LOOPS,
-   "Count of spin-loop rounds in InnoDB mutexes",
-   (gptr*) &srv_n_spin_wait_rounds,
-   (gptr*) &srv_n_spin_wait_rounds,
-   0, GET_LONG, REQUIRED_ARG, 20L, 0L, ~0L, 0, 1L, 0},
-  {"innodb_thread_concurrency", OPT_INNODB_THREAD_CONCURRENCY,
-   "Helps in performance tuning in heavily concurrent environments. "
-   "Sets the maximum number of threads allowed inside InnoDB. Value 0"
-   " will disable the thread throttling.",
-   (gptr*) &srv_thread_concurrency, (gptr*) &srv_thread_concurrency,
-   0, GET_LONG, REQUIRED_ARG, 8, 0, 1000, 0, 1, 0},
-  {"innodb_thread_sleep_delay", OPT_INNODB_THREAD_SLEEP_DELAY,
-   "Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0"
-    " disable a sleep",
-   (gptr*) &srv_thread_sleep_delay,
-   (gptr*) &srv_thread_sleep_delay,
-   0, GET_LONG, REQUIRED_ARG, 10000L, 0L, ~0L, 0, 1L, 0},
-#endif /* WITH_INNOBASE_STORAGE_ENGINE */
   {"interactive_timeout", OPT_INTERACTIVE_TIMEOUT,
    "The number of seconds the server waits for activity on an interactive connection before closing it.",
    (gptr*) &global_system_variables.net_interactive_timeout,
@@ -6216,6 +6006,11 @@ The minimum value for this variable is 4096.",
    "Directory for plugins.",
    (gptr*) &opt_plugin_dir_ptr, (gptr*) &opt_plugin_dir_ptr, 0,
    GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"plugin_load", OPT_PLUGIN_LOAD,
+   "Optional colon separated list of plugins to load, where each plugin is "
+   "identified by name and path to library seperated by an equals.",
+   (gptr*) &opt_plugin_load, (gptr*) &opt_plugin_load, 0,
+   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
    {"preload_buffer_size", OPT_PRELOAD_BUFFER_SIZE,
     "The size of the buffer that is allocated when preloading indexes",
     (gptr*) &global_system_variables.preload_buff_size,
@@ -7015,8 +6810,8 @@ Starts the MySQL database server\n");
   fix_paths();
   set_ports();
 
-  my_print_help(my_long_options);
+  /* Print out all the options including plugin supplied options */
-  my_print_variables(my_long_options);
+  my_print_help_inc_plugins(my_long_options, sizeof(my_long_options)/sizeof(my_option));
 
   puts("\n\
 To see what values a running MySQL server is using, type\n\
@@ -7058,6 +6853,7 @@ static void mysql_init_variables(void)
   mqh_used= 0;
   segfaulted= kill_in_progress= 0;
   cleanup_done= 0;
+  defaults_argc= 0;
   defaults_argv= 0;
   server_id_supplied= 0;
   test_flags= select_errors= dropping_tables= ha_open_options=0;
@@ -7145,7 +6941,7 @@ static void mysql_init_variables(void)
 
   /* Set default values for some option variables */
   default_storage_engine_str= (char*) "MyISAM";
-  global_system_variables.table_type= myisam_hton;
+  global_system_variables.table_plugin= NULL;
   global_system_variables.tx_isolation= ISO_REPEATABLE_READ;
   global_system_variables.select_limit= (ulonglong) HA_POS_ERROR;
   max_system_variables.select_limit=    (ulonglong) HA_POS_ERROR;
@@ -7166,36 +6962,13 @@ static void mysql_init_variables(void)
 			     "d:t:i:o,/tmp/mysqld.trace");
 #endif
   opt_error_log= IF_WIN(1,0);
-#ifdef WITH_INNOBASE_STORAGE_ENGINE
-  have_innodb= SHOW_OPTION_YES;
-#else
-  have_innodb= SHOW_OPTION_NO;
-#endif
-#ifdef WITH_CSV_STORAGE_ENGINE
-  have_csv_db= SHOW_OPTION_YES;
-#else
-  have_csv_db= SHOW_OPTION_NO;
-#endif
 #ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
-    have_ndbcluster= SHOW_OPTION_DISABLED;
-#else
-    have_ndbcluster= SHOW_OPTION_NO;
-#endif
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-    have_partition_db= SHOW_OPTION_YES;
-#else
-    have_partition_db= SHOW_OPTION_NO;
-#endif
-#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
-  have_ndbcluster=SHOW_OPTION_DISABLED;
   global_system_variables.ndb_index_stat_enable=FALSE;
   max_system_variables.ndb_index_stat_enable=TRUE;
   global_system_variables.ndb_index_stat_cache_entries=32;
   max_system_variables.ndb_index_stat_cache_entries=~0L;
   global_system_variables.ndb_index_stat_update_freq=20;
   max_system_variables.ndb_index_stat_update_freq=~0L;
-#else
-  have_ndbcluster=SHOW_OPTION_NO;
 #endif
 #ifdef HAVE_OPENSSL
   have_openssl=SHOW_OPTION_YES;
@@ -7655,17 +7428,6 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
     global_system_variables.tx_isolation= (type-1);
     break;
   }
-  case OPT_MERGE:
-  case OPT_BDB:
-    break;
-  case OPT_NDBCLUSTER:
-#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
-    if (opt_ndbcluster)
-      have_ndbcluster= SHOW_OPTION_YES;
-    else
-      have_ndbcluster= SHOW_OPTION_DISABLED;
-#endif
-    break;
 #ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
   case OPT_NDB_MGMD:
   case OPT_NDB_NODEID:
@@ -7713,24 +7475,6 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
       ndb_extra_logging= atoi(argument);
     break;
 #endif
-  case OPT_INNODB:
-#ifdef WITH_INNOBASE_STORAGE_ENGINE
-    if (opt_innodb)
-      have_innodb= SHOW_OPTION_YES;
-    else
-      have_innodb= SHOW_OPTION_DISABLED;
-#endif
-    break;
-  case OPT_INNODB_DATA_FILE_PATH:
-#ifdef WITH_INNOBASE_STORAGE_ENGINE
-    innobase_data_file_path= argument;
-#endif
-    break;
-#ifdef WITH_INNOBASE_STORAGE_ENGINE
-  case OPT_INNODB_LOG_ARCHIVE:
-    innobase_log_archive= argument ? test(atoi(argument)) : 1;
-    break;
-#endif /* WITH_INNOBASE_STORAGE_ENGINE */
   case OPT_MYISAM_RECOVER:
   {
     if (!argument || !argument[0])
@@ -7884,7 +7628,7 @@ static void option_error_reporter(enum loglevel level, const char *format, ...)
 }
 
 
-static void get_options(int argc,char **argv)
+static void get_options(int *argc,char **argv)
 {
   int ho_error;
 
@@ -7892,34 +7636,20 @@ static void get_options(int argc,char **argv)
   strmake(def_ft_boolean_syntax, ft_boolean_syntax,
 	  sizeof(ft_boolean_syntax)-1);
   my_getopt_error_reporter= option_error_reporter;
-  if ((ho_error= handle_options(&argc, &argv, my_long_options,
+
+  /* Skip unknown options so that they may be processed later by plugins */
+  my_getopt_skip_unknown= TRUE;
+
+  if ((ho_error= handle_options(argc, &argv, my_long_options,
                                 get_one_option)))
     exit(ho_error);
+  (*argc)++; /* add back one for the progname handle_options removes */
+             /* no need to do this for argv as we are discarding it. */
 
-#ifndef WITH_NDBCLUSTER_STORAGE_ENGINE
-  if (opt_ndbcluster)
-    sql_print_warning("this binary does not contain NDBCLUSTER storage engine");
-#endif
-#ifndef WITH_INNOBASE_STORAGE_ENGINE
-  if (opt_innodb)
-    sql_print_warning("this binary does not contain INNODB storage engine");
-#endif
   if ((opt_log_slow_admin_statements || opt_log_queries_not_using_indexes) &&
       !opt_slow_log)
     sql_print_warning("options --log-slow-admin-statements and --log-queries-not-using-indexes have no effect if --log-slow-queries is not set");
 
-  if (argc > 0)
-  {
-    fprintf(stderr, "%s: Too many arguments (first extra is '%s').\nUse --help to get a list of available options\n", my_progname, *argv);
-    /* FIXME add EXIT_TOO_MANY_ARGUMENTS to "mysys_err.h" and return that code? */
-    exit(1);
-  }
-
-  if (opt_help)
-  {
-    usage();
-    exit(0);
-  }
 #if defined(HAVE_BROKEN_REALPATH)
   my_use_symdir=0;
   my_disable_symlinks=1;
@@ -8238,12 +7968,7 @@ void refresh_status(THD *thd)
   bzero((char*) &thd->status_var, sizeof(thd->status_var));
 
   /* Reset some global variables */
-  for (SHOW_VAR *ptr= status_vars; ptr->name; ptr++)
+  reset_status_vars();
-  {
-    /* Note that SHOW_LONG_NOFLUSH variables are not reset */
-    if (ptr->type == SHOW_LONG)
-      *(ulong*) ptr->value= 0;
-  }
 
   /* Reset the counters of all key caches (default and named). */
   process_key_caches(reset_key_cache_counters);
@@ -8262,50 +7987,9 @@ void refresh_status(THD *thd)
 
 
 /*****************************************************************************
-  Instantiate have_xyx for missing storage engines
+  Instantiate variables for missing storage engines
+  This section should go away soon
 *****************************************************************************/
-#undef have_innodb
-#undef have_ndbcluster
-#undef have_csv_db
-
-SHOW_COMP_OPTION have_innodb= SHOW_OPTION_NO;
-SHOW_COMP_OPTION have_ndbcluster= SHOW_OPTION_NO;
-SHOW_COMP_OPTION have_csv_db= SHOW_OPTION_NO;
-SHOW_COMP_OPTION have_partition_db= SHOW_OPTION_NO;
-
-#ifndef WITH_INNOBASE_STORAGE_ENGINE
-uint innobase_flush_log_at_trx_commit;
-ulong innobase_fast_shutdown;
-long innobase_mirrored_log_groups, innobase_log_files_in_group;
-longlong innobase_log_file_size;
-long innobase_log_buffer_size;
-longlong innobase_buffer_pool_size;
-long innobase_additional_mem_pool_size;
-long innobase_file_io_threads, innobase_lock_wait_timeout;
-long innobase_force_recovery;
-long innobase_open_files;
-char *innobase_data_home_dir, *innobase_data_file_path;
-char *innobase_log_group_home_dir, *innobase_log_arch_dir;
-char *innobase_unix_file_flush_method;
-my_bool innobase_log_archive,
-        innobase_use_doublewrite,
-        innobase_use_checksums,
-        innobase_file_per_table,
-        innobase_locks_unsafe_for_binlog,
-        innobase_rollback_on_timeout;
-
-extern "C" {
-ulong srv_max_buf_pool_modified_pct;
-ulong srv_max_purge_lag;
-ulong srv_auto_extend_increment;
-ulong srv_n_spin_wait_rounds;
-ulong srv_n_free_tickets_to_enter;
-ulong srv_thread_sleep_delay;
-ulong srv_thread_concurrency;
-ulong srv_commit_concurrency;
-}
-
-#endif
 
 #ifndef WITH_NDBCLUSTER_STORAGE_ENGINE
 ulong ndb_cache_check_time;

sql/set_var.h

@@ -26,6 +26,7 @@
 
 class sys_var;
 class set_var;
+class sys_var_pluginvar; /* opaque */
 typedef struct system_variables SV;
 typedef struct my_locale_st MY_LOCALE;
 
@@ -37,11 +38,15 @@ typedef void (*sys_after_update_func)(THD *,enum_var_type);
 typedef void (*sys_set_default_func)(THD *, enum_var_type);
 typedef byte *(*sys_value_ptr_func)(THD *thd);
 
+struct sys_var_chain
+{
+  sys_var *first;
+  sys_var *last;
+};
+
 class sys_var
 {
 public:
-  static sys_var *first;
-  static uint sys_vars;
   sys_var *next;
   struct my_option *option_limits;	/* Updated by by set_var_init() */
   uint name_length;			/* Updated by by set_var_init() */
@@ -52,13 +57,15 @@ public:
   sys_var(const char *name_arg,sys_after_update_func func= NULL)
     :name(name_arg), after_update(func)
     , no_support_one_shot(1)
-  { add_sys_var(); }
+  {}
   virtual ~sys_var() {}
-  void add_sys_var()
+  void chain_sys_var(sys_var_chain *chain_arg)
   {
-    next= first;
+    if (chain_arg->last)
-    first= this;
+      chain_arg->last->next= this;
-    sys_vars++;
+    else
+      chain_arg->first= this;
+    chain_arg->last= this;
   }
   virtual bool check(THD *thd, set_var *var);
   bool check_enum(THD *thd, set_var *var, TYPELIB *enum_names);
@@ -77,6 +84,7 @@ public:
   Item *item(THD *thd, enum_var_type type, LEX_STRING *base);
   virtual bool is_struct() { return 0; }
   virtual bool is_readonly() const { return 0; }
+  virtual sys_var_pluginvar *cast_pluginvar() { return 0; }
 };
 
 
@@ -105,12 +113,12 @@ class sys_var_long_ptr_global: public sys_var_global
 {
 public:
   ulong *value;
-  sys_var_long_ptr_global(const char *name_arg, ulong *value_ptr_arg,
+  sys_var_long_ptr_global(sys_var_chain *chain, const char *name_arg, ulong *value_ptr_arg,
                         pthread_mutex_t *guard_arg,
                         sys_after_update_func after_update_arg= NULL)
     :sys_var_global(name_arg, after_update_arg, guard_arg),
     value(value_ptr_arg)
-    {}
+  { chain_sys_var(chain); }
   bool check(THD *thd, set_var *var);
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
@@ -127,7 +135,7 @@ public:
 class sys_var_long_ptr :public sys_var_long_ptr_global
 {
 public:
-  sys_var_long_ptr(const char *name_arg, ulong *value_ptr,
+  sys_var_long_ptr(sys_var_chain *chain, const char *name_arg, ulong *value_ptr,
                    sys_after_update_func after_update_arg= NULL);
 };
 
@@ -136,11 +144,13 @@ class sys_var_ulonglong_ptr :public sys_var
 {
 public:
   ulonglong *value;
-  sys_var_ulonglong_ptr(const char *name_arg, ulonglong *value_ptr_arg)
+  sys_var_ulonglong_ptr(sys_var_chain *chain, const char *name_arg, ulonglong *value_ptr_arg)
-    :sys_var(name_arg),value(value_ptr_arg) {}
+    :sys_var(name_arg),value(value_ptr_arg)
-  sys_var_ulonglong_ptr(const char *name_arg, ulonglong *value_ptr_arg,
+  { chain_sys_var(chain); }
+  sys_var_ulonglong_ptr(sys_var_chain *chain, const char *name_arg, ulonglong *value_ptr_arg,
 		       sys_after_update_func func)
-    :sys_var(name_arg,func), value(value_ptr_arg) {}
+    :sys_var(name_arg,func), value(value_ptr_arg)
+  { chain_sys_var(chain); }
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
   SHOW_TYPE show_type() { return SHOW_LONGLONG; }
@@ -153,9 +163,9 @@ 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_bool_ptr(sys_var_chain *chain, const char *name_arg, my_bool *value_arg)
     :sys_var(name_arg),value(value_arg)
-  {}
+  { chain_sys_var(chain); }
   bool check(THD *thd, set_var *var)
   {
     return check_enum(thd, var, &bool_typelib);
@@ -177,14 +187,14 @@ public:
   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_var_str(sys_var_chain *chain, const char *name_arg,
 	      sys_check_func check_func_arg,
 	      sys_update_func update_func_arg,
 	      sys_set_default_func set_default_func_arg,
               char *value_arg)
     :sys_var(name_arg), value(value_arg), check_func(check_func_arg),
     update_func(update_func_arg),set_default_func(set_default_func_arg)
-  {}
+  { chain_sys_var(chain); }
   bool check(THD *thd, set_var *var);
   bool update(THD *thd, set_var *var)
   {
@@ -209,9 +219,9 @@ 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_const_str(sys_var_chain *chain, const char *name_arg, const char *value_arg)
     :sys_var(name_arg),value((char*) value_arg)
-  {}
+  { chain_sys_var(chain); }
   bool check(THD *thd, set_var *var)
   {
     return 1;
@@ -238,9 +248,9 @@ class sys_var_const_str_ptr :public sys_var
 {
 public:
   char **value;					// Pointer to const value
-  sys_var_const_str_ptr(const char *name_arg, char **value_arg)
+  sys_var_const_str_ptr(sys_var_chain *chain, const char *name_arg, char **value_arg)
     :sys_var(name_arg),value(value_arg)
-  {}
+  { chain_sys_var(chain); }
   bool check(THD *thd, set_var *var)
   {
     return 1;
@@ -268,10 +278,10 @@ class sys_var_enum :public sys_var
   uint *value;
   TYPELIB *enum_names;
 public:
-  sys_var_enum(const char *name_arg, uint *value_arg,
+  sys_var_enum(sys_var_chain *chain, 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)
-  {}
+  { chain_sys_var(chain); }
   bool check(THD *thd, set_var *var)
   {
     return check_enum(thd, var, enum_names);
@@ -286,7 +296,8 @@ public:
 class sys_var_thd :public sys_var
 {
 public:
-  sys_var_thd(const char *name_arg, sys_after_update_func func= NULL)
+  sys_var_thd(const char *name_arg, 
+              sys_after_update_func func= NULL)
     :sys_var(name_arg,func)
   {}
   bool check_type(enum_var_type type) { return 0; }
@@ -302,13 +313,13 @@ class sys_var_thd_ulong :public sys_var_thd
   sys_check_func check_func;
 public:
   ulong SV::*offset;
-  sys_var_thd_ulong(const char *name_arg, ulong SV::*offset_arg)
+  sys_var_thd_ulong(sys_var_chain *chain, const char *name_arg, ulong SV::*offset_arg)
     :sys_var_thd(name_arg), check_func(0), offset(offset_arg)
-  {}
+  { chain_sys_var(chain); }
-  sys_var_thd_ulong(const char *name_arg, ulong SV::*offset_arg,
+  sys_var_thd_ulong(sys_var_chain *chain, const char *name_arg, ulong SV::*offset_arg,
 		   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)
-  {}
+  { chain_sys_var(chain); }
   bool check(THD *thd, set_var *var);
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
@@ -321,13 +332,15 @@ 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_ha_rows(sys_var_chain *chain, const char *name_arg, 
+                      ha_rows SV::*offset_arg)
     :sys_var_thd(name_arg), offset(offset_arg)
-  {}
+  { chain_sys_var(chain); }
-  sys_var_thd_ha_rows(const char *name_arg, ha_rows SV::*offset_arg,
+  sys_var_thd_ha_rows(sys_var_chain *chain, const char *name_arg, 
+                      ha_rows SV::*offset_arg,
 		      sys_after_update_func func)
     :sys_var_thd(name_arg,func), offset(offset_arg)
-  {}
+  { chain_sys_var(chain); }
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
   SHOW_TYPE show_type() { return SHOW_HA_ROWS; }
@@ -340,14 +353,16 @@ class sys_var_thd_ulonglong :public sys_var_thd
 public:
   ulonglong SV::*offset;
   bool only_global;
-  sys_var_thd_ulonglong(const char *name_arg, ulonglong SV::*offset_arg)
+  sys_var_thd_ulonglong(sys_var_chain *chain, const char *name_arg, 
+                        ulonglong SV::*offset_arg)
     :sys_var_thd(name_arg), offset(offset_arg)
-  {}
+  { chain_sys_var(chain); }
-  sys_var_thd_ulonglong(const char *name_arg, ulonglong SV::*offset_arg,
+  sys_var_thd_ulonglong(sys_var_chain *chain, const char *name_arg, 
+                        ulonglong SV::*offset_arg,
 			sys_after_update_func func, bool only_global_arg)
     :sys_var_thd(name_arg, func), offset(offset_arg),
     only_global(only_global_arg)
-  {}
+  { chain_sys_var(chain); }
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
   SHOW_TYPE show_type() { return SHOW_LONGLONG; }
@@ -367,13 +382,13 @@ 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_bool(sys_var_chain *chain, const char *name_arg, my_bool SV::*offset_arg)
     :sys_var_thd(name_arg), offset(offset_arg)
-  {}
+  { chain_sys_var(chain); }
-  sys_var_thd_bool(const char *name_arg, my_bool SV::*offset_arg,
+  sys_var_thd_bool(sys_var_chain *chain, const char *name_arg, my_bool SV::*offset_arg,
 		   sys_after_update_func func)
     :sys_var_thd(name_arg,func), offset(offset_arg)
-  {}
+  { chain_sys_var(chain); }
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
   SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
@@ -393,23 +408,23 @@ protected:
   TYPELIB *enum_names;
   sys_check_func check_func;
 public:
-  sys_var_thd_enum(const char *name_arg, ulong SV::*offset_arg,
+  sys_var_thd_enum(sys_var_chain *chain, const char *name_arg, ulong SV::*offset_arg,
 		   TYPELIB *typelib)
     :sys_var_thd(name_arg), offset(offset_arg), enum_names(typelib),
     check_func(0)
-  {}
+  { chain_sys_var(chain); }
-  sys_var_thd_enum(const char *name_arg, ulong SV::*offset_arg,
+  sys_var_thd_enum(sys_var_chain *chain, 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),
     check_func(0)
-  {}
+  { chain_sys_var(chain); }
-  sys_var_thd_enum(const char *name_arg, ulong SV::*offset_arg,
+  sys_var_thd_enum(sys_var_chain *chain, const char *name_arg, ulong SV::*offset_arg,
 		   TYPELIB *typelib, sys_after_update_func func,
                    sys_check_func check)
     :sys_var_thd(name_arg,func), offset(offset_arg), enum_names(typelib),
     check_func(check)
-  {}
+  { chain_sys_var(chain); }
   bool check(THD *thd, set_var *var)
   {
     int ret= 0;
@@ -430,8 +445,9 @@ extern void fix_sql_mode_var(THD *thd, enum_var_type type);
 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)
+  sys_var_thd_sql_mode(sys_var_chain *chain, const char *name_arg, 
-    :sys_var_thd_enum(name_arg, offset_arg, &sql_mode_typelib,
+                       ulong SV::*offset_arg)
+    :sys_var_thd_enum(chain, name_arg, offset_arg, &sql_mode_typelib,
 		      fix_sql_mode_var)
   {}
   bool check(THD *thd, set_var *var)
@@ -448,11 +464,12 @@ public:
 class sys_var_thd_storage_engine :public sys_var_thd
 {
 protected:
-  handlerton *SV::*offset;
+  plugin_ref SV::*offset;
 public:
-  sys_var_thd_storage_engine(const char *name_arg, handlerton *SV::*offset_arg)
+  sys_var_thd_storage_engine(sys_var_chain *chain, const char *name_arg, 
+                             plugin_ref SV::*offset_arg)
     :sys_var_thd(name_arg), offset(offset_arg)
-  {}
+  { chain_sys_var(chain); }
   bool check(THD *thd, set_var *var);
   SHOW_TYPE show_type() { return SHOW_CHAR; }
   bool check_update_type(Item_result type)
@@ -467,8 +484,9 @@ public:
 class sys_var_thd_table_type :public sys_var_thd_storage_engine
 {
 public:
-  sys_var_thd_table_type(const char *name_arg, handlerton *SV::*offset_arg)
+  sys_var_thd_table_type(sys_var_chain *chain, const char *name_arg, 
-    :sys_var_thd_storage_engine(name_arg, offset_arg)
+                         plugin_ref SV::*offset_arg)
+    :sys_var_thd_storage_engine(chain, name_arg, offset_arg)
   {}
   void warn_deprecated(THD *thd);
   void set_default(THD *thd, enum_var_type type);
@@ -482,12 +500,12 @@ class sys_var_thd_bit :public sys_var_thd
 public:
   ulonglong bit_flag;
   bool reverse;
-  sys_var_thd_bit(const char *name_arg,
+  sys_var_thd_bit(sys_var_chain *chain, const char *name_arg,
                   sys_check_func c_func, sys_update_func u_func,
                   ulonglong bit, bool reverse_arg=0)
     :sys_var_thd(name_arg), check_func(c_func), update_func(u_func),
     bit_flag(bit), reverse(reverse_arg)
-  {}
+  { chain_sys_var(chain); }
   bool check(THD *thd, set_var *var);
   bool update(THD *thd, set_var *var);
   bool check_update_type(Item_result type) { return 0; }
@@ -499,7 +517,9 @@ public:
 class sys_var_thd_dbug :public sys_var_thd
 {
 public:
-  sys_var_thd_dbug(const char *name_arg) :sys_var_thd(name_arg) {}
+  sys_var_thd_dbug(sys_var_chain *chain, const char *name_arg)
+    :sys_var_thd(name_arg)
+  { chain_sys_var(chain); }
   bool check_update_type(Item_result type) { return type != STRING_RESULT; }
   bool check(THD *thd, set_var *var);
   SHOW_TYPE show_type() { return SHOW_CHAR; }
@@ -515,7 +535,9 @@ public:
 class sys_var_timestamp :public sys_var
 {
 public:
-  sys_var_timestamp(const char *name_arg) :sys_var(name_arg) {}
+  sys_var_timestamp(sys_var_chain *chain, const char *name_arg)
+    :sys_var(name_arg)
+  { chain_sys_var(chain); }
   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; }
@@ -528,7 +550,9 @@ public:
 class sys_var_last_insert_id :public sys_var
 {
 public:
-  sys_var_last_insert_id(const char *name_arg) :sys_var(name_arg) {}
+  sys_var_last_insert_id(sys_var_chain *chain, const char *name_arg)
+    :sys_var(name_arg)
+  { chain_sys_var(chain); }
   bool update(THD *thd, set_var *var);
   bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
   SHOW_TYPE show_type() { return SHOW_LONGLONG; }
@@ -539,7 +563,9 @@ public:
 class sys_var_insert_id :public sys_var
 {
 public:
-  sys_var_insert_id(const char *name_arg) :sys_var(name_arg) {}
+  sys_var_insert_id(sys_var_chain *chain, const char *name_arg)
+    :sys_var(name_arg)
+  { chain_sys_var(chain); }
   bool update(THD *thd, set_var *var);
   bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
   SHOW_TYPE show_type() { return SHOW_LONGLONG; }
@@ -547,33 +573,12 @@ public:
 };
 
 
-#ifdef HAVE_REPLICATION
-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
-    show_type() or value_ptr()
-  */
-};
-
-class sys_var_sync_binlog_period :public sys_var_long_ptr
-{
-public:
-  sys_var_sync_binlog_period(const char *name_arg, ulong *value_ptr_arg)
-    :sys_var_long_ptr(name_arg,value_ptr_arg) {}
-  bool update(THD *thd, set_var *var);
-};
-#endif
-
 class sys_var_rand_seed1 :public sys_var
 {
 public:
-  sys_var_rand_seed1(const char *name_arg) :sys_var(name_arg) {}
+  sys_var_rand_seed1(sys_var_chain *chain, const char *name_arg)
+    :sys_var(name_arg)
+  { chain_sys_var(chain); }
   bool update(THD *thd, set_var *var);
   bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
 };
@@ -581,7 +586,9 @@ public:
 class sys_var_rand_seed2 :public sys_var
 {
 public:
-  sys_var_rand_seed2(const char *name_arg) :sys_var(name_arg) {}
+  sys_var_rand_seed2(sys_var_chain *chain, const char *name_arg)
+    :sys_var(name_arg)
+  { chain_sys_var(chain); }
   bool update(THD *thd, set_var *var);
   bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
 };
@@ -590,7 +597,8 @@ public:
 class sys_var_collation :public sys_var_thd
 {
 public:
-  sys_var_collation(const char *name_arg) :sys_var_thd(name_arg)
+  sys_var_collation(const char *name_arg)
+    :sys_var_thd(name_arg)
     {
     no_support_one_shot= 0;
     }
@@ -608,10 +616,9 @@ class sys_var_character_set :public sys_var_thd
 {
 public:
   bool nullable;
-  sys_var_character_set(const char *name_arg) :
+  sys_var_character_set(const char *name_arg, bool is_nullable= 0) :
-    sys_var_thd(name_arg)
+    sys_var_thd(name_arg), nullable(is_nullable)
   {
-    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.
@@ -631,83 +638,47 @@ public:
   virtual CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type)= 0;
 };
 
-class sys_var_character_set_filesystem :public sys_var_character_set
+
+class sys_var_character_set_sv :public sys_var_character_set
 {
+  CHARSET_INFO **global_default;
+  CHARSET_INFO *SV::*offset;
 public:
-  sys_var_character_set_filesystem(const char *name_arg) :
+  sys_var_character_set_sv(sys_var_chain *chain, const char *name_arg,
-    sys_var_character_set(name_arg) {}
+                            CHARSET_INFO *SV::*offset_arg,
+                            CHARSET_INFO **global_default_arg, 
+                            bool is_nullable= 0)
+    : sys_var_character_set(name_arg, is_nullable),
+      offset(offset_arg), global_default(global_default_arg)
+  { chain_sys_var(chain); }
   void set_default(THD *thd, enum_var_type type);
   CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
 };
 
-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) {}
-  void set_default(THD *thd, enum_var_type type);
-  CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
-};
-
-class sys_var_character_set_results :public sys_var_character_set
-{
-public:
-  sys_var_character_set_results(const char *name_arg) :
-    sys_var_character_set(name_arg) 
-    { nullable= 1; }
-  void set_default(THD *thd, enum_var_type type);
-  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_database(sys_var_chain *chain, const char *name_arg) :
-    sys_var_character_set(name_arg) {}
+    sys_var_character_set(name_arg)
+  { chain_sys_var(chain); }
   void set_default(THD *thd, enum_var_type type);
   CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
 };
 
-class sys_var_character_set_connection :public sys_var_character_set
+class sys_var_collation_sv :public sys_var_collation
 {
+  CHARSET_INFO **global_default;
+  CHARSET_INFO *SV::*offset;
 public:
-  sys_var_character_set_connection(const char *name_arg) :
+  sys_var_collation_sv(sys_var_chain *chain, const char *name_arg,
-    sys_var_character_set(name_arg) {}
+                               CHARSET_INFO *SV::*offset_arg,
-  void set_default(THD *thd, enum_var_type type);
+                               CHARSET_INFO **global_default_arg)
-  CHARSET_INFO **ci_ptr(THD *thd, enum_var_type type);
+    :sys_var_collation(name_arg),
-};
+     offset(offset_arg), global_default(global_default_arg)
-
+  {
-class sys_var_collation_connection :public sys_var_collation
+    chain_sys_var(chain);
-{
+  }
-public:
-  sys_var_collation_connection(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_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);
@@ -719,9 +690,10 @@ class sys_var_key_cache_param :public sys_var
 protected:
   size_t offset;
 public:
-  sys_var_key_cache_param(const char *name_arg, size_t offset_arg)
+  sys_var_key_cache_param(sys_var_chain *chain, const char *name_arg, 
+                          size_t offset_arg)
     :sys_var(name_arg), offset(offset_arg)
-  {}
+  { chain_sys_var(chain); }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
   bool check_default(enum_var_type type) { return 1; }
   bool is_struct() { return 1; }
@@ -731,8 +703,9 @@ public:
 class sys_var_key_buffer_size :public sys_var_key_cache_param
 {
 public:
-  sys_var_key_buffer_size(const char *name_arg)
+  sys_var_key_buffer_size(sys_var_chain *chain, const char *name_arg)
-    :sys_var_key_cache_param(name_arg, offsetof(KEY_CACHE, param_buff_size))
+    :sys_var_key_cache_param(chain, name_arg,
+                             offsetof(KEY_CACHE, param_buff_size))
   {}
   bool update(THD *thd, set_var *var);
   SHOW_TYPE show_type() { return SHOW_LONGLONG; }
@@ -742,8 +715,8 @@ public:
 class sys_var_key_cache_long :public sys_var_key_cache_param
 {
 public:
-  sys_var_key_cache_long(const char *name_arg, size_t offset_arg)
+  sys_var_key_cache_long(sys_var_chain *chain, const char *name_arg, size_t offset_arg)
-    :sys_var_key_cache_param(name_arg, offset_arg)
+    :sys_var_key_cache_param(chain, name_arg, offset_arg)
   {}
   bool update(THD *thd, set_var *var);
   SHOW_TYPE show_type() { return SHOW_LONG; }
@@ -755,12 +728,12 @@ class sys_var_thd_date_time_format :public sys_var_thd
   DATE_TIME_FORMAT *SV::*offset;
   timestamp_type date_time_type;
 public:
-  sys_var_thd_date_time_format(const char *name_arg,
+  sys_var_thd_date_time_format(sys_var_chain *chain, 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)
-  {}
+  { chain_sys_var(chain); }
   SHOW_TYPE show_type() { return SHOW_CHAR; }
   bool check_update_type(Item_result type)
   {
@@ -779,8 +752,9 @@ class sys_var_log_state :public sys_var_bool_ptr
 {
   uint log_type;
 public:
-  sys_var_log_state(const char *name_arg, my_bool *value_arg, uint log_type_arg)
+  sys_var_log_state(sys_var_chain *chain, const char *name_arg, my_bool *value_arg, 
-    :sys_var_bool_ptr(name_arg, value_arg), log_type(log_type_arg) {}
+                    uint log_type_arg)
+    :sys_var_bool_ptr(chain, name_arg, value_arg), log_type(log_type_arg) {}
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
 };
@@ -791,10 +765,10 @@ class sys_var_log_output :public sys_var
   ulong *value;
   TYPELIB *enum_names;
 public:
-  sys_var_log_output(const char *name_arg, ulong *value_arg,
+  sys_var_log_output(sys_var_chain *chain, const char *name_arg, ulong *value_arg,
                      TYPELIB *typelib, sys_after_update_func func)
     :sys_var(name_arg,func), value(value_arg), enum_names(typelib)
-  {}
+  { chain_sys_var(chain); }
   bool check(THD *thd, set_var *var)
   {
     return check_set(thd, var, enum_names);
@@ -815,12 +789,12 @@ public:
   enum_var_type var_type;
   SHOW_TYPE show_type_value;
   sys_value_ptr_func value_ptr_func;
-  sys_var_readonly(const char *name_arg, enum_var_type type,
+  sys_var_readonly(sys_var_chain *chain, 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_value(show_type_arg), value_ptr_func(value_ptr_func_arg)
-  {}
+  { chain_sys_var(chain); }
   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; }
@@ -834,19 +808,17 @@ public:
 };
 
 
-class sys_var_have_variable: public sys_var
+class sys_var_have_option: public sys_var
 {
-  SHOW_COMP_OPTION *have_variable;
+protected:
-
+  virtual SHOW_COMP_OPTION get_option() = 0;
 public:
-  sys_var_have_variable(const char *variable_name,
+  sys_var_have_option(sys_var_chain *chain, const char *variable_name):
-                        SHOW_COMP_OPTION *have_variable_arg):
+    sys_var(variable_name)
-    sys_var(variable_name),
+  { chain_sys_var(chain); }
-    have_variable(have_variable_arg)
-  { }
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
   {
-    return (byte*) show_comp_option_name[*have_variable];
+    return (byte*) show_comp_option_name[get_option()];
   }
   bool update(THD *thd, set_var *var) { return 1; }
   bool check_default(enum_var_type type) { return 1; }
@@ -857,13 +829,47 @@ public:
 };
 
 
+class sys_var_have_variable: public sys_var_have_option
+{
+  SHOW_COMP_OPTION *have_variable;
+
+public:
+  sys_var_have_variable(sys_var_chain *chain, const char *variable_name,
+                        SHOW_COMP_OPTION *have_variable_arg):
+    sys_var_have_option(chain, variable_name),
+    have_variable(have_variable_arg)
+  { }
+  SHOW_COMP_OPTION get_option() { return *have_variable; }
+};
+
+
+class sys_var_have_plugin: public sys_var_have_option
+{
+  const char *plugin_name_str;
+  const uint plugin_name_len;
+  const int plugin_type;
+
+public:
+  sys_var_have_plugin(sys_var_chain *chain, const char *variable_name,
+                      const char *plugin_name_str_arg, uint plugin_name_len_arg, 
+                      int plugin_type_arg):
+    sys_var_have_option(chain, variable_name), 
+    plugin_name_str(plugin_name_str_arg), plugin_name_len(plugin_name_len_arg),
+    plugin_type(plugin_type_arg)
+  { }
+  /* the following method is declared in sql_plugin.cc */
+  SHOW_COMP_OPTION get_option();
+};
+
+
 class sys_var_thd_time_zone :public sys_var_thd
 {
 public:
-  sys_var_thd_time_zone(const char *name_arg):
+  sys_var_thd_time_zone(sys_var_chain *chain, const char *name_arg):
     sys_var_thd(name_arg) 
   {
     no_support_one_shot= 0;
+    chain_sys_var(chain);
   }
   bool check(THD *thd, set_var *var);
   SHOW_TYPE show_type() { return SHOW_CHAR; }
@@ -881,8 +887,9 @@ public:
 class sys_var_max_user_conn : public sys_var_thd
 {
 public:
-  sys_var_max_user_conn(const char *name_arg):
+  sys_var_max_user_conn(sys_var_chain *chain, const char *name_arg):
-    sys_var_thd(name_arg) {}
+    sys_var_thd(name_arg)
+  { chain_sys_var(chain); }
   bool check(THD *thd, set_var *var);
   bool update(THD *thd, set_var *var);
   bool check_default(enum_var_type type)
@@ -898,8 +905,9 @@ class sys_var_trust_routine_creators :public sys_var_bool_ptr
 {
   /* We need a derived class only to have a warn_deprecated() */
 public:
-  sys_var_trust_routine_creators(const char *name_arg, my_bool *value_arg) :
+  sys_var_trust_routine_creators(sys_var_chain *chain, const char *name_arg, 
-    sys_var_bool_ptr(name_arg, value_arg) {};
+                                 my_bool *value_arg) :
+    sys_var_bool_ptr(chain, name_arg, value_arg) {};
   void warn_deprecated(THD *thd);
   void set_default(THD *thd, enum_var_type type);
   bool update(THD *thd, set_var *var);
@@ -913,8 +921,9 @@ public:
 class sys_var_opt_readonly :public sys_var_bool_ptr
 {
 public:
-  sys_var_opt_readonly(const char *name_arg, my_bool *value_arg) :
+  sys_var_opt_readonly(sys_var_chain *chain, const char *name_arg, 
-    sys_var_bool_ptr(name_arg, value_arg) {};
+                       my_bool *value_arg) :
+    sys_var_bool_ptr(chain, name_arg, value_arg) {};
   ~sys_var_opt_readonly() {};
   bool update(THD *thd, set_var *var);
 };
@@ -923,12 +932,13 @@ public:
 class sys_var_thd_lc_time_names :public sys_var_thd
 {
 public:
-  sys_var_thd_lc_time_names(const char *name_arg):
+  sys_var_thd_lc_time_names(sys_var_chain *chain, const char *name_arg):
-    sys_var_thd(name_arg) 
+    sys_var_thd(name_arg)
   {
 #if MYSQL_VERSION_ID < 50000
     no_support_one_shot= 0;
 #endif
+    chain_sys_var(chain);
   }
   bool check(THD *thd, set_var *var);
   SHOW_TYPE show_type() { return SHOW_CHAR; }
@@ -947,8 +957,8 @@ class sys_var_event_scheduler :public sys_var_long_ptr
 {
   /* We need a derived class only to have a warn_deprecated() */
 public:
-  sys_var_event_scheduler(const char *name_arg) :
+  sys_var_event_scheduler(sys_var_chain *chain, const char *name_arg) :
-    sys_var_long_ptr(name_arg, NULL, NULL) {};
+    sys_var_long_ptr(chain, name_arg, NULL, NULL) {};
   bool update(THD *thd, set_var *var);
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
   SHOW_TYPE show_type() { return SHOW_CHAR; }
@@ -964,8 +974,9 @@ extern void fix_binlog_format_after_update(THD *thd, enum_var_type type);
 class sys_var_thd_binlog_format :public sys_var_thd_enum
 {
 public:
-  sys_var_thd_binlog_format(const char *name_arg, ulong SV::*offset_arg)
+  sys_var_thd_binlog_format(sys_var_chain *chain, const char *name_arg, 
-    :sys_var_thd_enum(name_arg, offset_arg,
+                            ulong SV::*offset_arg)
+    :sys_var_thd_enum(chain, name_arg, offset_arg,
                       &binlog_format_typelib
                       , fix_binlog_format_after_update
                       )
@@ -1003,7 +1014,7 @@ public:
     CHARSET_INFO *charset;
     ulong ulong_value;
     ulonglong ulonglong_value;
-    handlerton *hton;
+    plugin_ref plugin;
     DATE_TIME_FORMAT *date_time_format;
     Time_zone *time_zone;
     MY_LOCALE *locale_value;
@@ -1132,9 +1143,13 @@ struct sys_var_with_base
   Prototypes for helper functions
 */
 
-void set_var_init();
+int set_var_init();
 void set_var_free();
-sys_var *find_sys_var(const char *str, uint length=0);
+int mysql_append_static_vars(const SHOW_VAR *show_vars, uint count);
+SHOW_VAR* enumerate_sys_vars(THD *thd, bool sorted);
+int mysql_add_sys_var_chain(sys_var *chain, struct my_option *long_options);
+int mysql_del_sys_var_chain(sys_var *chain);
+sys_var *find_sys_var(THD *thd, const char *str, uint length=0);
 int sql_set_variables(THD *thd, List<set_var_base> *var_list);
 bool not_all_support_one_shot(List<set_var_base> *var_list);
 void fix_delay_key_write(THD *thd, enum_var_type type);

sql/sql_base.cc

@@ -1596,7 +1596,7 @@ void close_temporary_table(THD *thd, TABLE *table,
 
 void close_temporary(TABLE *table, bool free_share, bool delete_table)
 {
-  handlerton *table_type= table->s->db_type;
+  handlerton *table_type= table->s->db_type();
   DBUG_ENTER("close_temporary");
 
   free_io_cache(table);
@@ -6186,7 +6186,7 @@ my_bool mysql_rm_tmp_tables(void)
           init_tmp_table_share(&share, "", 0, "", filePathCopy);
           if (!open_table_def(thd, &share, 0) &&
               ((handler_file= get_new_handler(&share, thd->mem_root,
-                                              share.db_type))))
+                                              share.db_type()))))
           {
             handler_file->delete_table(filePathCopy);
             delete handler_file;

sql/sql_cache.cc

@@ -2384,7 +2384,12 @@ Query_cache::register_tables_from_list(TABLE_LIST *tables_used,
                         tables_used->engine_data))
         DBUG_RETURN(0);
 
-      if (tables_used->table->s->db_type->db_type == DB_TYPE_MRG_MYISAM)
+#ifdef WITH_MYISAMMRG_STORAGE_ENGINE      
+      /*
+        XXX FIXME: Some generic mechanism is required here instead of this
+        MYISAMMRG-specific implementation.
+      */
+      if (tables_used->table->s->db_type()->db_type == DB_TYPE_MRG_MYISAM)
       {
         ha_myisammrg *handler = (ha_myisammrg *) tables_used->table->file;
         MYRG_INFO *file = handler->myrg_info();
@@ -2407,6 +2412,7 @@ Query_cache::register_tables_from_list(TABLE_LIST *tables_used,
             DBUG_RETURN(0);
         }
       }
+#endif
     }
   }
   DBUG_RETURN(n - counter);
@@ -2983,7 +2989,7 @@ static TABLE_COUNTER_TYPE process_and_count_tables(TABLE_LIST *tables_used,
       DBUG_PRINT("qcache", ("table: %s  db:  %s  type: %u",
                             tables_used->table->s->table_name.str,
                             tables_used->table->s->db.str,
-                            tables_used->table->s->db_type->db_type));
+                            tables_used->table->s->db_type()->db_type));
       if (tables_used->derived)
       {
         table_count--;
@@ -3008,12 +3014,18 @@ static TABLE_COUNTER_TYPE process_and_count_tables(TABLE_LIST *tables_used,
                     "other non-cacheable table(s)"));
         DBUG_RETURN(0);
       }
-      if (tables_used->table->s->db_type->db_type == DB_TYPE_MRG_MYISAM)
+#ifdef WITH_MYISAMMRG_STORAGE_ENGINE      
+      /*
+        XXX FIXME: Some generic mechanism is required here instead of this
+        MYISAMMRG-specific implementation.
+      */
+      if (tables_used->table->s->db_type()->db_type == DB_TYPE_MRG_MYISAM)
       {
         ha_myisammrg *handler = (ha_myisammrg *)tables_used->table->file;
         MYRG_INFO *file = handler->myrg_info();
         table_count+= (file->end_table - file->open_tables);
       }
+#endif
     }
   }
   DBUG_RETURN(table_count);

sql/sql_class.cc

@@ -167,15 +167,15 @@ Open_tables_state::Open_tables_state(ulong version_arg)
   reset_open_tables_state();
 }
 
-my_bool thd_in_lock_tables(const THD *thd)
+int thd_in_lock_tables(const THD *thd)
 {
-  return thd->in_lock_tables;
+  return test(thd->in_lock_tables);
 }
 
 
-my_bool thd_tablespace_op(const THD *thd)
+int thd_tablespace_op(const THD *thd)
 {
-  return thd->tablespace_op;
+  return test(thd->tablespace_op);
 }
 
 
@@ -191,6 +191,82 @@ void **thd_ha_data(const THD *thd, const struct handlerton *hton)
   return (void **) thd->ha_data + hton->slot;
 }
 
+long long thd_test_options(const THD *thd, long long test_options)
+{
+  return thd->options & test_options;
+}
+
+int thd_sql_command(const THD *thd)
+{
+  return (int) thd->lex->sql_command;
+}
+
+
+/*
+  Dumps a text description of a thread, its security context
+  (user, host) and the current query.
+  
+  SYNOPSIS
+    thd_security_context()
+    thd                 current thread context
+    buffer              pointer to preferred result buffer
+    length              length of buffer
+    max_query_len       how many chars of query to copy (0 for all)
+  
+  RETURN VALUES
+    pointer to string
+*/
+char *thd_security_context(THD *thd, char *buffer, int length,
+                           int max_query_len)
+{
+  String str(buffer, length, &my_charset_latin1);
+  const Security_context *sctx= &thd->main_security_ctx;
+  char header[64];
+  int len;
+  
+  len= my_snprintf(header, sizeof(header), 
+                   "MySQL thread id %lu, query id %lu",
+                   thd->thread_id, (ulong) thd->query_id);
+  str.length(0);
+  str.append(header, len);
+  
+  if (sctx->host)
+  {
+    str.append(' ');
+    str.append(sctx->host);
+  }
+
+  if (sctx->ip)
+  {
+    str.append(' ');
+    str.append(sctx->ip);
+  }
+
+  if (sctx->user)
+  {
+    str.append(' ');
+    str.append(sctx->user);
+  }
+
+  if (thd->proc_info)
+  {
+    str.append(' ');
+    str.append(thd->proc_info);
+  }
+
+  if (thd->query)
+  {
+    if (max_query_len < 1)
+      len= thd->query_length;
+    else
+      len= min(thd->query_length, max_query_len);
+    str.append('\n');
+    str.append(thd->query, len);
+  }
+  if (str.c_ptr_safe() == buffer)
+    return buffer;
+  return thd->strmake(str.ptr(), str.length());
+}
 
 /*
   Pass nominal parameters to Statement constructor only to ensure that
@@ -320,6 +396,7 @@ void THD::init(void)
 {
   pthread_mutex_lock(&LOCK_global_system_variables);
   variables= global_system_variables;
+  plugin_thdvar_init(this, false);
   variables.time_format= date_time_format_copy((THD*) 0,
 					       variables.time_format);
   variables.date_format= date_time_format_copy((THD*) 0,
@@ -465,6 +542,7 @@ THD::~THD()
     cleanup();
 
   ha_close_connection(this);
+  plugin_thdvar_cleanup(this);
 
   DBUG_PRINT("info", ("freeing security context"));
   main_security_ctx.destroy();
@@ -1682,7 +1760,7 @@ Statement::Statement(enum enum_state state_arg, ulong id_arg,
   :Query_arena(&main_mem_root, state_arg),
   id(id_arg),
   mark_used_columns(MARK_COLUMNS_READ),
-  lex(&main_lex),
+  main_lex(), lex(&main_lex),
   query(0),
   query_length(0),
   cursor(0)

sql/sql_class.h

@@ -180,6 +180,20 @@ class Time_zone;
 
 struct system_variables
 {
+  /*
+    How dynamically allocated system variables are handled:
+    
+    The global_system_variables and max_system_variables are "authoritative"
+    They both should have the same 'version' and 'size'.
+    When attempting to access a dynamic variable, if the session version
+    is out of date, then the session version is updated and realloced if
+    neccessary and bytes copied from global to make up for missing data.
+  */ 
+  ulong dynamic_variables_version;
+  char* dynamic_variables_ptr;
+  uint dynamic_variables_head;  /* largest valid variable offset */
+  uint dynamic_variables_size;  /* how many bytes are in use */
+  
   ulonglong myisam_max_extra_sort_file_size;
   ulonglong myisam_max_sort_file_size;
   ulonglong max_heap_table_size;
@@ -245,8 +259,6 @@ struct system_variables
   my_bool new_mode;
   my_bool query_cache_wlock_invalidate;
   my_bool engine_condition_pushdown;
-  my_bool innodb_table_locks;
-  my_bool innodb_support_xa;
   my_bool ndb_force_send;
   my_bool ndb_use_copying_alter_table;
   my_bool ndb_use_exact_count;
@@ -256,7 +268,7 @@ struct system_variables
   my_bool old_alter_table;
   my_bool old_passwords;
 
-  handlerton *table_type;
+  plugin_ref table_plugin;
 
   /* Only charset part of these variables is sensible */
   CHARSET_INFO  *character_set_filesystem;

sql/sql_connect.cc

@@ -966,6 +966,7 @@ bool login_connection(THD *thd)
 void end_connection(THD *thd)
 {
   NET *net= &thd->net;
+  plugin_thdvar_cleanup(thd);
   if (thd->user_connect)
     decrease_user_connections(thd->user_connect);
   if (net->error && net->vio != 0 && net->report_error)
@@ -1003,6 +1004,8 @@ void prepare_new_connection_state(THD* thd)
   if (thd->client_capabilities & CLIENT_COMPRESS)
     thd->net.compress=1;				// Use compression
 
+  plugin_thdvar_init(thd, true);
+
   thd->version= refresh_version;
   thd->proc_info= 0;
   thd->command= COM_SLEEP;

sql/sql_delete.cc

@@ -868,7 +868,7 @@ bool mysql_truncate(THD *thd, TABLE_LIST *table_list, bool dont_send_ok)
   /* If it is a temporary table, close and regenerate it */
   if (!dont_send_ok && (table= find_temporary_table(thd, table_list)))
   {
-    handlerton *table_type= table->s->db_type;
+    handlerton *table_type= table->s->db_type();
     TABLE_SHARE *share= table->s;
     if (!ha_check_storage_engine_flag(table_type, HTON_CAN_RECREATE))
       goto trunc_by_del;

sql/sql_insert.cc

@@ -3232,7 +3232,7 @@ void select_create::abort()
   {
     table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
     table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
-    handlerton *table_type=table->s->db_type;
+    handlerton *table_type=table->s->db_type();
     if (!table->s->tmp_table)
     {
       ulong version= table->s->version;

sql/sql_lex.cc

@@ -172,6 +172,7 @@ void lex_start(THD *thd, const uchar *buf, uint length)
   lex->spcont= NULL;
   lex->proc_list.first= 0;
   lex->escape_used= FALSE;
+  lex->query_tables= 0;
   lex->reset_query_tables_list(FALSE);
   lex->expr_allows_subselect= TRUE;
 
@@ -211,6 +212,12 @@ void lex_end(LEX *lex)
     lex->yacc_yyss= 0;
     lex->yacc_yyvs= 0;
   }
+
+  /* release used plugins */
+  plugin_unlock_list(0, (plugin_ref*)lex->plugins.buffer, 
+                     lex->plugins.elements);
+  reset_dynamic(&lex->plugins);
+
   DBUG_VOID_RETURN;
 }
 
@@ -1673,6 +1680,17 @@ void st_select_lex::print_limit(THD *thd, String *str)
 
 void Query_tables_list::reset_query_tables_list(bool init)
 {
+  if (!init && query_tables)
+  {
+    TABLE_LIST *table= query_tables;
+    for (;;)
+    {
+      delete table->view;
+      if (query_tables_last == &table->next_global ||
+          !(table= table->next_global))
+        break;
+    }
+  }
   query_tables= 0;
   query_tables_last= &query_tables;
   query_tables_own_last= 0;
@@ -1727,6 +1745,10 @@ st_lex::st_lex()
   :result(0), yacc_yyss(0), yacc_yyvs(0),
    sql_command(SQLCOM_END)
 {
+  my_init_dynamic_array2(&plugins, sizeof(plugin_ref),
+                         plugins_static_buffer,
+                         INITIAL_LEX_PLUGIN_LIST_SIZE, 
+                         INITIAL_LEX_PLUGIN_LIST_SIZE);
   reset_query_tables_list(TRUE);
 }
 

sql/sql_lex.h

@@ -952,6 +952,11 @@ typedef struct st_lex : public Query_tables_list
   XID *xid;
   gptr yacc_yyss,yacc_yyvs;
   THD *thd;
+
+  /* maintain a list of used plugins for this LEX */
+  DYNAMIC_ARRAY plugins;
+  plugin_ref plugins_static_buffer[INITIAL_LEX_PLUGIN_LIST_SIZE];
+  
   CHARSET_INFO *charset, *underscore_charset;
   /* store original leaf_tables for INSERT SELECT and PS/SP */
   TABLE_LIST *leaf_tables_insert;
@@ -1155,6 +1160,8 @@ typedef struct st_lex : public Query_tables_list
   virtual ~st_lex()
   {
     destroy_query_tables_list();
+    plugin_unlock_list(NULL, (plugin_ref *)plugins.buffer, plugins.elements);
+    delete_dynamic(&plugins);
   }
 
   inline void uncacheable(uint8 cause)

sql/sql_partition.cc

@@ -784,9 +784,9 @@ static bool handle_list_of_fields(List_iterator<char> it,
     }
     else
     {
-      if (table->s->db_type->partition_flags &&
+      if (table->s->db_type()->partition_flags &&
-          (table->s->db_type->partition_flags() & HA_USE_AUTO_PARTITION) &&
+          (table->s->db_type()->partition_flags() & HA_USE_AUTO_PARTITION) &&
-          (table->s->db_type->partition_flags() & HA_CAN_PARTITION))
+          (table->s->db_type()->partition_flags() & HA_CAN_PARTITION))
       {
         /*
           This engine can handle automatic partitioning and there is no
@@ -1664,8 +1664,8 @@ bool fix_partition_func(THD *thd, TABLE *table,
     goto end;
   if (unlikely(check_primary_key(table)))
     goto end;
-  if (unlikely((!(table->s->db_type->partition_flags &&
+  if (unlikely((!(table->s->db_type()->partition_flags &&
-      (table->s->db_type->partition_flags() & HA_CAN_PARTITION_UNIQUE))) &&
+      (table->s->db_type()->partition_flags() & HA_CAN_PARTITION_UNIQUE))) &&
                check_unique_keys(table)))
     goto end;
   if (unlikely(set_up_partition_bitmap(thd, part_info)))
@@ -1872,7 +1872,7 @@ static int add_keyword_int(File fptr, const char *keyword, longlong num)
 
 static int add_engine(File fptr, handlerton *engine_type)
 {
-  const char *engine_str= hton2plugin[engine_type->slot]->name.str;
+  const char *engine_str= ha_resolve_storage_engine_name(engine_type);
   DBUG_PRINT("info", ("ENGINE: %s", engine_str));
   int err= add_string(fptr, "ENGINE = ");
   return err + add_string(fptr, engine_str);
@@ -2185,8 +2185,8 @@ bool partition_key_modified(TABLE *table, const MY_BITMAP *fields)
 
   if (!part_info)
     DBUG_RETURN(FALSE);
-  if (table->s->db_type->partition_flags &&
+  if (table->s->db_type()->partition_flags &&
-      (table->s->db_type->partition_flags() & HA_CAN_UPDATE_PARTITION_KEY))
+      (table->s->db_type()->partition_flags() & HA_CAN_UPDATE_PARTITION_KEY))
     DBUG_RETURN(FALSE);
   for (fld= part_info->full_part_field_array; *fld; fld++)
     if (bitmap_is_set(fields, (*fld)->field_index))
@@ -4201,8 +4201,8 @@ uint prep_alter_part_table(THD *thd, TABLE *table, ALTER_INFO *alter_info,
         alter_info->no_parts= curr_part_no - new_part_no;
       }
     }
-    if (table->s->db_type->alter_table_flags &&
+    if (table->s->db_type()->alter_table_flags &&
-        (!(flags= table->s->db_type->alter_table_flags(alter_info->flags))))
+        (!(flags= table->s->db_type()->alter_table_flags(alter_info->flags))))
     {
       my_error(ER_PARTITION_FUNCTION_FAILURE, MYF(0));
       DBUG_RETURN(1);
@@ -4948,7 +4948,7 @@ the generated partition syntax in a correct manner.
           create_info->db_type= table->part_info->default_engine_type;
         }
         DBUG_PRINT("info", ("New engine type: %s",
-                   hton2plugin[create_info->db_type->slot]->name.str));
+                   ha_resolve_storage_engine_name(create_info->db_type)));
         thd->work_part_info= NULL;
         *partition_changed= TRUE;
       }

sql/sql_plugin.h

@@ -16,6 +16,17 @@
 #ifndef _sql_plugin_h
 #define _sql_plugin_h
 
+class sys_var;
+
+/*
+  the following flags are valid for plugin_init()
+*/
+#define PLUGIN_INIT_SKIP_DYNAMIC_LOADING 1
+#define PLUGIN_INIT_SKIP_PLUGIN_TABLE    2
+#define PLUGIN_INIT_SKIP_INITIALIZATION  4
+
+#define INITIAL_LEX_PLUGIN_LIST_SIZE    16
+
 /*
   the following #define adds server-only members to enum_mysql_show_type,
   that is defined in plugin.h
@@ -41,6 +52,7 @@ typedef struct st_mysql_show_var SHOW_VAR;
 #define PLUGIN_IS_DELETED       2
 #define PLUGIN_IS_UNINITIALIZED 4
 #define PLUGIN_IS_READY         8
+#define PLUGIN_IS_DYING         16
 
 /* A handle for the dynamic library containing a plugin or plugins. */
 
@@ -63,25 +75,57 @@ struct st_plugin_int
   uint state;
   uint ref_count;               /* number of threads using the plugin */
   void *data;                   /* plugin type specific, e.g. handlerton */
+  MEM_ROOT mem_root;            /* memory for dynamic plugin structures */
+  sys_var *system_vars;         /* server variables for this plugin */
 };
 
+#ifdef DBUG_OFF
+typedef struct st_plugin_int *plugin_ref;
+#define plugin_decl(pi) ((pi)->plugin)
+#define plugin_dlib(pi) ((pi)->plugin_dl)
+#define plugin_data(pi,cast) ((cast)((pi)->data))
+#define plugin_name(pi) (&((pi)->name))
+#define plugin_state(pi) ((pi)->state)
+#else
+typedef struct st_plugin_int **plugin_ref;
+#define plugin_decl(pi) ((pi)[0]->plugin)
+#define plugin_dlib(pi) ((pi)[0]->plugin_dl)
+#define plugin_data(pi,cast) ((cast)((pi)[0]->data))
+#define plugin_name(pi) (&((pi)[0]->name))
+#define plugin_state(pi) ((pi)[0]->state)
+#endif
+
 typedef int (*plugin_type_init)(struct st_plugin_int *);
 
+extern char *opt_plugin_load;
 extern char *opt_plugin_dir_ptr;
 extern char opt_plugin_dir[FN_REFLEN];
 extern const LEX_STRING plugin_type_names[];
-extern int plugin_init(int);
+
+extern int plugin_init(int *argc, char **argv, int init_flags);
 extern void plugin_shutdown(void);
-extern my_bool plugin_is_ready(const LEX_STRING *name, int type);
+extern void my_print_help_inc_plugins(struct my_option *options, uint size);
-extern st_plugin_int *plugin_lock(const LEX_STRING *name, int type);
+extern bool plugin_is_ready(const LEX_STRING *name, int type);
-extern void plugin_unlock(struct st_plugin_int *plugin);
+#define my_plugin_lock_by_name(A,B,C) plugin_lock_by_name(A,B,C CALLER_INFO)
-extern my_bool mysql_install_plugin(THD *thd, const LEX_STRING *name, const LEX_STRING *dl);
+#define my_plugin_lock_by_name_ci(A,B,C) plugin_lock_by_name(A,B,C ORIG_CALLER_INFO)
-extern my_bool mysql_uninstall_plugin(THD *thd, const LEX_STRING *name);
+#define my_plugin_lock(A,B) plugin_lock(A,B CALLER_INFO)
+#define my_plugin_lock_ci(A,B) plugin_lock(A,B ORIG_CALLER_INFO)
+extern plugin_ref plugin_lock(THD *thd, plugin_ref *ptr CALLER_INFO_PROTO);
+extern plugin_ref plugin_lock_by_name(THD *thd, const LEX_STRING *name,
+                                      int type CALLER_INFO_PROTO);
+extern void plugin_unlock(THD *thd, plugin_ref plugin);
+extern void plugin_unlock_list(THD *thd, plugin_ref *list, uint count);
+extern bool mysql_install_plugin(THD *thd, const LEX_STRING *name,
+                                 const LEX_STRING *dl);
+extern bool mysql_uninstall_plugin(THD *thd, const LEX_STRING *name);
+extern bool plugin_register_builtin(struct st_mysql_plugin *plugin);
+extern void plugin_thdvar_init(THD *thd, bool lock_locals);
+extern void plugin_thdvar_cleanup(THD *thd);
 
 typedef my_bool (plugin_foreach_func)(THD *thd,
-                                      st_plugin_int *plugin,
+                                      plugin_ref plugin,
                                       void *arg);
 #define plugin_foreach(A,B,C,D) plugin_foreach_with_mask(A,B,C,PLUGIN_IS_READY,D)
-extern my_bool plugin_foreach_with_mask(THD *thd, plugin_foreach_func *func,
+extern bool plugin_foreach_with_mask(THD *thd, plugin_foreach_func *func,
-                                        int type, uint state_mask, void *arg);
+                                     int type, uint state_mask, void *arg);
 #endif

sql/sql_repl.cc

@@ -1596,6 +1596,149 @@ int log_loaded_block(IO_CACHE* file)
   return 0;
 }
 
+/*
+  Replication System Variables
+*/
+
+class sys_var_slave_skip_counter :public sys_var
+{
+public:
+  sys_var_slave_skip_counter(sys_var_chain *chain, const char *name_arg)
+    :sys_var(name_arg)
+  { chain_sys_var(chain); }
+  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()
+  */
+};
+
+class sys_var_sync_binlog_period :public sys_var_long_ptr
+{
+public:
+  sys_var_sync_binlog_period(sys_var_chain *chain, const char *name_arg, 
+                             ulong *value_ptr)
+    :sys_var_long_ptr(chain, name_arg,value_ptr) {}
+  bool update(THD *thd, set_var *var);
+};
+
+static sys_var_chain vars = { NULL, NULL };
+
+static sys_var_bool_ptr	sys_relay_log_purge(&vars, "relay_log_purge",
+					    &relay_log_purge);
+static sys_var_long_ptr	sys_slave_net_timeout(&vars, "slave_net_timeout",
+					      &slave_net_timeout);
+static sys_var_long_ptr	sys_slave_trans_retries(&vars, "slave_transaction_retries",
+						&slave_trans_retries);
+static sys_var_sync_binlog_period sys_sync_binlog_period(&vars, "sync_binlog", &sync_binlog_period);
+static sys_var_slave_skip_counter sys_slave_skip_counter(&vars, "sql_slave_skip_counter");
+
+static int show_slave_skip_errors(THD *thd, SHOW_VAR *var, char *buff);
+
+
+static SHOW_VAR fixed_vars[]= {
+  {"log_slave_updates",       (char*) &opt_log_slave_updates,       SHOW_MY_BOOL},
+  {"relay_log_space_limit",   (char*) &relay_log_space_limit,       SHOW_LONGLONG},
+  {"slave_load_tmpdir",       (char*) &slave_load_tmpdir,           SHOW_CHAR_PTR},
+  {"slave_skip_errors",       (char*) &show_slave_skip_errors,      SHOW_FUNC},
+};
+
+static int show_slave_skip_errors(THD *thd, SHOW_VAR *var, char *buff)
+{
+  var->type=SHOW_CHAR;
+  var->value= buff;
+  if (!use_slave_mask || bitmap_is_clear_all(&slave_error_mask))
+  {
+    var->value= const_cast<char *>("OFF");
+  }
+  else if (bitmap_is_set_all(&slave_error_mask))
+  {
+    var->value= const_cast<char *>("ALL");
+  }
+  else
+  {
+    /* 10 is enough assuming errors are max 4 digits */
+    int i;
+    var->value= buff;
+    for (i= 1;
+         i < MAX_SLAVE_ERROR &&
+         (buff - var->value) < SHOW_VAR_FUNC_BUFF_SIZE;
+         i++)
+    {
+      if (bitmap_is_set(&slave_error_mask, i))
+      {
+        buff= int10_to_str(i, buff, 10);
+        *buff++= ',';
+      }
+    }
+    if (var->value != buff)
+      buff--;				// Remove last ','
+    if (i < MAX_SLAVE_ERROR)
+      buff= strmov(buff, "...");  // Couldn't show all errors
+    *buff=0;
+  }
+  return 0;
+}
+
+bool sys_var_slave_skip_counter::check(THD *thd, set_var *var)
+{
+  int result= 0;
+  pthread_mutex_lock(&LOCK_active_mi);
+  pthread_mutex_lock(&active_mi->rli.run_lock);
+  if (active_mi->rli.slave_running)
+  {
+    my_message(ER_SLAVE_MUST_STOP, ER(ER_SLAVE_MUST_STOP), MYF(0));
+    result=1;
+  }
+  pthread_mutex_unlock(&active_mi->rli.run_lock);
+  pthread_mutex_unlock(&LOCK_active_mi);
+  var->save_result.ulong_value= (ulong) var->value->val_int();
+  return result;
+}
+
+
+bool sys_var_slave_skip_counter::update(THD *thd, set_var *var)
+{
+  pthread_mutex_lock(&LOCK_active_mi);
+  pthread_mutex_lock(&active_mi->rli.run_lock);
+  /*
+    The following test should normally never be true as we test this
+    in the check function;  To be safe against multiple
+    SQL_SLAVE_SKIP_COUNTER request, we do the check anyway
+  */
+  if (!active_mi->rli.slave_running)
+  {
+    pthread_mutex_lock(&active_mi->rli.data_lock);
+    active_mi->rli.slave_skip_counter= var->save_result.ulong_value;
+    pthread_mutex_unlock(&active_mi->rli.data_lock);
+  }
+  pthread_mutex_unlock(&active_mi->rli.run_lock);
+  pthread_mutex_unlock(&LOCK_active_mi);
+  return 0;
+}
+
+
+bool sys_var_sync_binlog_period::update(THD *thd, set_var *var)
+{
+  sync_binlog_period= (ulong) var->save_result.ulonglong_value;
+  return 0;
+}
+
+int init_replication_sys_vars()
+{
+  mysql_append_static_vars(fixed_vars, sizeof(fixed_vars) / sizeof(SHOW_VAR));
+
+  if (mysql_add_sys_var_chain(vars.first, my_long_options))
+  {
+    /* should not happen */
+    fprintf(stderr, "failed to initialize replication system variables");
+    unireg_abort(1);
+  }
+  return 0;
+}
+
 #endif /* HAVE_REPLICATION */
 
 

sql/sql_repl.h

@@ -67,6 +67,7 @@ typedef struct st_load_file_info
 } LOAD_FILE_INFO;
 
 int log_loaded_block(IO_CACHE* file);
+int init_replication_sys_vars();
 
 #endif /* HAVE_REPLICATION */
 

sql/sql_select.cc

@@ -9458,12 +9458,14 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
   share->fields= field_count;
 
   /* If result table is small; use a heap */
+  /* future: storage engine selection can be made dynamic? */
   if (blob_count || using_unique_constraint ||
       (select_options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==
       OPTION_BIG_TABLES || (select_options & TMP_TABLE_FORCE_MYISAM))
   {
+    share->db_plugin= ha_lock_engine(0, myisam_hton);
     table->file= get_new_handler(share, &table->mem_root,
-                                 share->db_type= myisam_hton);
+                                 share->db_type());
     if (group &&
 	(param->group_parts > table->file->max_key_parts() ||
 	 param->group_length > table->file->max_key_length()))
@@ -9471,8 +9473,9 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
   }
   else
   {
+    share->db_plugin= ha_lock_engine(0, heap_hton);
     table->file= get_new_handler(share, &table->mem_root,
-                                 share->db_type= heap_hton);
+                                 share->db_type());
   }
   if (!table->file)
     goto err;
@@ -9633,7 +9636,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
   if (thd->variables.tmp_table_size == ~ (ulonglong) 0)		// No limit
     share->max_rows= ~(ha_rows) 0;
   else
-    share->max_rows= (ha_rows) (((share->db_type == heap_hton) ?
+    share->max_rows= (ha_rows) (((share->db_type() == heap_hton) ?
                                  min(thd->variables.tmp_table_size,
                                      thd->variables.max_heap_table_size) :
                                  thd->variables.tmp_table_size) /
@@ -9781,7 +9784,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
   if (thd->is_fatal_error)				// If end of memory
     goto err;					 /* purecov: inspected */
   share->db_record_offset= 1;
-  if (share->db_type == myisam_hton)
+  if (share->db_type() == myisam_hton)
   {
     if (create_myisam_tmp_table(table,param,select_options))
       goto err;
@@ -10088,6 +10091,8 @@ free_tmp_table(THD *thd, TABLE *entry)
   if (entry->temp_pool_slot != MY_BIT_NONE)
     bitmap_lock_clear_bit(&temp_pool, entry->temp_pool_slot);
 
+  plugin_unlock(0, entry->s->db_plugin);
+
   free_root(&own_root, MYF(0)); /* the table is allocated in its own root */
   thd->proc_info=save_proc_info;
 
@@ -10107,7 +10112,7 @@ bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param,
   int write_err;
   DBUG_ENTER("create_myisam_from_heap");
 
-  if (table->s->db_type != heap_hton || 
+  if (table->s->db_type() != heap_hton || 
       error != HA_ERR_RECORD_FILE_FULL)
   {
     table->file->print_error(error,MYF(0));
@@ -10116,9 +10121,9 @@ bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param,
   new_table= *table;
   share= *table->s;
   new_table.s= &share;
-  new_table.s->db_type= myisam_hton;
+  new_table.s->db_plugin= ha_lock_engine(thd, myisam_hton);
   if (!(new_table.file= get_new_handler(&share, &new_table.mem_root,
-                                        myisam_hton)))
+                                        new_table.s->db_type())))
     DBUG_RETURN(1);				// End of memory
 
   save_proc_info=thd->proc_info;
@@ -10176,9 +10181,12 @@ bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param,
   (void) table->file->delete_table(table->s->table_name.str);
   delete table->file;
   table->file=0;
+  plugin_unlock(0, table->s->db_plugin);
+  share.db_plugin= my_plugin_lock(0, &share.db_plugin);
   new_table.s= table->s;                       // Keep old share
   *table= new_table;
   *table->s= share;
+  
   table->file->change_table_ptr(table, table->s);
   table->use_all_columns();
   if (save_proc_info)
@@ -12761,7 +12769,7 @@ remove_duplicates(JOIN *join, TABLE *entry,List<Item> &fields, Item *having)
 
   free_io_cache(entry);				// Safety
   entry->file->info(HA_STATUS_VARIABLE);
-  if (entry->s->db_type == heap_hton ||
+  if (entry->s->db_type() == heap_hton ||
       (!entry->s->blob_fields &&
        ((ALIGN_SIZE(reclength) + HASH_OVERHEAD) * entry->file->stats.records <
 	thd->variables.sortbuff_size)))

sql/sql_show.cc

@@ -77,24 +77,24 @@ append_algorithm(TABLE_LIST *table, String *buff);
 ** List all table types supported
 ***************************************************************************/
 
-static my_bool show_handlerton(THD *thd, st_plugin_int *plugin,
+static my_bool show_handlerton(THD *thd, plugin_ref plugin,
                                void *arg)
 {
   handlerton *default_type= (handlerton *) arg;
   Protocol *protocol= thd->protocol;
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
 
   if (!(hton->flags & HTON_HIDDEN))
   {
     protocol->prepare_for_resend();
-    protocol->store(plugin->name.str, plugin->name.length,
+    protocol->store(plugin_name(plugin)->str, plugin_name(plugin)->length,
                     system_charset_info);
     const char *option_name= show_comp_option_name[(int) hton->state];
 
     if (hton->state == SHOW_OPTION_YES && default_type == hton)
       option_name= "DEFAULT";
     protocol->store(option_name, system_charset_info);
-    protocol->store(plugin->plugin->descr, system_charset_info);
+    protocol->store(plugin_decl(plugin)->descr, system_charset_info);
     protocol->store(hton->commit ? "YES" : "NO", system_charset_info);
     protocol->store(hton->prepare ? "YES" : "NO", system_charset_info);
     protocol->store(hton->savepoint_set ? "YES" : "NO", system_charset_info);
@@ -122,7 +122,7 @@ bool mysqld_show_storage_engines(THD *thd)
     DBUG_RETURN(TRUE);
 
   if (plugin_foreach(thd, show_handlerton,
-                     MYSQL_STORAGE_ENGINE_PLUGIN, thd->variables.table_type))
+                     MYSQL_STORAGE_ENGINE_PLUGIN, ha_default_handlerton(thd)))
     DBUG_RETURN(TRUE);
 
   send_eof(thd);
@@ -134,24 +134,26 @@ static int make_version_string(char *buf, int buf_length, uint version)
   return my_snprintf(buf, buf_length, "%d.%d", version>>8,version&0xff);
 }
 
-static my_bool show_plugins(THD *thd, st_plugin_int *plugin,
+static my_bool show_plugins(THD *thd, plugin_ref plugin,
                             void *arg)
 {
   TABLE *table= (TABLE*) arg;
-  struct st_mysql_plugin *plug= plugin->plugin;
+  struct st_mysql_plugin *plug= plugin_decl(plugin);
+  struct st_plugin_dl *plugin_dl= plugin_dlib(plugin);
   CHARSET_INFO *cs= system_charset_info;
   char version_buf[20];
 
   restore_record(table, s->default_values);
 
-  table->field[0]->store(plugin->name.str, plugin->name.length, cs);
+  table->field[0]->store(plugin_name(plugin)->str,
+                         plugin_name(plugin)->length, cs);
 
   table->field[1]->store(version_buf,
         make_version_string(version_buf, sizeof(version_buf), plug->version),
         cs);
 
 
-  switch (plugin->state) {
+  switch (plugin_state(plugin)) {
   /* case PLUGIN_IS_FREED: does not happen */
   case PLUGIN_IS_DELETED:
     table->field[2]->store(STRING_WITH_LEN("DELETED"), cs);
@@ -173,14 +175,13 @@ static my_bool show_plugins(THD *thd, st_plugin_int *plugin,
         make_version_string(version_buf, sizeof(version_buf),
                             *(uint *)plug->info), cs);
 
-  if (plugin->plugin_dl)
+  if (plugin_dl)
   {
-    table->field[5]->store(plugin->plugin_dl->dl.str,
+    table->field[5]->store(plugin_dl->dl.str, plugin_dl->dl.length, cs);
-                           plugin->plugin_dl->dl.length, cs);
     table->field[5]->set_notnull();
     table->field[6]->store(version_buf,
           make_version_string(version_buf, sizeof(version_buf),
-                              plugin->plugin_dl->version),
+                              plugin_dl->version),
           cs);
     table->field[6]->set_notnull();
   }
@@ -1236,9 +1237,9 @@ int store_create_info(THD *thd, TABLE_LIST *table_list, String *packet,
     store_key_options(thd, packet, table, key_info);
     if (key_info->parser)
     {
+      LEX_STRING *parser_name= plugin_name(key_info->parser);
       packet->append(STRING_WITH_LEN(" /*!50100 WITH PARSER "));
-      append_identifier(thd, packet, key_info->parser->name.str,
+      append_identifier(thd, packet, parser_name->str, parser_name->length);
-                        key_info->parser->name.length);
       packet->append(STRING_WITH_LEN(" */ "));
     }
   }
@@ -1933,6 +1934,18 @@ void init_status_vars()
   sort_dynamic(&all_status_vars, show_var_cmp);
 }
 
+void reset_status_vars()
+{
+  SHOW_VAR *ptr= (SHOW_VAR*) all_status_vars.buffer;
+  SHOW_VAR *last= ptr + all_status_vars.elements;
+  for (; ptr < last; ptr++)
+  {
+    /* Note that SHOW_LONG_NOFLUSH variables are not reset */
+    if (ptr->type == SHOW_LONG)
+      *(ulong*) ptr->value= 0;
+  }  
+}
+
 /*
   catch-all cleanup function, cleans up everything no matter what
 
@@ -2063,6 +2076,8 @@ static bool show_status_array(THD *thd, const char *wild,
         char *value=var->value;
         const char *pos, *end;                  // We assign a lot of const's
 
+        pthread_mutex_lock(&LOCK_global_system_variables);
+
         if (show_type == SHOW_SYS)
         {
           show_type= ((sys_var*) value)->show_type();
@@ -2145,6 +2160,9 @@ static bool show_status_array(THD *thd, const char *wild,
                                system_charset_info);
         table->field[1]->store(pos, (uint32) (end - pos), system_charset_info);
         table->field[1]->set_notnull();
+
+        pthread_mutex_unlock(&LOCK_global_system_variables);
+
         if (schema_table_store_record(thd, table))
           DBUG_RETURN(TRUE);
       }
@@ -2455,13 +2473,13 @@ struct st_add_schema_table
   const char *wild;
 };
 
-static my_bool add_schema_table(THD *thd, st_plugin_int *plugin,
+static my_bool add_schema_table(THD *thd, plugin_ref plugin,
                                 void* p_data)
 {
   st_add_schema_table *data= (st_add_schema_table *)p_data;
   List<char> *file_list= data->files;
   const char *wild= data->wild;
-  ST_SCHEMA_TABLE *schema_table= (ST_SCHEMA_TABLE *)plugin->data;
+  ST_SCHEMA_TABLE *schema_table= plugin_data(plugin, ST_SCHEMA_TABLE *);
   DBUG_ENTER("add_schema_table");
 
   if (schema_table->hidden)
@@ -2995,7 +3013,7 @@ static int get_schema_tables_record(THD *thd, struct st_table_list *tables,
                   ha_row_type[(uint) share->row_type],
                   NullS);
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-    if (show_table->s->db_type == partition_hton && 
+    if (show_table->s->db_type() == partition_hton && 
         show_table->part_info != NULL && 
         show_table->part_info->no_parts > 0)
       ptr= strmov(ptr, " partitioned");
@@ -3270,19 +3288,20 @@ int fill_schema_charsets(THD *thd, TABLE_LIST *tables, COND *cond)
 }
 
 
-static my_bool iter_schema_engines(THD *thd, st_plugin_int *plugin,
+static my_bool iter_schema_engines(THD *thd, plugin_ref plugin,
                                    void *ptable)
 {
   TABLE *table= (TABLE *) ptable;
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
   const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NullS;
   CHARSET_INFO *scs= system_charset_info;
   DBUG_ENTER("iter_schema_engines");
 
   if (!(hton->flags & HTON_HIDDEN))
   {
+    LEX_STRING *name= plugin_name(plugin);
     if (!(wild && wild[0] &&
-          wild_case_compare(scs, plugin->name.str,wild)))
+          wild_case_compare(scs, name->str,wild)))
     {
       LEX_STRING state[2]= {{ C_STRING_WITH_LEN("ENABLED") },
                             { C_STRING_WITH_LEN("DISABLED") }};
@@ -3291,11 +3310,11 @@ static my_bool iter_schema_engines(THD *thd, st_plugin_int *plugin,
       LEX_STRING *tmp;
       restore_record(table, s->default_values);
 
-      table->field[0]->store(plugin->name.str, plugin->name.length, scs);
+      table->field[0]->store(name->str, name->length, scs);
       tmp= &state[test(hton->state)];
       table->field[1]->store(tmp->str, tmp->length, scs);
-      table->field[2]->store(plugin->plugin->descr,
+      table->field[2]->store(plugin_decl(plugin)->descr,
-                             strlen(plugin->plugin->descr), scs);
+                             strlen(plugin_decl(plugin)->descr), scs);
       tmp= &yesno[test(hton->commit)];
       table->field[3]->store(tmp->str, tmp->length, scs);
       tmp= &yesno[test(hton->prepare)];
@@ -4464,10 +4483,10 @@ int fill_variables(THD *thd, TABLE_LIST *tables, COND *cond)
   int res= 0;
   LEX *lex= thd->lex;
   const char *wild= lex->wild ? lex->wild->ptr() : NullS;
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  rw_rdlock(&LOCK_system_variables_hash);
-  res= show_status_array(thd, wild, init_vars,
+  res= show_status_array(thd, wild, enumerate_sys_vars(thd, TRUE),
                          lex->option_type, 0, "", tables->table, 0);
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  rw_unlock(&LOCK_system_variables_hash);
   DBUG_RETURN(res);
 }
 
@@ -4583,12 +4602,12 @@ struct schema_table_ref
     0	table not found
     1   found the schema table
 */
-static my_bool find_schema_table_in_plugin(THD *thd, st_plugin_int *plugin,
+static my_bool find_schema_table_in_plugin(THD *thd, plugin_ref plugin,
                                            void* p_table)
 {
   schema_table_ref *p_schema_table= (schema_table_ref *)p_table;
   const char* table_name= p_schema_table->table_name;
-  ST_SCHEMA_TABLE *schema_table= (ST_SCHEMA_TABLE *)plugin->data;
+  ST_SCHEMA_TABLE *schema_table= plugin_data(plugin, ST_SCHEMA_TABLE *);
   DBUG_ENTER("find_schema_table_in_plugin");
 
   if (!my_strcasecmp(system_charset_info,
@@ -5125,12 +5144,12 @@ struct run_hton_fill_schema_files_args
   COND *cond;
 };
 
-static my_bool run_hton_fill_schema_files(THD *thd, st_plugin_int *plugin,
+static my_bool run_hton_fill_schema_files(THD *thd, plugin_ref plugin,
                                           void *arg)
 {
   struct run_hton_fill_schema_files_args *args=
     (run_hton_fill_schema_files_args *) arg;
-  handlerton *hton= (handlerton *)plugin->data;
+  handlerton *hton= plugin_data(plugin, handlerton *);
   if(hton->fill_files_table && hton->state == SHOW_OPTION_YES)
     hton->fill_files_table(hton, thd, args->tables, args->cond);
   return false;
@@ -5296,10 +5315,10 @@ int fill_schema_global_variables(THD *thd, TABLE_LIST *tables, COND *cond)
   int res= 0;
   DBUG_ENTER("fill_schema_global_variables");
   
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  rw_rdlock(&LOCK_system_variables_hash);
-  res= show_status_array(thd, "", init_vars, OPT_GLOBAL,
+  res= show_status_array(thd, "", enumerate_sys_vars(thd, FALSE), OPT_GLOBAL,
                          NULL, "", tables->table, 1);
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  rw_unlock(&LOCK_system_variables_hash);
   
   DBUG_RETURN(res);
 }
@@ -5309,10 +5328,10 @@ int fill_schema_session_variables(THD *thd, TABLE_LIST *tables, COND *cond)
   int res= 0;
   DBUG_ENTER("fill_schema_session_variables");
   
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  rw_rdlock(&LOCK_system_variables_hash);
-  res= show_status_array(thd, "", init_vars, OPT_SESSION,
+  res= show_status_array(thd, "", enumerate_sys_vars(thd, FALSE), OPT_SESSION,
                          NULL, "", tables->table, 1);
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  rw_unlock(&LOCK_system_variables_hash);
   
   DBUG_RETURN(res);
 }

sql/sql_table.cc

@@ -662,16 +662,14 @@ static int execute_ddl_log_action(THD *thd, DDL_LOG_ENTRY *ddl_log_entry)
     frm_action= TRUE;
   else
   {
-    TABLE_SHARE dummy;
+    plugin_ref plugin= ha_resolve_by_name(thd, &handler_name);
-
+    if (!plugin)
-    hton= ha_resolve_by_name(thd, &handler_name);
-    if (!hton)
     {
       my_error(ER_ILLEGAL_HA, MYF(0), ddl_log_entry->handler_name);
       goto error;
     }
-    bzero(&dummy, sizeof(TABLE_SHARE));
+    hton= plugin_data(plugin, handlerton*);
-    file= get_new_handler(&dummy, &mem_root, hton);
+    file= get_new_handler((TABLE_SHARE*)0, &mem_root, hton);
     if (!file)
     {
       mem_alloc_error(sizeof(handler));
@@ -1635,7 +1633,7 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists,
     TABLE_SHARE *share;
     table->db_type= NULL;
     if ((share= get_cached_table_share(table->db, table->table_name)))
-      table->db_type= share->db_type;
+      table->db_type= share->db_type();
 
     /* Disable drop of enabled log tables */
     if (share && share->log_table &&
@@ -5031,7 +5029,7 @@ static uint compare_tables(TABLE *table, List<create_field> *create_list,
     See BUG#6236.
   */
   if (table->s->fields != create_list->elements ||
-      table->s->db_type != create_info->db_type ||
+      table->s->db_type() != create_info->db_type ||
       table->s->tmp_table ||
       create_info->used_fields & HA_CREATE_USED_ENGINE ||
       create_info->used_fields & HA_CREATE_USED_CHARSET ||
@@ -5490,7 +5488,7 @@ view_err:
     new_name= table_name;
   }
 
-  old_db_type= table->s->db_type;
+  old_db_type= table->s->db_type();
   if (!create_info->db_type)
   {
 #ifdef WITH_PARTITION_STORAGE_ENGINE
@@ -6002,7 +6000,7 @@ view_err:
   }
 
   if (thd->variables.old_alter_table
-      || (table->s->db_type != create_info->db_type)
+      || (table->s->db_type() != create_info->db_type)
 #ifdef WITH_PARTITION_STORAGE_ENGINE
       || partition_changed
 #endif
@@ -6040,8 +6038,8 @@ view_err:
     uint  *idx_p;
     uint  *idx_end_p;
 
-    if (table->s->db_type->alter_table_flags)
+    if (table->s->db_type()->alter_table_flags)
-      alter_flags= table->s->db_type->alter_table_flags(alter_info->flags);
+      alter_flags= table->s->db_type()->alter_table_flags(alter_info->flags);
     DBUG_PRINT("info", ("alter_flags: %lu", alter_flags));
     /* Check dropped indexes. */
     for (idx_p= index_drop_buffer, idx_end_p= idx_p + index_drop_count;
@@ -7066,7 +7064,7 @@ static bool check_engine(THD *thd, const char *table_name,
     if (create_info->used_fields & HA_CREATE_USED_ENGINE)
     {
       my_error(ER_ILLEGAL_HA_CREATE_OPTION, MYF(0),
-               hton2plugin[(*new_engine)->slot]->name.str, "TEMPORARY");
+               ha_resolve_storage_engine_name(*new_engine), "TEMPORARY");
       *new_engine= 0;
       return TRUE;
     }

sql/sql_tablespace.cc

@@ -34,7 +34,7 @@ int mysql_alter_tablespace(THD *thd, st_alter_tablespace *ts_info)
       push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
                           ER_WARN_USING_OTHER_HANDLER,
                           ER(ER_WARN_USING_OTHER_HANDLER),
-                          hton2plugin[hton->slot]->name.str,
+                          ha_resolve_storage_engine_name(hton),
                           ts_info->tablespace_name ? ts_info->tablespace_name
                                                 : ts_info->logfile_group_name);
   }
@@ -63,7 +63,7 @@ int mysql_alter_tablespace(THD *thd, st_alter_tablespace *ts_info)
     push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
                         ER_ILLEGAL_HA_CREATE_OPTION,
                         ER(ER_ILLEGAL_HA_CREATE_OPTION),
-                        hton2plugin[hton->slot]->name.str,
+                        ha_resolve_storage_engine_name(hton),
                         "TABLESPACE or LOGFILE GROUP");
   }
   if (mysql_bin_log.is_open())

sql/sql_yacc.yy

@@ -1043,7 +1043,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 
 %type <interval_time_st> interval_time_st
 
-%type <db_type> storage_engines
+%type <db_type> storage_engines known_storage_engine
 
 %type <row_type> row_types
 
@@ -1447,14 +1447,26 @@ create:
 	  lex->change=NullS;
 	  bzero((char*) &lex->create_info,sizeof(lex->create_info));
 	  lex->create_info.options=$2 | $4;
-	  lex->create_info.db_type= lex->thd->variables.table_type;
+	  lex->create_info.db_type= ha_default_handlerton(thd);
 	  lex->create_info.default_table_charset= NULL;
 	  lex->name.str= 0;
           lex->name.length= 0;
          lex->like_name= 0;
 	}
 	create2
-	  { Lex->current_select= &Lex->select_lex; }
+	{
+	  LEX *lex= YYTHD->lex;
+          lex->current_select= &lex->select_lex; 
+          if (!lex->create_info.db_type)
+          {
+            lex->create_info.db_type= ha_default_handlerton(YYTHD);
+            push_warning_printf(YYTHD, MYSQL_ERROR::WARN_LEVEL_WARN,
+                                ER_WARN_USING_OTHER_HANDLER,
+                                ER(ER_WARN_USING_OTHER_HANDLER),
+                                ha_resolve_storage_engine_name(lex->create_info.db_type),
+                                $5->table.str);
+          }
+        }
 	| CREATE opt_unique_or_fulltext INDEX_SYM ident key_alg ON
 	  table_ident
 	  {
@@ -3365,7 +3377,7 @@ opt_ts_comment:
           };
 
 opt_ts_engine:
-          opt_storage ENGINE_SYM opt_equal storage_engines
+          opt_storage ENGINE_SYM opt_equal known_storage_engine
           {
             LEX *lex= Lex;
             if (lex->alter_tablespace_info->storage_engine != NULL)
@@ -3533,6 +3545,13 @@ partitioning:
         {
 #ifdef WITH_PARTITION_STORAGE_ENGINE
           LEX *lex= Lex;
+          LEX_STRING partition_name={C_STRING_WITH_LEN("partition")};
+          if (!plugin_is_ready(&partition_name, MYSQL_STORAGE_ENGINE_PLUGIN))
+          {
+            my_error(ER_FEATURE_DISABLED, MYF(0),
+                     "partitioning", "--with-partition");
+            YYABORT;
+          }
           lex->part_info= new partition_info();
           if (!lex->part_info)
           {
@@ -4046,7 +4065,7 @@ opt_part_option_list:
 opt_part_option:
         TABLESPACE opt_equal ident_or_text
         { Lex->part_info->curr_part_elem->tablespace_name= $3.str; }
-        | opt_storage ENGINE_SYM opt_equal storage_engines
+        | opt_storage ENGINE_SYM opt_equal known_storage_engine
         {
           LEX *lex= Lex;
           lex->part_info->curr_part_elem->engine_type= $4;
@@ -4251,21 +4270,43 @@ default_collation:
 storage_engines:
 	ident_or_text
 	{
-	  $$ = ha_resolve_by_name(YYTHD, &$1);
+          LEX *lex= YYTHD->lex;
-	  if ($$ == NULL)
+          plugin_ref plugin;
+          
+          if ((plugin= ha_resolve_by_name(YYTHD, &$1)))
+            $$= plugin_data(plugin, handlerton*);
+          else
           if (YYTHD->variables.sql_mode & MODE_NO_ENGINE_SUBSTITUTION)
 	  {
 	    my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), $1.str);
 	    YYABORT;
 	  }
           else
+          if (lex->sql_command == SQLCOM_ALTER_TABLE)
           {
-            push_warning_printf(YYTHD, MYSQL_ERROR::WARN_LEVEL_ERROR,
+            TABLE_LIST *table= (TABLE_LIST *) lex->select_lex.table_list.first;
-                                ER_UNKNOWN_STORAGE_ENGINE,
+            $$= ha_default_handlerton(YYTHD);
-                                ER(ER_UNKNOWN_STORAGE_ENGINE), $1.str);
+            push_warning_printf(YYTHD, MYSQL_ERROR::WARN_LEVEL_WARN,
+                                ER_WARN_USING_OTHER_HANDLER,
+                                ER(ER_WARN_USING_OTHER_HANDLER),
+                                ha_resolve_storage_engine_name($$),
+                                table->table_name);
           }
 	};
 
+known_storage_engine:
+	ident_or_text
+	{
+          plugin_ref plugin;
+          if ((plugin= ha_resolve_by_name(YYTHD, &$1)))
+            $$= plugin_data(plugin, handlerton*);
+          else
+	  {
+	    my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), $1.str);
+	    YYABORT;
+	  }
+	};
+
 row_types:
 	DEFAULT		{ $$= ROW_TYPE_DEFAULT; }
 	| FIXED_SYM	{ $$= ROW_TYPE_FIXED; }
@@ -8452,7 +8493,7 @@ show_param:
             if (prepare_schema_table(YYTHD, lex, 0, SCH_PLUGINS))
               YYABORT;
 	  }
-	| ENGINE_SYM storage_engines 
+	| ENGINE_SYM known_storage_engine
 	  { Lex->create_info.db_type= $2; }
 	  show_engine_param
 	| ENGINE_SYM ALL 
@@ -10095,7 +10136,7 @@ sys_option_value:
 	  LEX *lex=Lex;
 	  lex->option_type= $1;
 	  lex->var_list.push_back(new set_var(lex->option_type,
-                                              find_sys_var("tx_isolation"),
+                                              find_sys_var(YYTHD, "tx_isolation"),
                                               &null_lex_str,
                                               new Item_int((int32) $5)));
 	}
@@ -10184,7 +10225,7 @@ internal_variable_name:
 	  if (!spc || !(spv = spc->find_variable(&$1)))
 	  {
             /* Not an SP local variable */
-	    sys_var *tmp=find_sys_var($1.str, $1.length);
+	    sys_var *tmp=find_sys_var(YYTHD, $1.str, $1.length);
 	    if (!tmp)
 	      YYABORT;
 	    $$.var= tmp;
@@ -10246,7 +10287,7 @@ internal_variable_name:
             }
             else
             {
-              sys_var *tmp=find_sys_var($3.str, $3.length);
+              sys_var *tmp=find_sys_var(YYTHD, $3.str, $3.length);
               if (!tmp)
                 YYABORT;
               if (!tmp->is_struct())
@@ -10257,7 +10298,7 @@ internal_variable_name:
 	  }
 	| DEFAULT '.' ident
 	  {
-	    sys_var *tmp=find_sys_var($3.str, $3.length);
+	    sys_var *tmp=find_sys_var(YYTHD, $3.str, $3.length);
 	    if (!tmp)
 	      YYABORT;
 	    if (!tmp->is_struct())

sql/structs.h

@@ -83,7 +83,11 @@ typedef struct st_key {
   */
   union
   {
+#ifdef DBUG_OFF
     struct st_plugin_int *parser;       /* Fulltext [pre]parser */
+#else
+    struct st_plugin_int **parser;      /* Fulltext [pre]parser */
+#endif
     LEX_STRING *parser_name;            /* Fulltext [pre]parser name */
   };
   KEY_PART_INFO *key_part;

sql/table.cc

@@ -238,6 +238,9 @@ void free_table_share(TABLE_SHARE *share)
     pthread_cond_destroy(&share->cond);
   }
   hash_free(&share->name_hash);
+  
+  plugin_unlock(NULL, share->db_plugin);
+  share->db_plugin= NULL;
 
   /* We must copy mem_root from share because share is allocated through it */
   memcpy((char*) &mem_root, (char*) &share->mem_root, sizeof(mem_root));
@@ -422,6 +425,7 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
   Field  **field_ptr, *reg_field;
   const char **interval_array;
   enum legacy_db_type legacy_db_type;
+  handlerton *hton;
   my_bitmap_map *bitmaps;
   DBUG_ENTER("open_binary_frm");
 
@@ -452,7 +456,11 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
   DBUG_PRINT("info", ("default_part_db_type = %u", head[61]));
 #endif
   legacy_db_type= (enum legacy_db_type) (uint) *(head+3);
-  share->db_type= ha_checktype(thd, legacy_db_type, 0, 0);
+  if ((hton= ha_checktype(thd, legacy_db_type, 0, 0)) != share->db_type())
+  {
+    plugin_unlock(NULL, share->db_plugin);
+    share->db_plugin= ha_lock_engine(NULL, hton);
+  }
   share->db_create_options= db_create_options= uint2korr(head+30);
   share->db_options_in_use= share->db_create_options;
   share->mysql_version= uint4korr(head+51);
@@ -611,24 +619,38 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
     {
       uint str_db_type_length= uint2korr(next_chunk);
       LEX_STRING name= { next_chunk + 2, str_db_type_length };
-      handlerton *tmp_db_type= ha_resolve_by_name(thd, &name);
+      plugin_ref tmp_plugin= ha_resolve_by_name(thd, &name);
-      if (tmp_db_type != NULL)
+      if (tmp_plugin != NULL)
       {
-        share->db_type= tmp_db_type;
+        /*
+          tmp_plugin is locked with a local lock.
+          we unlock the old value of share->db_plugin before
+          replacing it with a globally locked version of tmp_plugin
+        */
+        plugin_unlock(NULL, share->db_plugin);
+        share->db_plugin= my_plugin_lock(NULL, &tmp_plugin);
         DBUG_PRINT("info", ("setting dbtype to '%.*s' (%d)",
                             str_db_type_length, next_chunk + 2,
-                            ha_legacy_type(share->db_type)));
+                            ha_legacy_type(share->db_type())));
       }
 #ifdef WITH_PARTITION_STORAGE_ENGINE
       else
       {
-        if (!strncmp(next_chunk + 2, "partition", str_db_type_length))
+        LEX_STRING pname= { C_STRING_WITH_LEN( "partition" ) };
+        if (str_db_type_length == pname.length &&
+            !strncmp(next_chunk + 2, pname.str, pname.length))
         {
-          /* Use partition handler */
+          /*
-          share->db_type= partition_hton;
+            Use partition handler
+            tmp_plugin is locked with a local lock.
+            we unlock the old value of share->db_plugin before
+            replacing it with a globally locked version of tmp_plugin
+          */
+          plugin_unlock(NULL, share->db_plugin);
+          share->db_plugin= ha_lock_engine(NULL, partition_hton);
           DBUG_PRINT("info", ("setting dbtype to '%.*s' (%d)",
                               str_db_type_length, next_chunk + 2,
-                              ha_legacy_type(share->db_type)));
+                              ha_legacy_type(share->db_type())));
         }
       }
 #endif
@@ -694,7 +716,8 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
         }
         parser_name.str= next_chunk;
         parser_name.length= strlen(next_chunk);
-        keyinfo->parser= plugin_lock(&parser_name, MYSQL_FTPARSER_PLUGIN);
+        keyinfo->parser= my_plugin_lock_by_name(NULL, &parser_name,
+                                                MYSQL_FTPARSER_PLUGIN);
         if (! keyinfo->parser)
         {
           my_error(ER_PLUGIN_IS_NOT_LOADED, MYF(0), parser_name.str);
@@ -810,7 +833,7 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
 
  /* Allocate handler */
   if (!(handler_file= get_new_handler(share, thd->mem_root,
-                                      share->db_type)))
+                                      share->db_type())))
     goto err;
 
   record= (char*) share->default_values-1;	/* Fieldstart = 1 */
@@ -1344,7 +1367,7 @@ int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias,
 
   /* Allocate handler */
   if (!(outparam->file= get_new_handler(share, &outparam->mem_root,
-                                        share->db_type)))
+                                        share->db_type())))
     goto err;
 
   error= 4;
@@ -1628,7 +1651,7 @@ int closefrm(register TABLE *table, bool free_share)
   {
     if (key_info->flags & HA_USES_PARSER)
     {
-      plugin_unlock(key_info->parser);
+      plugin_unlock(NULL, key_info->parser);
       key_info->flags= 0;
     }
   }
@@ -1839,10 +1862,10 @@ void open_table_error(TABLE_SHARE *share, int error, int db_errno, int errarg)
     handler *file= 0;
     const char *datext= "";
     
-    if (share->db_type != NULL)
+    if (share->db_type() != NULL)
     {
       if ((file= get_new_handler(share, current_thd->mem_root,
-                                 share->db_type)))
+                                 share->db_type())))
       {
         if (!(datext= *file->bas_ext()))
           datext= "";

sql/table.h

@@ -172,7 +172,12 @@ typedef struct st_table_share
   ulong   timestamp_offset;		/* Set to offset+1 of record */
   ulong   reclength;			/* Recordlength */
 
-  handlerton *db_type;			/* table_type for handler */
+  plugin_ref db_plugin;			/* storage engine plugin */
+  inline handlerton *db_type() const	/* table_type for handler */
+  { 
+    // DBUG_ASSERT(db_plugin);
+    return db_plugin ? plugin_data(db_plugin, handlerton*) : NULL;
+  }
   enum row_type row_type;		/* How rows are stored */
   enum tmp_table_type tmp_table;
 

storage/federated/ha_federated.cc

@@ -1777,7 +1777,7 @@ int ha_federated::write_row(byte *buf)
   values_string.length(0);
   insert_string.length(0);
   insert_field_value_string.length(0);
-  statistic_increment(table->in_use->status_var.ha_write_count, &LOCK_status);
+  ha_statistic_increment(&SSV::ha_write_count);
   if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
     table->timestamp_field->set_time();
 
@@ -2244,8 +2244,7 @@ int ha_federated::index_read_idx_with_result_set(byte *buf, uint index,
   *result= 0;                                   // In case of errors
   index_string.length(0);
   sql_query.length(0);
-  statistic_increment(table->in_use->status_var.ha_read_key_count,
+  ha_statistic_increment(&SSV::ha_read_key_count);
-                      &LOCK_status);
 
   sql_query.append(share->select_query);
 
@@ -2359,8 +2358,7 @@ int ha_federated::read_range_next()
 int ha_federated::index_next(byte *buf)
 {
   DBUG_ENTER("ha_federated::index_next");
-  statistic_increment(table->in_use->status_var.ha_read_next_count,
+  ha_statistic_increment(&SSV::ha_read_next_count);
-		      &LOCK_status);
   DBUG_RETURN(read_next(buf, stored_result));
 }
 
@@ -2561,8 +2559,7 @@ int ha_federated::rnd_pos(byte *buf, byte *pos)
 {
   int result;
   DBUG_ENTER("ha_federated::rnd_pos");
-  statistic_increment(table->in_use->status_var.ha_read_rnd_count,
+  ha_statistic_increment(&SSV::ha_read_rnd_count);
-                      &LOCK_status);
   if (table->s->primary_key != MAX_KEY)
   {
     /* We have a primary key, so use index_read_idx to find row */

storage/heap/ha_heap.cc

@@ -181,7 +181,7 @@ void ha_heap::update_key_stats()
 int ha_heap::write_row(byte * buf)
 {
   int res;
-  statistic_increment(table->in_use->status_var.ha_write_count,&LOCK_status);
+  ha_statistic_increment(&SSV::ha_write_count);
   if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
     table->timestamp_field->set_time();
   if (table->next_number_field && buf == table->record[0])
@@ -205,7 +205,7 @@ int ha_heap::write_row(byte * buf)
 int ha_heap::update_row(const byte * old_data, byte * new_data)
 {
   int res;
-  statistic_increment(table->in_use->status_var.ha_update_count,&LOCK_status);
+  ha_statistic_increment(&SSV::ha_update_count);
   if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
     table->timestamp_field->set_time();
   res= heap_update(file,old_data,new_data);
@@ -224,7 +224,7 @@ int ha_heap::update_row(const byte * old_data, byte * new_data)
 int ha_heap::delete_row(const byte * buf)
 {
   int res;
-  statistic_increment(table->in_use->status_var.ha_delete_count,&LOCK_status);
+  ha_statistic_increment(&SSV::ha_delete_count);
   res= heap_delete(file,buf);
   if (!res && table->s->tmp_table == NO_TMP_TABLE && 
       ++records_changed*HEAP_STATS_UPDATE_THRESHOLD > file->s->records)
@@ -242,8 +242,7 @@ int ha_heap::index_read(byte * buf, const byte * key, uint key_len,
 			enum ha_rkey_function find_flag)
 {
   DBUG_ASSERT(inited==INDEX);
-  statistic_increment(table->in_use->status_var.ha_read_key_count,
+  ha_statistic_increment(&SSV::ha_read_key_count);
-		      &LOCK_status);
   int error = heap_rkey(file,buf,active_index, key, key_len, find_flag);
   table->status = error ? STATUS_NOT_FOUND : 0;
   return error;
@@ -252,8 +251,7 @@ int ha_heap::index_read(byte * buf, const byte * key, uint key_len,
 int ha_heap::index_read_last(byte *buf, const byte *key, uint key_len)
 {
   DBUG_ASSERT(inited==INDEX);
-  statistic_increment(table->in_use->status_var.ha_read_key_count,
+  ha_statistic_increment(&SSV::ha_read_key_count);
-		      &LOCK_status);
   int error= heap_rkey(file, buf, active_index, key, key_len,
 		       HA_READ_PREFIX_LAST);
   table->status= error ? STATUS_NOT_FOUND : 0;
@@ -263,8 +261,7 @@ int ha_heap::index_read_last(byte *buf, const byte *key, uint key_len)
 int ha_heap::index_read_idx(byte * buf, uint index, const byte * key,
 			    uint key_len, enum ha_rkey_function find_flag)
 {
-  statistic_increment(table->in_use->status_var.ha_read_key_count,
+  ha_statistic_increment(&SSV::ha_read_key_count);
-		      &LOCK_status);
   int error = heap_rkey(file, buf, index, key, key_len, find_flag);
   table->status = error ? STATUS_NOT_FOUND : 0;
   return error;
@@ -273,8 +270,7 @@ int ha_heap::index_read_idx(byte * buf, uint index, const byte * key,
 int ha_heap::index_next(byte * buf)
 {
   DBUG_ASSERT(inited==INDEX);
-  statistic_increment(table->in_use->status_var.ha_read_next_count,
+  ha_statistic_increment(&SSV::ha_read_next_count);
-		      &LOCK_status);
   int error=heap_rnext(file,buf);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -283,8 +279,7 @@ int ha_heap::index_next(byte * buf)
 int ha_heap::index_prev(byte * buf)
 {
   DBUG_ASSERT(inited==INDEX);
-  statistic_increment(table->in_use->status_var.ha_read_prev_count,
+  ha_statistic_increment(&SSV::ha_read_prev_count);
-		      &LOCK_status);
   int error=heap_rprev(file,buf);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -293,8 +288,7 @@ int ha_heap::index_prev(byte * buf)
 int ha_heap::index_first(byte * buf)
 {
   DBUG_ASSERT(inited==INDEX);
-  statistic_increment(table->in_use->status_var.ha_read_first_count,
+  ha_statistic_increment(&SSV::ha_read_first_count);
-		      &LOCK_status);
   int error=heap_rfirst(file, buf, active_index);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -303,8 +297,7 @@ int ha_heap::index_first(byte * buf)
 int ha_heap::index_last(byte * buf)
 {
   DBUG_ASSERT(inited==INDEX);
-  statistic_increment(table->in_use->status_var.ha_read_last_count,
+  ha_statistic_increment(&SSV::ha_read_last_count);
-		      &LOCK_status);
   int error=heap_rlast(file, buf, active_index);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -317,8 +310,7 @@ int ha_heap::rnd_init(bool scan)
 
 int ha_heap::rnd_next(byte *buf)
 {
-  statistic_increment(table->in_use->status_var.ha_read_rnd_next_count,
+  ha_statistic_increment(&SSV::ha_read_rnd_next_count);
-		      &LOCK_status);
   int error=heap_scan(file, buf);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -328,8 +320,7 @@ int ha_heap::rnd_pos(byte * buf, byte *pos)
 {
   int error;
   HEAP_PTR heap_position;
-  statistic_increment(table->in_use->status_var.ha_read_rnd_count,
+  ha_statistic_increment(&SSV::ha_read_rnd_count);
-		      &LOCK_status);
   memcpy_fixed((char*) &heap_position, pos, sizeof(HEAP_PTR));
   error=heap_rrnd(file, buf, heap_position);
   table->status=error ? STATUS_NOT_FOUND: 0;

storage/innobase/include/trx0trx.h

@@ -501,6 +501,14 @@ struct trx_struct{
 	ulint		mysql_process_no;/* since in Linux, 'top' reports
 					process id's and not thread id's, we
 					store the process number too */
+	ibool		allow_duplicates;/* normally FALSE, but if the user
+					wants to update duplicate rows,
+					(in table inserts, for example) we
+					set this TRUE */
+	ibool		replace_duplicates;/* normally FALSE, but if the user
+					wants to replace duplicate rows,
+					(in table inserts, for example) we
+					set this TRUE */
 	/*------------------------------*/
 	ulint		n_mysql_tables_in_use; /* number of Innobase tables
 					used in the processing of the current

storage/myisam/ha_myisam.cc

@@ -633,10 +633,10 @@ int ha_myisam::open(const char *name, int mode, uint test_if_locked)
 
   for (i= 0; i < table->s->keys; i++)
   {
-    struct st_plugin_int *parser= table->key_info[i].parser;
+    plugin_ref parser= table->key_info[i].parser;
     if (table->key_info[i].flags & HA_USES_PARSER)
       file->s->keyinfo[i].parser=
-        (struct st_mysql_ftparser *)parser->plugin->info;
+        (struct st_mysql_ftparser *)plugin_decl(parser)->info;
     table->key_info[i].block_size= file->s->keyinfo[i].block_length;
   }
   return (0);
@@ -651,7 +651,7 @@ int ha_myisam::close(void)
 
 int ha_myisam::write_row(byte * buf)
 {
-  statistic_increment(table->in_use->status_var.ha_write_count,&LOCK_status);
+  ha_statistic_increment(&SSV::ha_write_count);
 
   /* If we have a timestamp column, update it to the current time */
   if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
@@ -1509,7 +1509,7 @@ bool ha_myisam::is_crashed() const
 
 int ha_myisam::update_row(const byte * old_data, byte * new_data)
 {
-  statistic_increment(table->in_use->status_var.ha_update_count,&LOCK_status);
+  ha_statistic_increment(&SSV::ha_update_count);
   if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
     table->timestamp_field->set_time();
   return mi_update(file,old_data,new_data);
@@ -1517,7 +1517,7 @@ int ha_myisam::update_row(const byte * old_data, byte * new_data)
 
 int ha_myisam::delete_row(const byte * buf)
 {
-  statistic_increment(table->in_use->status_var.ha_delete_count,&LOCK_status);
+  ha_statistic_increment(&SSV::ha_delete_count);
   return mi_delete(file,buf);
 }
 
@@ -1525,8 +1525,7 @@ int ha_myisam::index_read(byte * buf, const byte * key,
 			  uint key_len, enum ha_rkey_function find_flag)
 {
   DBUG_ASSERT(inited==INDEX);
-  statistic_increment(table->in_use->status_var.ha_read_key_count,
+  ha_statistic_increment(&SSV::ha_read_key_count);
-		      &LOCK_status);
   int error=mi_rkey(file,buf,active_index, key, key_len, find_flag);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -1535,8 +1534,7 @@ int ha_myisam::index_read(byte * buf, const byte * key,
 int ha_myisam::index_read_idx(byte * buf, uint index, const byte * key,
 			      uint key_len, enum ha_rkey_function find_flag)
 {
-  statistic_increment(table->in_use->status_var.ha_read_key_count,
+  ha_statistic_increment(&SSV::ha_read_key_count);
-		      &LOCK_status);
   int error=mi_rkey(file,buf,index, key, key_len, find_flag);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -1546,8 +1544,7 @@ int ha_myisam::index_read_last(byte * buf, const byte * key, uint key_len)
 {
   DBUG_ENTER("ha_myisam::index_read_last");
   DBUG_ASSERT(inited==INDEX);
-  statistic_increment(table->in_use->status_var.ha_read_key_count,
+  ha_statistic_increment(&SSV::ha_read_key_count);
-		      &LOCK_status);
   int error=mi_rkey(file,buf,active_index, key, key_len, HA_READ_PREFIX_LAST);
   table->status=error ? STATUS_NOT_FOUND: 0;
   DBUG_RETURN(error);
@@ -1556,8 +1553,7 @@ int ha_myisam::index_read_last(byte * buf, const byte * key, uint key_len)
 int ha_myisam::index_next(byte * buf)
 {
   DBUG_ASSERT(inited==INDEX);
-  statistic_increment(table->in_use->status_var.ha_read_next_count,
+  ha_statistic_increment(&SSV::ha_read_next_count);
-		      &LOCK_status);
   int error=mi_rnext(file,buf,active_index);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -1566,8 +1562,7 @@ int ha_myisam::index_next(byte * buf)
 int ha_myisam::index_prev(byte * buf)
 {
   DBUG_ASSERT(inited==INDEX);
-  statistic_increment(table->in_use->status_var.ha_read_prev_count,
+  ha_statistic_increment(&SSV::ha_read_prev_count);
-		      &LOCK_status);
   int error=mi_rprev(file,buf, active_index);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -1576,8 +1571,7 @@ int ha_myisam::index_prev(byte * buf)
 int ha_myisam::index_first(byte * buf)
 {
   DBUG_ASSERT(inited==INDEX);
-  statistic_increment(table->in_use->status_var.ha_read_first_count,
+  ha_statistic_increment(&SSV::ha_read_first_count);
-		      &LOCK_status);
   int error=mi_rfirst(file, buf, active_index);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -1586,8 +1580,7 @@ int ha_myisam::index_first(byte * buf)
 int ha_myisam::index_last(byte * buf)
 {
   DBUG_ASSERT(inited==INDEX);
-  statistic_increment(table->in_use->status_var.ha_read_last_count,
+  ha_statistic_increment(&SSV::ha_read_last_count);
-		      &LOCK_status);
   int error=mi_rlast(file, buf, active_index);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -1598,8 +1591,7 @@ int ha_myisam::index_next_same(byte * buf,
 			       uint length __attribute__((unused)))
 {
   DBUG_ASSERT(inited==INDEX);
-  statistic_increment(table->in_use->status_var.ha_read_next_count,
+  ha_statistic_increment(&SSV::ha_read_next_count);
-		      &LOCK_status);
   int error=mi_rnext_same(file,buf);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -1615,8 +1607,7 @@ int ha_myisam::rnd_init(bool scan)
 
 int ha_myisam::rnd_next(byte *buf)
 {
-  statistic_increment(table->in_use->status_var.ha_read_rnd_next_count,
+  ha_statistic_increment(&SSV::ha_read_rnd_next_count);
-		      &LOCK_status);
   int error=mi_scan(file, buf);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -1629,8 +1620,7 @@ int ha_myisam::restart_rnd_next(byte *buf, byte *pos)
 
 int ha_myisam::rnd_pos(byte * buf, byte *pos)
 {
-  statistic_increment(table->in_use->status_var.ha_read_rnd_count,
+  ha_statistic_increment(&SSV::ha_read_rnd_count);
-		      &LOCK_status);
   int error=mi_rrnd(file, buf, my_get_ptr(pos,ref_length));
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;

storage/myisammrg/ha_myisammrg.cc

@@ -148,7 +148,7 @@ int ha_myisammrg::close(void)
 
 int ha_myisammrg::write_row(byte * buf)
 {
-  statistic_increment(table->in_use->status_var.ha_write_count,&LOCK_status);
+  ha_statistic_increment(&SSV::ha_write_count);
 
   if (file->merge_insert_method == MERGE_INSERT_DISABLED || !file->tables)
     return (HA_ERR_TABLE_READONLY);
@@ -166,7 +166,7 @@ int ha_myisammrg::write_row(byte * buf)
 
 int ha_myisammrg::update_row(const byte * old_data, byte * new_data)
 {
-  statistic_increment(table->in_use->status_var.ha_update_count,&LOCK_status);
+  ha_statistic_increment(&SSV::ha_update_count);
   if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
     table->timestamp_field->set_time();
   return myrg_update(file,old_data,new_data);
@@ -174,15 +174,14 @@ int ha_myisammrg::update_row(const byte * old_data, byte * new_data)
 
 int ha_myisammrg::delete_row(const byte * buf)
 {
-  statistic_increment(table->in_use->status_var.ha_delete_count,&LOCK_status);
+  ha_statistic_increment(&SSV::ha_delete_count);
   return myrg_delete(file,buf);
 }
 
 int ha_myisammrg::index_read(byte * buf, const byte * key,
 			  uint key_len, enum ha_rkey_function find_flag)
 {
-  statistic_increment(table->in_use->status_var.ha_read_key_count,
+  ha_statistic_increment(&SSV::ha_read_key_count);
-		      &LOCK_status);
   int error=myrg_rkey(file,buf,active_index, key, key_len, find_flag);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -191,8 +190,7 @@ int ha_myisammrg::index_read(byte * buf, const byte * key,
 int ha_myisammrg::index_read_idx(byte * buf, uint index, const byte * key,
 				 uint key_len, enum ha_rkey_function find_flag)
 {
-  statistic_increment(table->in_use->status_var.ha_read_key_count,
+  ha_statistic_increment(&SSV::ha_read_key_count);
-		      &LOCK_status);
   int error=myrg_rkey(file,buf,index, key, key_len, find_flag);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -200,8 +198,7 @@ int ha_myisammrg::index_read_idx(byte * buf, uint index, const byte * key,
 
 int ha_myisammrg::index_read_last(byte * buf, const byte * key, uint key_len)
 {
-  statistic_increment(table->in_use->status_var.ha_read_key_count,
+  ha_statistic_increment(&SSV::ha_read_key_count);
-		      &LOCK_status);
   int error=myrg_rkey(file,buf,active_index, key, key_len,
 		      HA_READ_PREFIX_LAST);
   table->status=error ? STATUS_NOT_FOUND: 0;
@@ -210,8 +207,7 @@ int ha_myisammrg::index_read_last(byte * buf, const byte * key, uint key_len)
 
 int ha_myisammrg::index_next(byte * buf)
 {
-  statistic_increment(table->in_use->status_var.ha_read_next_count,
+  ha_statistic_increment(&SSV::ha_read_next_count);
-		      &LOCK_status);
   int error=myrg_rnext(file,buf,active_index);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -219,8 +215,7 @@ int ha_myisammrg::index_next(byte * buf)
 
 int ha_myisammrg::index_prev(byte * buf)
 {
-  statistic_increment(table->in_use->status_var.ha_read_prev_count,
+  ha_statistic_increment(&SSV::ha_read_prev_count);
-		      &LOCK_status);
   int error=myrg_rprev(file,buf, active_index);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -228,8 +223,7 @@ int ha_myisammrg::index_prev(byte * buf)
 
 int ha_myisammrg::index_first(byte * buf)
 {
-  statistic_increment(table->in_use->status_var.ha_read_first_count,
+  ha_statistic_increment(&SSV::ha_read_first_count);
-		      &LOCK_status);
   int error=myrg_rfirst(file, buf, active_index);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -237,8 +231,7 @@ int ha_myisammrg::index_first(byte * buf)
 
 int ha_myisammrg::index_last(byte * buf)
 {
-  statistic_increment(table->in_use->status_var.ha_read_last_count,
+  ha_statistic_increment(&SSV::ha_read_last_count);
-		      &LOCK_status);
   int error=myrg_rlast(file, buf, active_index);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -248,8 +241,7 @@ int ha_myisammrg::index_next_same(byte * buf,
                                   const byte *key __attribute__((unused)),
                                   uint length __attribute__((unused)))
 {
-  statistic_increment(table->in_use->status_var.ha_read_next_count,
+  ha_statistic_increment(&SSV::ha_read_next_count);
-		      &LOCK_status);
   int error=myrg_rnext_same(file,buf);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -264,8 +256,7 @@ int ha_myisammrg::rnd_init(bool scan)
 
 int ha_myisammrg::rnd_next(byte *buf)
 {
-  statistic_increment(table->in_use->status_var.ha_read_rnd_next_count,
+  ha_statistic_increment(&SSV::ha_read_rnd_next_count);
-		      &LOCK_status);
   int error=myrg_rrnd(file, buf, HA_OFFSET_ERROR);
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -274,8 +265,7 @@ int ha_myisammrg::rnd_next(byte *buf)
 
 int ha_myisammrg::rnd_pos(byte * buf, byte *pos)
 {
-  statistic_increment(table->in_use->status_var.ha_read_rnd_count,
+  ha_statistic_increment(&SSV::ha_read_rnd_count);
-		      &LOCK_status);
   int error=myrg_rrnd(file, buf, my_get_ptr(pos,ref_length));
   table->status=error ? STATUS_NOT_FOUND: 0;
   return error;
@@ -609,7 +599,6 @@ static int myisammrg_init(void *p)
 
   myisammrg_hton= (handlerton *)p;
 
-  myisammrg_hton->state= SHOW_OPTION_YES;
   myisammrg_hton->db_type= DB_TYPE_MRG_MYISAM;
   myisammrg_hton->create= myisammrg_create_handler;
   myisammrg_hton->panic= myisammrg_panic;