Adding upstream version 1:10.5.12.upstream/1%10.5.12upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 3681 insertions, 0 deletions

diff --git a/storage/spider/spd_param.cc b/storage/spider/spd_param.cc
new file mode 100644
index 00000000..ec0949b5
--- /dev/null
+++ b/storage/spider/spd_param.cc
@@ -0,0 +1,3681 @@
+/* Copyright (C) 2008-2018 Kentoku Shiba
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; version 2 of the License.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#define MYSQL_SERVER 1
+#include <my_global.h>
+#include "mysql_version.h"
+#include "spd_environ.h"
+#if MYSQL_VERSION_ID < 50500
+#include "mysql_priv.h"
+#include <mysql/plugin.h>
+#else
+#include "sql_priv.h"
+#include "probes_mysql.h"
+#include "sql_class.h"
+#include "sql_partition.h"
+#endif
+#include <my_getopt.h>
+#include "spd_err.h"
+#include "spd_db_include.h"
+#include "spd_include.h"
+#include "ha_spider.h"
+#include "spd_table.h"
+#include "spd_trx.h"
+
+extern struct st_mysql_plugin spider_i_s_alloc_mem;
+extern struct st_mysql_plugin spider_i_s_wrapper_protocols;
+#ifdef MARIADB_BASE_VERSION
+extern struct st_maria_plugin spider_i_s_alloc_mem_maria;
+extern struct st_maria_plugin spider_i_s_wrapper_protocols_maria;
+#endif
+
+extern volatile ulonglong spider_mon_table_cache_version;
+extern volatile ulonglong spider_mon_table_cache_version_req;
+
+#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
+static int spider_direct_update(THD *thd, SHOW_VAR *var, char *buff)
+{
+  int error_num = 0;
+  SPIDER_TRX *trx;
+  DBUG_ENTER("spider_direct_update");
+  var->type = SHOW_LONGLONG;
+  if ((trx = spider_get_trx(thd, TRUE, &error_num)))
+    var->value = (char *) &trx->direct_update_count;
+  DBUG_RETURN(error_num);
+}
+
+static int spider_direct_delete(THD *thd, SHOW_VAR *var, char *buff)
+{
+  int error_num = 0;
+  SPIDER_TRX *trx;
+  DBUG_ENTER("spider_direct_delete");
+  var->type = SHOW_LONGLONG;
+  if ((trx = spider_get_trx(thd, TRUE, &error_num)))
+    var->value = (char *) &trx->direct_delete_count;
+  DBUG_RETURN(error_num);
+}
+#endif
+
+static int spider_direct_order_limit(THD *thd, SHOW_VAR *var, char *buff)
+{
+  int error_num = 0;
+  SPIDER_TRX *trx;
+  DBUG_ENTER("spider_direct_order_limit");
+  var->type = SHOW_LONGLONG;
+  if ((trx = spider_get_trx(thd, TRUE, &error_num)))
+    var->value = (char *) &trx->direct_order_limit_count;
+  DBUG_RETURN(error_num);
+}
+
+static int spider_direct_aggregate(THD *thd, SHOW_VAR *var, char *buff)
+{
+  int error_num = 0;
+  SPIDER_TRX *trx;
+  DBUG_ENTER("spider_direct_aggregate");
+  var->type = SHOW_LONGLONG;
+  if ((trx = spider_get_trx(thd, TRUE, &error_num)))
+    var->value = (char *) &trx->direct_aggregate_count;
+  DBUG_RETURN(error_num);
+}
+
+static int spider_parallel_search(THD *thd, SHOW_VAR *var, char *buff)
+{
+  int error_num = 0;
+  SPIDER_TRX *trx;
+  DBUG_ENTER("spider_parallel_search");
+  var->type = SHOW_LONGLONG;
+  if ((trx = spider_get_trx(thd, TRUE, &error_num)))
+    var->value = (char *) &trx->parallel_search_count;
+  DBUG_RETURN(error_num);
+}
+
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+static int spider_hs_result_free(THD *thd, SHOW_VAR *var, char *buff)
+{
+  int error_num = 0;
+  SPIDER_TRX *trx;
+  DBUG_ENTER("spider_hs_result_free");
+  var->type = SHOW_LONGLONG;
+  if ((trx = spider_get_trx(thd, TRUE, &error_num)))
+    var->value = (char *) &trx->hs_result_free_count;
+  DBUG_RETURN(error_num);
+}
+#endif
+
+struct st_mysql_show_var spider_status_variables[] =
+{
+  {"Spider_mon_table_cache_version",
+    (char *) &spider_mon_table_cache_version, SHOW_LONGLONG},
+  {"Spider_mon_table_cache_version_req",
+    (char *) &spider_mon_table_cache_version_req, SHOW_LONGLONG},
+#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
+#ifdef SPIDER_HAS_SHOW_SIMPLE_FUNC
+  {"Spider_direct_update", (char *) &spider_direct_update, SHOW_SIMPLE_FUNC},
+  {"Spider_direct_delete", (char *) &spider_direct_delete, SHOW_SIMPLE_FUNC},
+#else
+  {"Spider_direct_update", (char *) &spider_direct_update, SHOW_FUNC},
+  {"Spider_direct_delete", (char *) &spider_direct_delete, SHOW_FUNC},
+#endif
+#endif
+#ifdef SPIDER_HAS_SHOW_SIMPLE_FUNC
+  {"Spider_direct_order_limit",
+    (char *) &spider_direct_order_limit, SHOW_SIMPLE_FUNC},
+  {"Spider_direct_aggregate",
+    (char *) &spider_direct_aggregate, SHOW_SIMPLE_FUNC},
+  {"Spider_parallel_search",
+    (char *) &spider_parallel_search, SHOW_SIMPLE_FUNC},
+#else
+  {"Spider_direct_order_limit",
+    (char *) &spider_direct_order_limit, SHOW_FUNC},
+  {"Spider_direct_aggregate",
+    (char *) &spider_direct_aggregate, SHOW_FUNC},
+  {"Spider_parallel_search",
+    (char *) &spider_parallel_search, SHOW_FUNC},
+#endif
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+#ifdef SPIDER_HAS_SHOW_SIMPLE_FUNC
+  {"Spider_hs_result_free", (char *) &spider_hs_result_free, SHOW_SIMPLE_FUNC},
+#else
+  {"Spider_hs_result_free", (char *) &spider_hs_result_free, SHOW_FUNC},
+#endif
+#endif
+  {NullS, NullS, SHOW_LONG}
+};
+
+typedef DECLARE_MYSQL_THDVAR_SIMPLE(thdvar_int_t, int);
+#if MYSQL_VERSION_ID < 50500
+extern bool throw_bounds_warning(THD *thd, bool fixed, bool unsignd,
+  const char *name, long long val);
+#else
+extern bool throw_bounds_warning(THD *thd, const char *name, bool fixed,
+  bool is_unsignd, longlong v);
+#endif
+
+static my_bool spider_support_xa;
+static MYSQL_SYSVAR_BOOL(
+  support_xa,
+  spider_support_xa,
+  PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
+  "XA support",
+  NULL,
+  NULL,
+  TRUE
+);
+
+my_bool spider_param_support_xa()
+{
+  DBUG_ENTER("spider_param_support_xa");
+  DBUG_RETURN(spider_support_xa);
+}
+
+static my_bool spider_connect_mutex;
+static MYSQL_SYSVAR_BOOL(
+  connect_mutex,
+  spider_connect_mutex,
+  PLUGIN_VAR_OPCMDARG,
+  "Use mutex at connecting",
+  NULL,
+  NULL,
+  FALSE
+);
+
+my_bool spider_param_connect_mutex()
+{
+  DBUG_ENTER("spider_param_connect_mutex");
+  DBUG_RETURN(spider_connect_mutex);
+}
+
+static uint spider_connect_error_interval;
+/*
+  0-: interval
+ */
+static MYSQL_SYSVAR_UINT(
+  connect_error_interval,
+  spider_connect_error_interval,
+  PLUGIN_VAR_RQCMDARG,
+  "Return same error code until interval passes if connection is failed",
+  NULL,
+  NULL,
+  1,
+  0,
+  4294967295U,
+  0
+);
+
+uint spider_param_connect_error_interval()
+{
+  DBUG_ENTER("spider_param_connect_error_interval");
+  DBUG_RETURN(spider_connect_error_interval);
+}
+
+static uint spider_table_init_error_interval;
+/*
+  0-: interval
+ */
+static MYSQL_SYSVAR_UINT(
+  table_init_error_interval,
+  spider_table_init_error_interval,
+  PLUGIN_VAR_RQCMDARG,
+  "Return same error code until interval passes if table init is failed",
+  NULL,
+  NULL,
+  1,
+  0,
+  4294967295U,
+  0
+);
+
+uint spider_param_table_init_error_interval()
+{
+  DBUG_ENTER("spider_param_table_init_error_interval");
+  DBUG_RETURN(spider_table_init_error_interval);
+}
+
+static int spider_use_table_charset;
+/*
+ -1 :use table parameter
+  0 :use utf8
+  1 :use table charset
+ */
+static MYSQL_SYSVAR_INT(
+  use_table_charset,
+  spider_use_table_charset,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "Use table charset for remote access",
+  NULL,
+  NULL,
+  -1,
+  -1,
+  1,
+  0
+);
+
+int spider_param_use_table_charset(
+  int use_table_charset
+) {
+  DBUG_ENTER("spider_param_use_table_charset");
+  DBUG_RETURN(spider_use_table_charset == -1 ?
+    use_table_charset : spider_use_table_charset);
+}
+
+/*
+  0: no recycle
+  1: recycle in instance
+  2: recycle in thread
+ */
+static MYSQL_THDVAR_UINT(
+  conn_recycle_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Connection recycle mode", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  0, /* def */
+  0, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+uint spider_param_conn_recycle_mode(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_conn_recycle_mode");
+  DBUG_RETURN(THDVAR(thd, conn_recycle_mode));
+}
+
+/*
+  0: weak
+  1: strict
+ */
+static MYSQL_THDVAR_UINT(
+  conn_recycle_strict, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Strict connection recycle", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  0, /* def */
+  0, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+uint spider_param_conn_recycle_strict(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_conn_recycle_strict");
+  DBUG_RETURN(THDVAR(thd, conn_recycle_strict));
+}
+
+/*
+  FALSE: no sync
+  TRUE:  sync
+ */
+static MYSQL_THDVAR_BOOL(
+  sync_trx_isolation, /* name */
+  PLUGIN_VAR_OPCMDARG, /* opt */
+  "Sync transaction isolation level", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  TRUE /* def */
+);
+
+bool spider_param_sync_trx_isolation(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_sync_trx_isolation");
+  DBUG_RETURN(THDVAR(thd, sync_trx_isolation));
+}
+
+/*
+  FALSE: no use
+  TRUE:  use
+ */
+static MYSQL_THDVAR_BOOL(
+  use_consistent_snapshot, /* name */
+  PLUGIN_VAR_OPCMDARG, /* opt */
+  "Use start transaction with consistent snapshot", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  FALSE /* def */
+);
+
+bool spider_param_use_consistent_snapshot(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_use_consistent_snapshot");
+  DBUG_RETURN(THDVAR(thd, use_consistent_snapshot));
+}
+
+/*
+  FALSE: off
+  TRUE:  on
+ */
+static MYSQL_THDVAR_BOOL(
+  internal_xa, /* name */
+  PLUGIN_VAR_OPCMDARG, /* opt */
+  "Use inner xa transaction", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  FALSE /* def */
+);
+
+bool spider_param_internal_xa(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_internal_xa");
+  DBUG_RETURN(THDVAR(thd, internal_xa));
+}
+
+/*
+  0 :err when use a spider table
+  1 :err when start trx
+  2 :start trx with snapshot on remote server(not use xa)
+  3 :start xa on remote server(not use trx with snapshot)
+ */
+static MYSQL_THDVAR_UINT(
+  internal_xa_snapshot, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Action of inner xa and snapshot both using", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  0, /* def */
+  0, /* min */
+  3, /* max */
+  0 /* blk */
+);
+
+uint spider_param_internal_xa_snapshot(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_internal_xa_snapshot");
+  DBUG_RETURN(THDVAR(thd, internal_xa_snapshot));
+}
+
+/*
+  0 :off
+  1 :continue prepare, commit, rollback if xid not found return
+  2 :continue prepare, commit, rollback if all error return
+ */
+static MYSQL_THDVAR_UINT(
+  force_commit, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Force prepare, commit, rollback mode", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  1, /* def */
+  0, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+uint spider_param_force_commit(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_force_commit");
+  DBUG_RETURN(THDVAR(thd, force_commit));
+}
+
+/*
+  0: register all XA transaction
+  1: register only write XA transaction
+ */
+static MYSQL_THDVAR_UINT(
+  xa_register_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Mode of XA transaction register into system table", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  1, /* def */
+  0, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+uint spider_param_xa_register_mode(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_xa_register_mode");
+  DBUG_RETURN(THDVAR(thd, xa_register_mode));
+}
+
+/*
+ -1 :use table parameter
+  0-:offset
+ */
+static MYSQL_THDVAR_LONGLONG(
+  internal_offset, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Internal offset", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  9223372036854775807LL, /* max */
+  0 /* blk */
+);
+
+longlong spider_param_internal_offset(
+  THD *thd,
+  longlong internal_offset
+) {
+  DBUG_ENTER("spider_param_internal_offset");
+  DBUG_RETURN(THDVAR(thd, internal_offset) < 0 ?
+    internal_offset : THDVAR(thd, internal_offset));
+}
+
+/*
+ -1 :use table parameter
+  0-:limit
+ */
+static MYSQL_THDVAR_LONGLONG(
+  internal_limit, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Internal limit", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  9223372036854775807LL, /* max */
+  0 /* blk */
+);
+
+longlong spider_param_internal_limit(
+  THD *thd,
+  longlong internal_limit
+) {
+  DBUG_ENTER("spider_param_internal_limit");
+  DBUG_RETURN(THDVAR(thd, internal_limit) < 0 ?
+    internal_limit : THDVAR(thd, internal_limit));
+}
+
+/*
+ -1 :use table parameter
+  0-:number of rows at a select
+ */
+static MYSQL_THDVAR_LONGLONG(
+  split_read, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Number of rows at a select", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  9223372036854775807LL, /* max */
+  0 /* blk */
+);
+
+longlong spider_param_split_read(
+  THD *thd,
+  longlong split_read
+) {
+  DBUG_ENTER("spider_param_split_read");
+  DBUG_RETURN(THDVAR(thd, split_read) < 0 ?
+    split_read : THDVAR(thd, split_read));
+}
+
+/*
+  -1 :use table parameter
+   0 :doesn't use "offset" and "limit" for "split_read"
+   1-:magnification
+ */
+static MYSQL_THDVAR_INT(
+  semi_split_read, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Use offset and limit parameter in SQL for split_read parameter.", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+double spider_param_semi_split_read(
+  THD *thd,
+  double semi_split_read
+) {
+  DBUG_ENTER("spider_param_semi_split_read");
+  DBUG_RETURN(THDVAR(thd, semi_split_read) < 0 ?
+    semi_split_read : THDVAR(thd, semi_split_read));
+}
+
+/*
+ -1 :use table parameter
+  0-:the limit value
+ */
+static MYSQL_THDVAR_LONGLONG(
+  semi_split_read_limit, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "The limit value for semi_split_read", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  9223372036854775807LL, /* max */
+  0 /* blk */
+);
+
+longlong spider_param_semi_split_read_limit(
+  THD *thd,
+  longlong semi_split_read_limit
+) {
+  DBUG_ENTER("spider_param_semi_split_read_limit");
+  DBUG_RETURN(THDVAR(thd, semi_split_read_limit) < 0 ?
+    semi_split_read_limit : THDVAR(thd, semi_split_read_limit));
+}
+
+/*
+ -1 :use table parameter
+  0 :no alloc
+  1-:alloc size
+ */
+static MYSQL_THDVAR_INT(
+  init_sql_alloc_size, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Initial sql string alloc size", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+int spider_param_init_sql_alloc_size(
+  THD *thd,
+  int init_sql_alloc_size
+) {
+  DBUG_ENTER("spider_param_init_sql_alloc_size");
+  DBUG_RETURN(THDVAR(thd, init_sql_alloc_size) < 0 ?
+    init_sql_alloc_size : THDVAR(thd, init_sql_alloc_size));
+}
+
+/*
+ -1 :use table parameter
+  0 :off
+  1 :on
+ */
+static MYSQL_THDVAR_INT(
+  reset_sql_alloc, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Reset sql string alloc after execute", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_reset_sql_alloc(
+  THD *thd,
+  int reset_sql_alloc
+) {
+  DBUG_ENTER("spider_param_reset_sql_alloc");
+  DBUG_RETURN(THDVAR(thd, reset_sql_alloc) < 0 ?
+    reset_sql_alloc : THDVAR(thd, reset_sql_alloc));
+}
+
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+/*
+ -1 :use table parameter
+  0-:result free size for handlersocket
+ */
+static MYSQL_THDVAR_LONGLONG(
+  hs_result_free_size, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Result free size for handlersocket", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  9223372036854775807LL, /* max */
+  0 /* blk */
+);
+
+longlong spider_param_hs_result_free_size(
+  THD *thd,
+  longlong hs_result_free_size
+) {
+  DBUG_ENTER("spider_param_hs_result_free_size");
+  DBUG_RETURN(THDVAR(thd, hs_result_free_size) < 0 ?
+    hs_result_free_size : THDVAR(thd, hs_result_free_size));
+}
+#endif
+
+/*
+ -1 :use table parameter
+  0 :off
+  1 :on
+ */
+static MYSQL_THDVAR_INT(
+  multi_split_read, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Sprit read mode for multi range", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+int spider_param_multi_split_read(
+  THD *thd,
+  int multi_split_read
+) {
+  DBUG_ENTER("spider_param_multi_split_read");
+  DBUG_RETURN(THDVAR(thd, multi_split_read) < 0 ?
+    multi_split_read : THDVAR(thd, multi_split_read));
+}
+
+/*
+ -1 :use table parameter
+  0-:max order columns
+ */
+static MYSQL_THDVAR_INT(
+  max_order, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Max columns for order by", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  32767, /* max */
+  0 /* blk */
+);
+
+int spider_param_max_order(
+  THD *thd,
+  int max_order
+) {
+  DBUG_ENTER("spider_param_max_order");
+  DBUG_RETURN(THDVAR(thd, max_order) < 0 ?
+    max_order : THDVAR(thd, max_order));
+}
+
+/*
+ -1 :off
+  0 :read uncommitted
+  1 :read committed
+  2 :repeatable read
+  3 :serializable
+ */
+static MYSQL_THDVAR_INT(
+  semi_trx_isolation, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Transaction isolation level during execute a sql", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  3, /* max */
+  0 /* blk */
+);
+
+int spider_param_semi_trx_isolation(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_semi_trx_isolation");
+  DBUG_RETURN(THDVAR(thd, semi_trx_isolation));
+}
+
+static int spider_param_semi_table_lock_check(
+  MYSQL_THD thd,
+  struct st_mysql_sys_var *var,
+  void *save,
+  struct st_mysql_value *value
+) {
+  int error_num;
+  SPIDER_TRX *trx;
+  my_bool fixed;
+  long long tmp;
+  struct my_option options;
+  DBUG_ENTER("spider_param_semi_table_lock_check");
+  if (!(trx = spider_get_trx((THD *) thd, TRUE, &error_num)))
+    DBUG_RETURN(error_num);
+  if (trx->locked_connections)
+  {
+    my_message(ER_SPIDER_ALTER_BEFORE_UNLOCK_NUM,
+      ER_SPIDER_ALTER_BEFORE_UNLOCK_STR, MYF(0));
+    DBUG_RETURN(ER_SPIDER_ALTER_BEFORE_UNLOCK_NUM);
+  }
+  value->val_int(value, &tmp);
+  options.sub_size = 0;
+  options.var_type = GET_INT;
+  options.def_value = ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->def_val;
+  options.min_value = ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->min_val;
+  options.max_value = ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->max_val;
+  options.block_size =
+    (long) ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->blk_sz;
+  options.arg_type = REQUIRED_ARG;
+  *((int *) save) = (int) getopt_ll_limit_value(tmp, &options, &fixed);
+#if MYSQL_VERSION_ID < 50500
+  DBUG_RETURN(throw_bounds_warning(thd, fixed, FALSE,
+    ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->name, (long long) tmp));
+#else
+  DBUG_RETURN(throw_bounds_warning(thd,
+    ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->name, fixed, FALSE,
+    (longlong) tmp));
+#endif
+}
+
+/*
+  0 :off
+  1 :on
+ */
+static MYSQL_THDVAR_INT(
+  semi_table_lock, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Table lock during execute a sql", /* comment */
+  &spider_param_semi_table_lock_check, /* check */
+  NULL, /* update */
+  1, /* def */
+  0, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_semi_table_lock(
+  THD *thd,
+  int semi_table_lock
+) {
+  DBUG_ENTER("spider_param_semi_table_lock");
+  DBUG_RETURN((semi_table_lock & THDVAR(thd, semi_table_lock)));
+}
+
+static int spider_param_semi_table_lock_connection_check(
+  MYSQL_THD thd,
+  struct st_mysql_sys_var *var,
+  void *save,
+  struct st_mysql_value *value
+) {
+  int error_num;
+  SPIDER_TRX *trx;
+  my_bool fixed;
+  long long tmp;
+  struct my_option options;
+  DBUG_ENTER("spider_param_semi_table_lock_connection_check");
+  if (!(trx = spider_get_trx((THD *) thd, TRUE, &error_num)))
+    DBUG_RETURN(error_num);
+  if (trx->locked_connections)
+  {
+    my_message(ER_SPIDER_ALTER_BEFORE_UNLOCK_NUM,
+      ER_SPIDER_ALTER_BEFORE_UNLOCK_STR, MYF(0));
+    DBUG_RETURN(ER_SPIDER_ALTER_BEFORE_UNLOCK_NUM);
+  }
+  value->val_int(value, &tmp);
+  options.sub_size = 0;
+  options.var_type = GET_INT;
+  options.def_value = ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->def_val;
+  options.min_value = ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->min_val;
+  options.max_value = ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->max_val;
+  options.block_size =
+    (long) ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->blk_sz;
+  options.arg_type = REQUIRED_ARG;
+  *((int *) save) = (int) getopt_ll_limit_value(tmp, &options, &fixed);
+#if MYSQL_VERSION_ID < 50500
+  DBUG_RETURN(throw_bounds_warning(thd, fixed, FALSE,
+    ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->name, (long long) tmp));
+#else
+  DBUG_RETURN(throw_bounds_warning(thd,
+    ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->name, fixed, FALSE,
+    (longlong) tmp));
+#endif
+}
+
+/*
+ -1 :off
+  0 :use same connection
+  1 :use different connection
+ */
+static MYSQL_THDVAR_INT(
+  semi_table_lock_connection, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Use different connection if semi_table_lock is enabled", /* comment */
+  &spider_param_semi_table_lock_connection_check, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_semi_table_lock_connection(
+  THD *thd,
+  int semi_table_lock_connection
+) {
+  DBUG_ENTER("spider_param_semi_table_lock_connection");
+  DBUG_RETURN(THDVAR(thd, semi_table_lock_connection) == -1 ?
+    semi_table_lock_connection : THDVAR(thd, semi_table_lock_connection));
+}
+
+/*
+  0-:block_size
+ */
+static MYSQL_THDVAR_UINT(
+  block_size, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Index block size", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  16384, /* def */
+  0, /* min */
+  4294967295U, /* max */
+  0 /* blk */
+);
+
+uint spider_param_block_size(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_block_size");
+  DBUG_RETURN(THDVAR(thd, block_size));
+}
+
+/*
+ -1 :use table parameter
+  0 :off
+  1 :lock in share mode
+  2 :for update
+ */
+static MYSQL_THDVAR_INT(
+  selupd_lock_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Lock for select with update", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+int spider_param_selupd_lock_mode(
+  THD *thd,
+  int selupd_lock_mode
+) {
+  DBUG_ENTER("spider_param_selupd_lock_mode");
+  DBUG_RETURN(THDVAR(thd, selupd_lock_mode) == -1 ?
+    selupd_lock_mode : THDVAR(thd, selupd_lock_mode));
+}
+
+/*
+  FALSE: no sync
+  TRUE:  sync
+ */
+static MYSQL_THDVAR_BOOL(
+  sync_autocommit, /* name */
+  PLUGIN_VAR_OPCMDARG, /* opt */
+  "Sync autocommit", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  TRUE /* def */
+);
+
+bool spider_param_sync_autocommit(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_sync_autocommit");
+  DBUG_RETURN(THDVAR(thd, sync_autocommit));
+}
+
+/*
+  FALSE: not use
+  TRUE:  use
+ */
+static MYSQL_THDVAR_BOOL(
+  use_default_database, /* name */
+  PLUGIN_VAR_OPCMDARG, /* opt */
+  "Use default database", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  TRUE /* def */
+);
+
+bool spider_param_use_default_database(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_use_default_database");
+  DBUG_RETURN(THDVAR(thd, use_default_database));
+}
+
+/*
+-1 :don't know or does not matter; don't send 'SET SQL_LOG_OFF' statement
+ 0 :do send 'SET SQL_LOG_OFF 0' statement to data nodes
+ 1 :do send 'SET SQL_LOG_OFF 1' statement to data nodes
+*/
+static MYSQL_THDVAR_INT(
+  internal_sql_log_off,                                  /* name */
+  PLUGIN_VAR_RQCMDARG,                                   /* opt */
+  "Manage SQL_LOG_OFF mode statement to the data nodes", /* comment */
+  NULL,                                                  /* check */
+  NULL,                                                  /* update */
+  -1,                                                    /* default */
+  -1,                                                    /* min */
+  1,                                                     /* max */
+  0                                                      /* blk */
+);
+
+int spider_param_internal_sql_log_off(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_internal_sql_log_off");
+  DBUG_RETURN(THDVAR(thd, internal_sql_log_off));
+}
+
+/*
+ -1 :use table parameter
+  0-:bulk insert size
+ */
+static MYSQL_THDVAR_INT(
+  bulk_size, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Bulk insert size", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+int spider_param_bulk_size(
+  THD *thd,
+  int bulk_size
+) {
+  DBUG_ENTER("spider_param_bulk_size");
+  DBUG_RETURN(THDVAR(thd, bulk_size) < 0 ?
+    bulk_size : THDVAR(thd, bulk_size));
+}
+
+/*
+ -1 :use table parameter
+  0 : Send "update" and "delete" statements one by one.
+  1 : Send collected multiple "update" and "delete" statements.
+      (Collected statements are sent one by one)
+  2 : Send collected multiple "update" and "delete" statements.
+      (Collected statements are sent together)
+ */
+static MYSQL_THDVAR_INT(
+  bulk_update_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "The mode of bulk updating and deleting", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+int spider_param_bulk_update_mode(
+  THD *thd,
+  int bulk_update_mode
+) {
+  DBUG_ENTER("spider_param_bulk_update_mode");
+  DBUG_RETURN(THDVAR(thd, bulk_update_mode) == -1 ?
+    bulk_update_mode : THDVAR(thd, bulk_update_mode));
+}
+
+/*
+ -1 :use table parameter
+  0-:bulk update size
+ */
+static MYSQL_THDVAR_INT(
+  bulk_update_size, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Bulk update size", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+int spider_param_bulk_update_size(
+  THD *thd,
+  int bulk_update_size
+) {
+  DBUG_ENTER("spider_param_bulk_update_size");
+  DBUG_RETURN(THDVAR(thd, bulk_update_size) == -1 ?
+    bulk_update_size : THDVAR(thd, bulk_update_size));
+}
+
+/*
+ -1 :use table parameter
+  0-:buffer size
+ */
+static MYSQL_THDVAR_INT(
+  buffer_size, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Buffer size", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+int spider_param_buffer_size(
+  THD *thd,
+  int buffer_size
+) {
+  DBUG_ENTER("spider_param_buffer_size");
+  DBUG_RETURN(THDVAR(thd, buffer_size) == -1 ?
+    buffer_size : THDVAR(thd, buffer_size));
+}
+
+/*
+ -1 :use table parameter
+  0 :off
+  1 :on
+ */
+static MYSQL_THDVAR_INT(
+  internal_optimize, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Execute optimize to remote server", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_internal_optimize(
+  THD *thd,
+  int internal_optimize
+) {
+  DBUG_ENTER("spider_param_internal_optimize");
+  DBUG_RETURN(THDVAR(thd, internal_optimize) == -1 ?
+    internal_optimize : THDVAR(thd, internal_optimize));
+}
+
+/*
+ -1 :use table parameter
+  0 :off
+  1 :on
+ */
+static MYSQL_THDVAR_INT(
+  internal_optimize_local, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Execute optimize to remote server with local", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_internal_optimize_local(
+  THD *thd,
+  int internal_optimize_local
+) {
+  DBUG_ENTER("spider_param_internal_optimize_local");
+  DBUG_RETURN(THDVAR(thd, internal_optimize_local) == -1 ?
+    internal_optimize_local : THDVAR(thd, internal_optimize_local));
+}
+
+/*
+  FALSE: off
+  TRUE:  on
+ */
+static MYSQL_THDVAR_BOOL(
+  use_flash_logs, /* name */
+  PLUGIN_VAR_OPCMDARG, /* opt */
+  "Execute flush logs to remote server", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  FALSE /* def */
+);
+
+bool spider_param_use_flash_logs(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_use_flash_logs");
+  DBUG_RETURN(THDVAR(thd, use_flash_logs));
+}
+
+/*
+  0 :off
+  1 :flush tables with read lock
+  2 :flush tables another connection
+ */
+static MYSQL_THDVAR_INT(
+  use_snapshot_with_flush_tables, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Execute optimize to remote server with local", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  0, /* def */
+  0, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+int spider_param_use_snapshot_with_flush_tables(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_use_snapshot_with_flush_tables");
+  DBUG_RETURN(THDVAR(thd, use_snapshot_with_flush_tables));
+}
+
+/*
+  FALSE: off
+  TRUE:  on
+ */
+static MYSQL_THDVAR_BOOL(
+  use_all_conns_snapshot, /* name */
+  PLUGIN_VAR_OPCMDARG, /* opt */
+  "When start trx with snapshot, it send to all connections", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  FALSE /* def */
+);
+
+bool spider_param_use_all_conns_snapshot(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_use_all_conns_snapshot");
+  DBUG_RETURN(THDVAR(thd, use_all_conns_snapshot));
+}
+
+/*
+  FALSE: off
+  TRUE:  on
+ */
+static MYSQL_THDVAR_BOOL(
+  lock_exchange, /* name */
+  PLUGIN_VAR_OPCMDARG, /* opt */
+  "Exchange select lock to lock tables", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  FALSE /* def */
+);
+
+bool spider_param_lock_exchange(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_lock_exchange");
+  DBUG_RETURN(THDVAR(thd, lock_exchange));
+}
+
+/*
+  FALSE: off
+  TRUE:  on
+ */
+static MYSQL_THDVAR_BOOL(
+  internal_unlock, /* name */
+  PLUGIN_VAR_OPCMDARG, /* opt */
+  "Unlock tables for using connections in sql", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  FALSE /* def */
+);
+
+bool spider_param_internal_unlock(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_internal_unlock");
+  DBUG_RETURN(THDVAR(thd, internal_unlock));
+}
+
+/*
+  FALSE: off
+  TRUE:  on
+ */
+static MYSQL_THDVAR_BOOL(
+  semi_trx, /* name */
+  PLUGIN_VAR_OPCMDARG, /* opt */
+  "Take a transaction during execute a sql", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  TRUE /* def */
+);
+
+bool spider_param_semi_trx(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_semi_trx");
+  DBUG_RETURN(THDVAR(thd, semi_trx));
+}
+
+/*
+ -1 :use table parameter
+  0-:seconds of timeout
+ */
+static MYSQL_THDVAR_INT(
+  connect_timeout, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Wait timeout of connecting to remote server", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+int spider_param_connect_timeout(
+  THD *thd,
+  int connect_timeout
+) {
+  DBUG_ENTER("spider_param_connect_timeout");
+  if (thd)
+    DBUG_RETURN(THDVAR(thd, connect_timeout) == -1 ?
+      connect_timeout : THDVAR(thd, connect_timeout));
+  DBUG_RETURN(connect_timeout);
+}
+
+/*
+ -1 :use table parameter
+  0-:seconds of timeout
+ */
+static MYSQL_THDVAR_INT(
+  net_read_timeout, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Wait timeout of receiving data from remote server", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+int spider_param_net_read_timeout(
+  THD *thd,
+  int net_read_timeout
+) {
+  DBUG_ENTER("spider_param_net_read_timeout");
+  if (thd)
+    DBUG_RETURN(THDVAR(thd, net_read_timeout) == -1 ?
+      net_read_timeout : THDVAR(thd, net_read_timeout));
+  DBUG_RETURN(net_read_timeout);
+}
+
+/*
+ -1 :use table parameter
+  0-:seconds of timeout
+ */
+static MYSQL_THDVAR_INT(
+  net_write_timeout, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Wait timeout of sending data to remote server", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+int spider_param_net_write_timeout(
+  THD *thd,
+  int net_write_timeout
+) {
+  DBUG_ENTER("spider_param_net_write_timeout");
+  if (thd)
+    DBUG_RETURN(THDVAR(thd, net_write_timeout) == -1 ?
+      net_write_timeout : THDVAR(thd, net_write_timeout));
+  DBUG_RETURN(net_write_timeout);
+}
+
+/*
+ -1 :use table parameter
+  0 :It acquires it collectively.
+  1 :Acquisition one by one.If it discontinues once, and it will need
+     it later, it retrieves it again when there is interrupt on the way.
+  2 :Acquisition one by one.Interrupt is waited for until end of getting
+     result when there is interrupt on the way.
+ */
+static MYSQL_THDVAR_INT(
+  quick_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "The retrieval result from a remote server is acquired by acquisition one by one", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  3, /* max */
+  0 /* blk */
+);
+
+int spider_param_quick_mode(
+  THD *thd,
+  int quick_mode
+) {
+  DBUG_ENTER("spider_param_quick_mode");
+  DBUG_RETURN(THDVAR(thd, quick_mode) < 0 ?
+    quick_mode : THDVAR(thd, quick_mode));
+}
+
+/*
+ -1 :use table parameter
+  0-:number of records
+ */
+static MYSQL_THDVAR_LONGLONG(
+  quick_page_size, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Number of records in a page when acquisition one by one", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  9223372036854775807LL, /* max */
+  0 /* blk */
+);
+
+longlong spider_param_quick_page_size(
+  THD *thd,
+  longlong quick_page_size
+) {
+  DBUG_ENTER("spider_param_quick_page_size");
+  DBUG_RETURN(THDVAR(thd, quick_page_size) < 0 ?
+    quick_page_size : THDVAR(thd, quick_page_size));
+}
+
+/*
+ -1 :use table parameter
+  0-:the limitation of memory size
+ */
+static MYSQL_THDVAR_LONGLONG(
+  quick_page_byte, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "The limitation of memory size in a page when acquisition one by one", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  9223372036854775807LL, /* max */
+  0 /* blk */
+);
+
+longlong spider_param_quick_page_byte(
+  THD *thd,
+  longlong quick_page_byte
+) {
+  DBUG_ENTER("spider_param_quick_page_byte");
+  DBUG_RETURN(THDVAR(thd, quick_page_byte) < 0 ?
+    quick_page_byte : THDVAR(thd, quick_page_byte));
+}
+
+/*
+ -1 :use table parameter
+  0 :It doesn't use low memory mode.
+  1 :It uses low memory mode.
+ */
+static MYSQL_THDVAR_INT(
+  low_mem_read, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Use low memory mode when SQL(SELECT) internally issued to a remote server is executed and get a result list", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_low_mem_read(
+  THD *thd,
+  int low_mem_read
+) {
+  DBUG_ENTER("spider_param_low_mem_read");
+  DBUG_RETURN(THDVAR(thd, low_mem_read) < 0 ?
+    low_mem_read : THDVAR(thd, low_mem_read));
+}
+
+/*
+ -1 :use table parameter
+  0 :Use index columns if select statement can solve by using index,
+     otherwise use all columns.
+  1 :Use columns that are judged necessary.
+ */
+static MYSQL_THDVAR_INT(
+  select_column_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "The mode of using columns at select clause", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_select_column_mode(
+  THD *thd,
+  int select_column_mode
+) {
+  DBUG_ENTER("spider_param_select_column_mode");
+  DBUG_RETURN(THDVAR(thd, select_column_mode) == -1 ?
+    select_column_mode : THDVAR(thd, select_column_mode));
+}
+
+#ifndef WITHOUT_SPIDER_BG_SEARCH
+/*
+ -1 :use table parameter
+  0 :background search is disabled
+  1 :background search is used if search with no lock
+  2 :background search is used if search with no lock or shared lock
+  3 :background search is used regardless of the lock
+ */
+static MYSQL_THDVAR_INT(
+  bgs_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Mode of background search", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  3, /* max */
+  0 /* blk */
+);
+
+int spider_param_bgs_mode(
+  THD *thd,
+  int bgs_mode
+) {
+  DBUG_ENTER("spider_param_bgs_mode");
+  DBUG_RETURN(THDVAR(thd, bgs_mode) < 0 ?
+    bgs_mode : THDVAR(thd, bgs_mode));
+}
+
+/*
+ -1 :use table parameter
+  0 :records is gotten usually
+  1-:number of records
+ */
+static MYSQL_THDVAR_LONGLONG(
+  bgs_first_read, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Number of first read records when background search is used", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  9223372036854775807LL, /* max */
+  0 /* blk */
+);
+
+longlong spider_param_bgs_first_read(
+  THD *thd,
+  longlong bgs_first_read
+) {
+  DBUG_ENTER("spider_param_bgs_first_read");
+  DBUG_RETURN(THDVAR(thd, bgs_first_read) < 0 ?
+    bgs_first_read : THDVAR(thd, bgs_first_read));
+}
+
+/*
+ -1 :use table parameter
+  0 :records is gotten usually
+  1-:number of records
+ */
+static MYSQL_THDVAR_LONGLONG(
+  bgs_second_read, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Number of second read records when background search is used", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  9223372036854775807LL, /* max */
+  0 /* blk */
+);
+
+longlong spider_param_bgs_second_read(
+  THD *thd,
+  longlong bgs_second_read
+) {
+  DBUG_ENTER("spider_param_bgs_second_read");
+  DBUG_RETURN(THDVAR(thd, bgs_second_read) < 0 ?
+    bgs_second_read : THDVAR(thd, bgs_second_read));
+}
+#endif
+
+/*
+ -1 :use table parameter
+  0 :records is gotten usually
+  1-:number of records
+ */
+static MYSQL_THDVAR_LONGLONG(
+  first_read, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Number of first read records", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  9223372036854775807LL, /* max */
+  0 /* blk */
+);
+
+longlong spider_param_first_read(
+  THD *thd,
+  longlong first_read
+) {
+  DBUG_ENTER("spider_param_first_read");
+  DBUG_RETURN(THDVAR(thd, first_read) < 0 ?
+    first_read : THDVAR(thd, first_read));
+}
+
+/*
+ -1 :use table parameter
+  0 :records is gotten usually
+  1-:number of records
+ */
+static MYSQL_THDVAR_LONGLONG(
+  second_read, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Number of second read records", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  9223372036854775807LL, /* max */
+  0 /* blk */
+);
+
+longlong spider_param_second_read(
+  THD *thd,
+  longlong second_read
+) {
+  DBUG_ENTER("spider_param_second_read");
+  DBUG_RETURN(THDVAR(thd, second_read) < 0 ?
+    second_read : THDVAR(thd, second_read));
+}
+
+/*
+ -1 :use table parameter
+  0 :always get the newest information
+  1-:interval
+ */
+static MYSQL_THDVAR_INT(
+  crd_interval, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Interval of cardinality confirmation.(second)", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+double spider_param_crd_interval(
+  THD *thd,
+  double crd_interval
+) {
+  DBUG_ENTER("spider_param_crd_interval");
+  DBUG_RETURN(THDVAR(thd, crd_interval) == -1 ?
+    crd_interval : THDVAR(thd, crd_interval));
+}
+
+/*
+ -1 :use table parameter
+  0 :use table parameter
+  1 :use show command
+  2 :use information schema
+  3 :use explain
+ */
+static MYSQL_THDVAR_INT(
+  crd_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Mode of cardinality confirmation.", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  3, /* max */
+  0 /* blk */
+);
+
+int spider_param_crd_mode(
+  THD *thd,
+  int crd_mode
+) {
+  DBUG_ENTER("spider_param_crd_mode");
+  DBUG_RETURN(THDVAR(thd, crd_mode) <= 0 ?
+    crd_mode : THDVAR(thd, crd_mode));
+}
+
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+/*
+ -1 :use table parameter
+  0 :No synchronization.
+  1 :Cardinality is synchronized when opening a table.
+     Then no synchronization.
+  2 :Synchronization.
+ */
+static MYSQL_THDVAR_INT(
+  crd_sync, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Cardinality synchronization in partitioned table.", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+int spider_param_crd_sync(
+  THD *thd,
+  int crd_sync
+) {
+  DBUG_ENTER("spider_param_crd_sync");
+  DBUG_RETURN(THDVAR(thd, crd_sync) == -1 ?
+    crd_sync : THDVAR(thd, crd_sync));
+}
+#endif
+
+/*
+ -1 :use table parameter
+  0 :The crd_weight is used as a fixed value.
+  1 :The crd_weight is used as an addition value.
+  2 :The crd_weight is used as a multiplication value.
+ */
+static MYSQL_THDVAR_INT(
+  crd_type, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Type of cardinality calculation.", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+int spider_param_crd_type(
+  THD *thd,
+  int crd_type
+) {
+  DBUG_ENTER("spider_param_crd_type");
+  DBUG_RETURN(THDVAR(thd, crd_type) == -1 ?
+    crd_type : THDVAR(thd, crd_type));
+}
+
+/*
+ -1 :use table parameter
+  0-:weight
+ */
+static MYSQL_THDVAR_INT(
+  crd_weight, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Weight coefficient to calculate effectiveness of index from cardinality of column.", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+double spider_param_crd_weight(
+  THD *thd,
+  double crd_weight
+) {
+  DBUG_ENTER("spider_param_crd_weight");
+  DBUG_RETURN(THDVAR(thd, crd_weight) == -1 ?
+    crd_weight : THDVAR(thd, crd_weight));
+}
+
+#ifndef WITHOUT_SPIDER_BG_SEARCH
+/*
+ -1 :use table parameter
+  0 :Background confirmation is disabled
+  1 :Background confirmation is enabled (create thread per table/partition)
+  2 :Background confirmation is enabled (use static threads)
+ */
+static MYSQL_THDVAR_INT(
+  crd_bg_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Mode of cardinality confirmation at background.", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+int spider_param_crd_bg_mode(
+  THD *thd,
+  int crd_bg_mode
+) {
+  DBUG_ENTER("spider_param_crd_bg_mode");
+  DBUG_RETURN(THDVAR(thd, crd_bg_mode) == -1 ?
+    crd_bg_mode : THDVAR(thd, crd_bg_mode));
+}
+#endif
+
+/*
+ -1 :use table parameter
+  0 :always get the newest information
+  1-:interval
+ */
+static MYSQL_THDVAR_INT(
+  sts_interval, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Interval of table state confirmation.(second)", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+double spider_param_sts_interval(
+  THD *thd,
+  double sts_interval
+) {
+  DBUG_ENTER("spider_param_sts_interval");
+  DBUG_RETURN(THDVAR(thd, sts_interval) == -1 ?
+    sts_interval : THDVAR(thd, sts_interval));
+}
+
+/*
+ -1 :use table parameter
+  0 :use table parameter
+  1 :use show command
+  2 :use information schema
+ */
+static MYSQL_THDVAR_INT(
+  sts_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Mode of table state confirmation.", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+int spider_param_sts_mode(
+  THD *thd,
+  int sts_mode
+) {
+  DBUG_ENTER("spider_param_sts_mode");
+  DBUG_RETURN(THDVAR(thd, sts_mode) <= 0 ?
+    sts_mode : THDVAR(thd, sts_mode));
+}
+
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+/*
+ -1 :use table parameter
+  0 :No synchronization.
+  1 :Table state is synchronized when opening a table.
+     Then no synchronization.
+  2 :Synchronization.
+ */
+static MYSQL_THDVAR_INT(
+  sts_sync, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Table state synchronization in partitioned table.", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+int spider_param_sts_sync(
+  THD *thd,
+  int sts_sync
+) {
+  DBUG_ENTER("spider_param_sts_sync");
+  DBUG_RETURN(THDVAR(thd, sts_sync) == -1 ?
+    sts_sync : THDVAR(thd, sts_sync));
+}
+#endif
+
+#ifndef WITHOUT_SPIDER_BG_SEARCH
+/*
+ -1 :use table parameter
+  0 :Background confirmation is disabled
+  1 :Background confirmation is enabled (create thread per table/partition)
+  2 :Background confirmation is enabled (use static threads)
+ */
+static MYSQL_THDVAR_INT(
+  sts_bg_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Mode of table state confirmation at background.", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+int spider_param_sts_bg_mode(
+  THD *thd,
+  int sts_bg_mode
+) {
+  DBUG_ENTER("spider_param_sts_bg_mode");
+  DBUG_RETURN(THDVAR(thd, sts_bg_mode) == -1 ?
+    sts_bg_mode : THDVAR(thd, sts_bg_mode));
+}
+#endif
+
+/*
+  0 :always ping
+  1-:interval
+ */
+static MYSQL_THDVAR_INT(
+  ping_interval_at_trx_start, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Ping interval at transaction start", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  3600, /* def */
+  0, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+double spider_param_ping_interval_at_trx_start(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_ping_interval_at_trx_start");
+  DBUG_RETURN(THDVAR(thd, ping_interval_at_trx_start));
+}
+
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+/*
+  0 :always ping
+  1-:interval
+ */
+static MYSQL_THDVAR_INT(
+  hs_ping_interval, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Ping interval for handlersocket", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  30, /* def */
+  0, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+double spider_param_hs_ping_interval(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_hs_ping_interval");
+  DBUG_RETURN(THDVAR(thd, hs_ping_interval));
+}
+#endif
+
+/*
+ -1 :use table parameter
+  0 :normal mode
+  1 :quick mode
+  2 :set 0 value
+ */
+static MYSQL_THDVAR_INT(
+  auto_increment_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Mode of auto increment.", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  3, /* max */
+  0 /* blk */
+);
+
+int spider_param_auto_increment_mode(
+  THD *thd,
+  int auto_increment_mode
+) {
+  DBUG_ENTER("spider_param_auto_increment_mode");
+  DBUG_RETURN(THDVAR(thd, auto_increment_mode) == -1 ?
+    auto_increment_mode : THDVAR(thd, auto_increment_mode));
+}
+
+/*
+  FALSE: off
+  TRUE:  on
+ */
+static MYSQL_THDVAR_BOOL(
+  same_server_link, /* name */
+  PLUGIN_VAR_OPCMDARG, /* opt */
+  "Permit one to link same server's table", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  FALSE /* def */
+);
+
+bool spider_param_same_server_link(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_same_server_link");
+  DBUG_RETURN(THDVAR(thd, same_server_link));
+}
+
+/*
+  FALSE: transmits
+  TRUE:  don't transmit
+ */
+static MYSQL_THDVAR_BOOL(
+  local_lock_table, /* name */
+  PLUGIN_VAR_OPCMDARG, /* opt */
+  "Remote server transmission when lock tables is executed at local",
+    /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  FALSE /* def */
+);
+
+bool spider_param_local_lock_table(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_local_lock_table");
+  DBUG_RETURN(THDVAR(thd, local_lock_table));
+}
+
+/*
+ -1 :use table parameter
+  0 :don't transmit
+  1 :transmits
+ */
+static MYSQL_THDVAR_INT(
+  use_pushdown_udf, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Remote server transmission existence when UDF is used at condition and \"engine_condition_pushdown=1\"", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_use_pushdown_udf(
+  THD *thd,
+  int use_pushdown_udf
+) {
+  DBUG_ENTER("spider_param_use_pushdown_udf");
+  DBUG_RETURN(THDVAR(thd, use_pushdown_udf) == -1 ?
+    use_pushdown_udf : THDVAR(thd, use_pushdown_udf));
+}
+
+/*
+ -1 :use table parameter
+  0 :duplicate check on local server
+  1 :avoid duplicate check on local server
+ */
+static MYSQL_THDVAR_INT(
+  direct_dup_insert, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Execute \"REPLACE\" and \"INSERT IGNORE\" on remote server and avoid duplicate check on local server", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_direct_dup_insert(
+  THD *thd,
+  int direct_dup_insert
+) {
+  DBUG_ENTER("spider_param_direct_dup_insert");
+  DBUG_RETURN(THDVAR(thd, direct_dup_insert) < 0 ?
+    direct_dup_insert : THDVAR(thd, direct_dup_insert));
+}
+
+static uint spider_udf_table_lock_mutex_count;
+/*
+  1-: mutex count
+ */
+static MYSQL_SYSVAR_UINT(
+  udf_table_lock_mutex_count,
+  spider_udf_table_lock_mutex_count,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "Mutex count of table lock for Spider UDFs",
+  NULL,
+  NULL,
+  20,
+  1,
+  4294967295U,
+  0
+);
+
+uint spider_param_udf_table_lock_mutex_count()
+{
+  DBUG_ENTER("spider_param_udf_table_lock_mutex_count");
+  DBUG_RETURN(spider_udf_table_lock_mutex_count);
+}
+
+static uint spider_udf_table_mon_mutex_count;
+/*
+  1-: mutex count
+ */
+static MYSQL_SYSVAR_UINT(
+  udf_table_mon_mutex_count,
+  spider_udf_table_mon_mutex_count,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "Mutex count of table mon for Spider UDFs",
+  NULL,
+  NULL,
+  20,
+  1,
+  4294967295U,
+  0
+);
+
+uint spider_param_udf_table_mon_mutex_count()
+{
+  DBUG_ENTER("spider_param_udf_table_mon_mutex_count");
+  DBUG_RETURN(spider_udf_table_mon_mutex_count);
+}
+
+/*
+  1-:number of rows
+ */
+static MYSQL_THDVAR_LONGLONG(
+  udf_ds_bulk_insert_rows, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Number of rows for bulk inserting", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  9223372036854775807LL, /* max */
+  0 /* blk */
+);
+
+longlong spider_param_udf_ds_bulk_insert_rows(
+  THD *thd,
+  longlong udf_ds_bulk_insert_rows
+) {
+  DBUG_ENTER("spider_param_udf_ds_bulk_insert_rows");
+  DBUG_RETURN(THDVAR(thd, udf_ds_bulk_insert_rows) <= 0 ?
+    udf_ds_bulk_insert_rows : THDVAR(thd, udf_ds_bulk_insert_rows));
+}
+
+/*
+ -1 :use table parameter
+  0 :drop records
+  1 :insert last table
+  2 :insert first table and loop again
+ */
+static MYSQL_THDVAR_INT(
+  udf_ds_table_loop_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Table loop mode if the number of tables in table list are less than the number of result sets", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+int spider_param_udf_ds_table_loop_mode(
+  THD *thd,
+  int udf_ds_table_loop_mode
+) {
+  DBUG_ENTER("spider_param_udf_ds_table_loop_mode");
+  DBUG_RETURN(THDVAR(thd, udf_ds_table_loop_mode) == -1 ?
+    udf_ds_table_loop_mode : THDVAR(thd, udf_ds_table_loop_mode));
+}
+
+static char *spider_remote_access_charset;
+/*
+ */
+#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000
+static MYSQL_SYSVAR_STR(
+  remote_access_charset,
+  spider_remote_access_charset,
+  PLUGIN_VAR_MEMALLOC |
+  PLUGIN_VAR_RQCMDARG,
+  "Set remote access charset at connecting for improvement performance of connection if you know",
+  NULL,
+  NULL,
+  NULL
+);
+#else
+#ifdef PLUGIN_VAR_CAN_MEMALLOC
+static MYSQL_SYSVAR_STR(
+  remote_access_charset,
+  spider_remote_access_charset,
+  PLUGIN_VAR_MEMALLOC |
+  PLUGIN_VAR_RQCMDARG,
+  "Set remote access charset at connecting for improvement performance of connection if you know",
+  NULL,
+  NULL,
+  NULL
+);
+#else
+static MYSQL_SYSVAR_STR(
+  remote_access_charset,
+  spider_remote_access_charset,
+  PLUGIN_VAR_RQCMDARG,
+  "Set remote access charset at connecting for improvement performance of connection if you know",
+  NULL,
+  NULL,
+  NULL
+);
+#endif
+#endif
+
+char *spider_param_remote_access_charset()
+{
+  DBUG_ENTER("spider_param_remote_access_charset");
+  DBUG_RETURN(spider_remote_access_charset);
+}
+
+static int spider_remote_autocommit;
+/*
+ -1 :don't set
+  0 :autocommit = 0
+  1 :autocommit = 1
+ */
+static MYSQL_SYSVAR_INT(
+  remote_autocommit,
+  spider_remote_autocommit,
+  PLUGIN_VAR_RQCMDARG,
+  "Set autocommit mode at connecting for improvement performance of connection if you know",
+  NULL,
+  NULL,
+  -1,
+  -1,
+  1,
+  0
+);
+
+int spider_param_remote_autocommit()
+{
+  DBUG_ENTER("spider_param_remote_autocommit");
+  DBUG_RETURN(spider_remote_autocommit);
+}
+
+static char *spider_remote_time_zone;
+/*
+ */
+#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000
+static MYSQL_SYSVAR_STR(
+  remote_time_zone,
+  spider_remote_time_zone,
+  PLUGIN_VAR_MEMALLOC |
+  PLUGIN_VAR_RQCMDARG,
+  "Set remote time_zone at connecting for improvement performance of connection if you know",
+  NULL,
+  NULL,
+  NULL
+);
+#else
+#ifdef PLUGIN_VAR_CAN_MEMALLOC
+static MYSQL_SYSVAR_STR(
+  remote_time_zone,
+  spider_remote_time_zone,
+  PLUGIN_VAR_MEMALLOC |
+  PLUGIN_VAR_RQCMDARG,
+  "Set remote time_zone at connecting for improvement performance of connection if you know",
+  NULL,
+  NULL,
+  NULL
+);
+#else
+static MYSQL_SYSVAR_STR(
+  remote_time_zone,
+  spider_remote_time_zone,
+  PLUGIN_VAR_RQCMDARG,
+  "Set remote time_zone at connecting for improvement performance of connection if you know",
+  NULL,
+  NULL,
+  NULL
+);
+#endif
+#endif
+
+char *spider_param_remote_time_zone()
+{
+  DBUG_ENTER("spider_param_remote_time_zone");
+  DBUG_RETURN(spider_remote_time_zone);
+}
+
+static int spider_remote_sql_log_off;
+/*
+ -1 :don't know the value on all data nodes, or does not matter
+  0 :sql_log_off = 0 on all data nodes
+  1 :sql_log_off = 1 on all data nodes
+ */
+static MYSQL_SYSVAR_INT(
+  remote_sql_log_off,
+  spider_remote_sql_log_off,
+  PLUGIN_VAR_RQCMDARG,
+  "Set SQL_LOG_OFF mode on connecting for improved performance of connection, if you know",
+  NULL,
+  NULL,
+  -1,
+  -1,
+  1,
+  0
+);
+
+int spider_param_remote_sql_log_off()
+{
+  DBUG_ENTER("spider_param_remote_sql_log_off");
+  DBUG_RETURN(spider_remote_sql_log_off);
+}
+
+static int spider_remote_trx_isolation;
+/*
+ -1 :don't set
+  0 :READ UNCOMMITTED
+  1 :READ COMMITTED
+  2 :REPEATABLE READ
+  3 :SERIALIZABLE
+ */
+static MYSQL_SYSVAR_INT(
+  remote_trx_isolation,
+  spider_remote_trx_isolation,
+  PLUGIN_VAR_RQCMDARG,
+  "Set transaction isolation level at connecting for improvement performance of connection if you know",
+  NULL,
+  NULL,
+  -1,
+  -1,
+  3,
+  0
+);
+
+int spider_param_remote_trx_isolation()
+{
+  DBUG_ENTER("spider_param_remote_trx_isolation");
+  DBUG_RETURN(spider_remote_trx_isolation);
+}
+
+static char *spider_remote_default_database;
+/*
+ */
+#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000
+static MYSQL_SYSVAR_STR(
+  remote_default_database,
+  spider_remote_default_database,
+  PLUGIN_VAR_MEMALLOC |
+  PLUGIN_VAR_RQCMDARG,
+  "Set remote database at connecting for improvement performance of connection if you know",
+  NULL,
+  NULL,
+  NULL
+);
+#else
+#ifdef PLUGIN_VAR_CAN_MEMALLOC
+static MYSQL_SYSVAR_STR(
+  remote_default_database,
+  spider_remote_default_database,
+  PLUGIN_VAR_MEMALLOC |
+  PLUGIN_VAR_RQCMDARG,
+  "Set remote database at connecting for improvement performance of connection if you know",
+  NULL,
+  NULL,
+  NULL
+);
+#else
+static MYSQL_SYSVAR_STR(
+  remote_default_database,
+  spider_remote_default_database,
+  PLUGIN_VAR_RQCMDARG,
+  "Set remote database at connecting for improvement performance of connection if you know",
+  NULL,
+  NULL,
+  NULL
+);
+#endif
+#endif
+
+char *spider_param_remote_default_database()
+{
+  DBUG_ENTER("spider_param_remote_default_database");
+  DBUG_RETURN(spider_remote_default_database);
+}
+
+/*
+  0-:connect retry interval (micro second)
+ */
+static MYSQL_THDVAR_LONGLONG(
+  connect_retry_interval, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Connect retry interval", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  1000, /* def */
+  0, /* min */
+  9223372036854775807LL, /* max */
+  0 /* blk */
+);
+
+longlong spider_param_connect_retry_interval(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_connect_retry_interval");
+  if (thd)
+    DBUG_RETURN(THDVAR(thd, connect_retry_interval));
+  DBUG_RETURN(0);
+}
+
+/*
+  0-:connect retry count
+ */
+static MYSQL_THDVAR_INT(
+  connect_retry_count, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Connect retry count", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  1000, /* def */
+  0, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+int spider_param_connect_retry_count(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_connect_retry_count");
+  if (thd)
+    DBUG_RETURN(THDVAR(thd, connect_retry_count));
+  DBUG_RETURN(0);
+}
+
+/*
+ */
+#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000
+static MYSQL_THDVAR_STR(
+  bka_engine, /* name */
+  PLUGIN_VAR_MEMALLOC |
+  PLUGIN_VAR_RQCMDARG,
+  "Temporary table's engine for BKA", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  NULL /* def */
+);
+#else
+#ifdef PLUGIN_VAR_CAN_MEMALLOC
+static MYSQL_THDVAR_STR(
+  bka_engine, /* name */
+  PLUGIN_VAR_MEMALLOC |
+  PLUGIN_VAR_RQCMDARG,
+  "Temporary table's engine for BKA", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  NULL /* def */
+);
+#else
+static MYSQL_THDVAR_STR(
+  bka_engine, /* name */
+  PLUGIN_VAR_RQCMDARG,
+  "Temporary table's engine for BKA", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  NULL /* def */
+);
+#endif
+#endif
+
+char *spider_param_bka_engine(
+  THD *thd,
+  char *bka_engine
+) {
+  DBUG_ENTER("spider_param_bka_engine");
+  DBUG_RETURN(THDVAR(thd, bka_engine) ?
+    THDVAR(thd, bka_engine) : bka_engine);
+}
+
+/*
+ -1 :use table parameter
+  0 :use union all
+  1 :use temporary table
+ */
+static MYSQL_THDVAR_INT(
+  bka_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Mode of BKA for Spider", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+int spider_param_bka_mode(
+  THD *thd,
+  int bka_mode
+) {
+  DBUG_ENTER("spider_param_bka_mode");
+  DBUG_RETURN(THDVAR(thd, bka_mode) == -1 ?
+    bka_mode : THDVAR(thd, bka_mode));
+}
+
+static int spider_udf_ct_bulk_insert_interval;
+/*
+ -1         : The UDF parameter is adopted.
+  0 or more : Milliseconds.
+ */
+static MYSQL_SYSVAR_INT(
+  udf_ct_bulk_insert_interval,
+  spider_udf_ct_bulk_insert_interval,
+  PLUGIN_VAR_RQCMDARG,
+  "The interval time between bulk insert and next bulk insert at coping",
+  NULL,
+  NULL,
+  -1,
+  -1,
+  2147483647,
+  0
+);
+
+int spider_param_udf_ct_bulk_insert_interval(
+  int udf_ct_bulk_insert_interval
+) {
+  DBUG_ENTER("spider_param_udf_ct_bulk_insert_interval");
+  DBUG_RETURN(spider_udf_ct_bulk_insert_interval < 0 ?
+    udf_ct_bulk_insert_interval : spider_udf_ct_bulk_insert_interval);
+}
+
+static longlong spider_udf_ct_bulk_insert_rows;
+/*
+ -1,0       : The UDF parameter is adopted.
+  1 or more : Number of rows.
+ */
+static MYSQL_SYSVAR_LONGLONG(
+  udf_ct_bulk_insert_rows,
+  spider_udf_ct_bulk_insert_rows,
+  PLUGIN_VAR_RQCMDARG,
+  "The number of rows inserted with bulk insert of one time at coping",
+  NULL,
+  NULL,
+  -1,
+  -1,
+  9223372036854775807LL,
+  0
+);
+
+longlong spider_param_udf_ct_bulk_insert_rows(
+  longlong udf_ct_bulk_insert_rows
+) {
+  DBUG_ENTER("spider_param_udf_ct_bulk_insert_rows");
+  DBUG_RETURN(spider_udf_ct_bulk_insert_rows <= 0 ?
+    udf_ct_bulk_insert_rows : spider_udf_ct_bulk_insert_rows);
+}
+
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+/*
+  0: no recycle
+  1: recycle in instance
+  2: recycle in thread
+ */
+static MYSQL_THDVAR_UINT(
+  hs_r_conn_recycle_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Handlersocket connection recycle mode", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  2, /* def */
+  0, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+uint spider_param_hs_r_conn_recycle_mode(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_hs_r_conn_recycle_mode");
+  DBUG_RETURN(THDVAR(thd, hs_r_conn_recycle_mode));
+}
+
+/*
+  0: weak
+  1: strict
+ */
+static MYSQL_THDVAR_UINT(
+  hs_r_conn_recycle_strict, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Strict handlersocket connection recycle", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  0, /* def */
+  0, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+uint spider_param_hs_r_conn_recycle_strict(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_hs_r_conn_recycle_strict");
+  DBUG_RETURN(THDVAR(thd, hs_r_conn_recycle_strict));
+}
+
+/*
+  0: no recycle
+  1: recycle in instance
+  2: recycle in thread
+ */
+static MYSQL_THDVAR_UINT(
+  hs_w_conn_recycle_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Handlersocket connection recycle mode", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  2, /* def */
+  0, /* min */
+  2, /* max */
+  0 /* blk */
+);
+
+uint spider_param_hs_w_conn_recycle_mode(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_hs_w_conn_recycle_mode");
+  DBUG_RETURN(THDVAR(thd, hs_w_conn_recycle_mode));
+}
+
+/*
+  0: weak
+  1: strict
+ */
+static MYSQL_THDVAR_UINT(
+  hs_w_conn_recycle_strict, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Strict handlersocket connection recycle", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  0, /* def */
+  0, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+uint spider_param_hs_w_conn_recycle_strict(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_hs_w_conn_recycle_strict");
+  DBUG_RETURN(THDVAR(thd, hs_w_conn_recycle_strict));
+}
+
+/*
+ -1 :use table parameter
+  0 :not use
+  1 :use handlersocket
+ */
+static MYSQL_THDVAR_INT(
+  use_hs_read, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Use handlersocket for reading", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_use_hs_read(
+  THD *thd,
+  int use_hs_read
+) {
+  DBUG_ENTER("spider_param_use_hs_read");
+  DBUG_RETURN(THDVAR(thd, use_hs_read) == -1 ?
+    use_hs_read : THDVAR(thd, use_hs_read));
+}
+
+/*
+ -1 :use table parameter
+  0 :not use
+  1 :use handlersocket
+ */
+static MYSQL_THDVAR_INT(
+  use_hs_write, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Use handlersocket for writing", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_use_hs_write(
+  THD *thd,
+  int use_hs_write
+) {
+  DBUG_ENTER("spider_param_use_hs_write");
+  DBUG_RETURN(THDVAR(thd, use_hs_write) == -1 ?
+    use_hs_write : THDVAR(thd, use_hs_write));
+}
+#endif
+
+/*
+ -1 :use table parameter
+  0 :not use
+  1 :use handler
+ */
+static MYSQL_THDVAR_INT(
+  use_handler, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Use handler for reading", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  3, /* max */
+  0 /* blk */
+);
+
+int spider_param_use_handler(
+  THD *thd,
+  int use_handler
+) {
+  DBUG_ENTER("spider_param_use_handler");
+  DBUG_RETURN(THDVAR(thd, use_handler) == -1 ?
+    use_handler : THDVAR(thd, use_handler));
+}
+
+/*
+ -1 :use table parameter
+  0 :return error if error
+  1 :return 0 record if error
+ */
+static MYSQL_THDVAR_INT(
+  error_read_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Read error mode if error", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_error_read_mode(
+  THD *thd,
+  int error_read_mode
+) {
+  DBUG_ENTER("spider_param_error_read_mode");
+  DBUG_RETURN(THDVAR(thd, error_read_mode) == -1 ?
+    error_read_mode : THDVAR(thd, error_read_mode));
+}
+
+/*
+ -1 :use table parameter
+  0 :return error if error
+  1 :return 0 record if error
+ */
+static MYSQL_THDVAR_INT(
+  error_write_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Write error mode if error", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_error_write_mode(
+  THD *thd,
+  int error_write_mode
+) {
+  DBUG_ENTER("spider_param_error_write_mode");
+  DBUG_RETURN(THDVAR(thd, error_write_mode) == -1 ?
+    error_write_mode : THDVAR(thd, error_write_mode));
+}
+
+/*
+ -1 :use table parameter
+  0 :not skip
+  1 :skip
+ */
+static MYSQL_THDVAR_INT(
+  skip_default_condition, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Skip generating internal default condition", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_skip_default_condition(
+  THD *thd,
+  int skip_default_condition
+) {
+  DBUG_ENTER("spider_param_skip_default_condition");
+  DBUG_RETURN(THDVAR(thd, skip_default_condition) == -1 ?
+    skip_default_condition : THDVAR(thd, skip_default_condition));
+}
+
+/*
+ -1 :use table parameter
+  0 :not skip
+  1 :skip parallel search if query is not SELECT statement
+  2 :skip parallel search if query has SQL_NO_CACHE
+  3 :1+2
+ */
+static MYSQL_THDVAR_INT(
+  skip_parallel_search, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Skip parallel search by specific conditions", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  3, /* max */
+  0 /* blk */
+);
+
+int spider_param_skip_parallel_search(
+  THD *thd,
+  int skip_parallel_search
+) {
+  DBUG_ENTER("spider_param_skip_parallel_search");
+  DBUG_RETURN(THDVAR(thd, skip_parallel_search) == -1 ?
+    skip_parallel_search : THDVAR(thd, skip_parallel_search));
+}
+
+/*
+ -1 :use table parameter
+  0 :not send directly
+  1-:send directly
+ */
+static MYSQL_THDVAR_LONGLONG(
+  direct_order_limit, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Send 'ORDER BY' and 'LIMIT' to remote server directly", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  9223372036854775807LL, /* max */
+  0 /* blk */
+);
+
+longlong spider_param_direct_order_limit(
+  THD *thd,
+  longlong direct_order_limit
+) {
+  DBUG_ENTER("spider_param_direct_order_limit");
+  DBUG_RETURN(THDVAR(thd, direct_order_limit) == -1 ?
+    direct_order_limit : THDVAR(thd, direct_order_limit));
+}
+
+/*
+ -1 :use table parameter
+  0 :writable
+  1 :read only
+ */
+static MYSQL_THDVAR_INT(
+  read_only_mode, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Read only", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_read_only_mode(
+  THD *thd,
+  int read_only_mode
+) {
+  DBUG_ENTER("spider_param_read_only_mode");
+  DBUG_RETURN(THDVAR(thd, read_only_mode) == -1 ?
+    read_only_mode : THDVAR(thd, read_only_mode));
+}
+
+#ifdef HA_CAN_BULK_ACCESS
+static int spider_bulk_access_free;
+/*
+ -1 :use table parameter
+  0 :in reset
+  1 :in close
+ */
+static MYSQL_SYSVAR_INT(
+  bulk_access_free,
+  spider_bulk_access_free,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "Free mode of bulk access resources",
+  NULL,
+  NULL,
+  -1,
+  -1,
+  1,
+  0
+);
+
+int spider_param_bulk_access_free(
+  int bulk_access_free
+) {
+  DBUG_ENTER("spider_param_bulk_access_free");
+  DBUG_RETURN(spider_bulk_access_free == -1 ?
+    bulk_access_free : spider_bulk_access_free);
+}
+#endif
+
+#if MYSQL_VERSION_ID < 50500
+#else
+/*
+ -1 :use UDF parameter
+  0 :can not use
+  1 :can use
+ */
+static MYSQL_THDVAR_INT(
+  udf_ds_use_real_table, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Use real table for temporary table list", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_udf_ds_use_real_table(
+  THD *thd,
+  int udf_ds_use_real_table
+) {
+  DBUG_ENTER("spider_param_udf_ds_use_real_table");
+  DBUG_RETURN(THDVAR(thd, udf_ds_use_real_table) == -1 ?
+    udf_ds_use_real_table : THDVAR(thd, udf_ds_use_real_table));
+}
+#endif
+
+static my_bool spider_general_log;
+static MYSQL_SYSVAR_BOOL(
+  general_log,
+  spider_general_log,
+  PLUGIN_VAR_OPCMDARG,
+  "Log query to remote server in general log",
+  NULL,
+  NULL,
+  FALSE
+);
+
+my_bool spider_param_general_log()
+{
+  DBUG_ENTER("spider_param_general_log");
+  DBUG_RETURN(spider_general_log);
+}
+
+/*
+  FALSE: no pushdown hints
+  TRUE:  pushdown hints
+ */
+static MYSQL_THDVAR_BOOL(
+  index_hint_pushdown, /* name */
+  PLUGIN_VAR_OPCMDARG, /* opt */
+  "switch to control if push down index hint, like force_index", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  FALSE /* def */
+);
+
+my_bool spider_param_index_hint_pushdown(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_index_hint_pushdown");
+  DBUG_RETURN(THDVAR(thd, index_hint_pushdown));
+}
+
+static uint spider_max_connections;
+static MYSQL_SYSVAR_UINT(
+  max_connections,
+  spider_max_connections,
+  PLUGIN_VAR_RQCMDARG,
+  "the values, as the max conncetion from spider to remote mysql. Default 0, mean unlimit the connections",
+  NULL,
+  NULL,
+  0, /* def */
+  0, /* min */
+  99999, /* max */
+  0 /* blk */
+);
+
+uint spider_param_max_connections()
+{
+  DBUG_ENTER("spider_param_max_connections");
+  DBUG_RETURN(spider_max_connections);
+}
+
+static uint spider_conn_wait_timeout;
+static MYSQL_SYSVAR_UINT(
+  conn_wait_timeout,
+  spider_conn_wait_timeout,
+  PLUGIN_VAR_RQCMDARG,
+  "the values, as the max waiting time when spider get a remote conn",
+  NULL,
+  NULL,
+  10, /* def */
+  0, /* min */
+  1000, /* max */
+  0 /* blk */
+);
+
+uint spider_param_conn_wait_timeout()
+{
+  DBUG_ENTER("spider_param_conn_wait_timeout");
+  DBUG_RETURN(spider_conn_wait_timeout);
+}
+
+static uint spider_log_result_errors;
+/*
+  0: no log
+  1: log error
+  2: log warning summary
+  3: log warning
+  4: log info
+ */
+static MYSQL_SYSVAR_UINT(
+  log_result_errors,
+  spider_log_result_errors,
+  PLUGIN_VAR_RQCMDARG,
+  "Log error from remote server in error log",
+  NULL,
+  NULL,
+  0,
+  0,
+  4,
+  0
+);
+
+uint spider_param_log_result_errors()
+{
+  DBUG_ENTER("spider_param_log_result_errors");
+  DBUG_RETURN(spider_log_result_errors);
+}
+
+static uint spider_log_result_error_with_sql;
+/*
+  0: no log
+  1: log spider sql at logging result errors
+  2: log user sql at logging result errors
+  3: log both sql at logging result errors
+ */
+static MYSQL_SYSVAR_UINT(
+  log_result_error_with_sql,
+  spider_log_result_error_with_sql,
+  PLUGIN_VAR_RQCMDARG,
+  "Log sql at logging result errors",
+  NULL,
+  NULL,
+  0,
+  0,
+  3,
+  0
+);
+
+uint spider_param_log_result_error_with_sql()
+{
+  DBUG_ENTER("spider_param_log_result_error_with_sql");
+  DBUG_RETURN(spider_log_result_error_with_sql);
+}
+
+static char *spider_version = (char *) SPIDER_DETAIL_VERSION;
+static MYSQL_SYSVAR_STR(
+  version,
+  spider_version,
+  PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_READONLY,
+  "The version of Spider",
+  NULL,
+  NULL,
+  SPIDER_DETAIL_VERSION
+);
+
+/*
+  0: server_id + thread_id
+  1: server_id + thread_id + query_id
+ */
+static MYSQL_THDVAR_UINT(
+  internal_xa_id_type, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "The type of internal_xa id", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  0, /* def */
+  0, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+uint spider_param_internal_xa_id_type(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_internal_xa_id_type");
+  DBUG_RETURN(THDVAR(thd, internal_xa_id_type));
+}
+
+/*
+ -1 :use table parameter
+  0 :OFF
+  1 :automatic channel
+  2-63 :use custom channel
+ */
+static MYSQL_THDVAR_INT(
+  casual_read, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Read casually if it is possible", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  63, /* max */
+  0 /* blk */
+);
+
+int spider_param_casual_read(
+  THD *thd,
+  int casual_read
+) {
+  DBUG_ENTER("spider_param_casual_read");
+  DBUG_RETURN(THDVAR(thd, casual_read) == -1 ?
+    casual_read : THDVAR(thd, casual_read));
+}
+
+static my_bool spider_dry_access;
+static MYSQL_SYSVAR_BOOL(
+  dry_access,
+  spider_dry_access,
+  PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
+  "dry access",
+  NULL,
+  NULL,
+  FALSE
+);
+
+my_bool spider_param_dry_access()
+{
+  DBUG_ENTER("spider_param_dry_access");
+  DBUG_RETURN(spider_dry_access);
+}
+
+/*
+ -1 :use table parameter
+  0 :fast
+  1 :correct delete row number
+ */
+static MYSQL_THDVAR_INT(
+  delete_all_rows_type, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "The type of delete_all_rows", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_delete_all_rows_type(
+  THD *thd,
+  int delete_all_rows_type
+) {
+  DBUG_ENTER("spider_param_delete_all_rows_type");
+  DBUG_RETURN(THDVAR(thd, delete_all_rows_type) == -1 ?
+    delete_all_rows_type : THDVAR(thd, delete_all_rows_type));
+}
+
+/*
+ -1 :use table parameter
+  0 :compact
+  1 :add original table name
+ */
+static MYSQL_THDVAR_INT(
+  bka_table_name_type, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "The type of temporary table name for bka", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_bka_table_name_type(
+  THD *thd,
+  int bka_table_name_type
+) {
+  DBUG_ENTER("spider_param_bka_table_name_type");
+  DBUG_RETURN(THDVAR(thd, bka_table_name_type) == -1 ?
+    bka_table_name_type : THDVAR(thd, bka_table_name_type));
+}
+
+/*
+ -1 :use table parameter
+  0 :off
+  1 :on
+ */
+static MYSQL_THDVAR_INT(
+  use_cond_other_than_pk_for_update, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Use all conditions even if condition has pk", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  1, /* def */
+  0, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_use_cond_other_than_pk_for_update(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_reset_sql_alloc");
+  DBUG_RETURN(THDVAR(thd, use_cond_other_than_pk_for_update));
+}
+
+static int spider_store_last_sts;
+/*
+ -1 : use table parameter
+  0 : do not store
+  1 : do store
+ */
+static MYSQL_SYSVAR_INT(
+  store_last_sts,
+  spider_store_last_sts,
+  PLUGIN_VAR_RQCMDARG,
+  "Store last sts result into system table",
+  NULL,
+  NULL,
+  -1,
+  -1,
+  1,
+  0
+);
+
+int spider_param_store_last_sts(
+  int store_last_sts
+) {
+  DBUG_ENTER("spider_param_store_last_sts");
+  DBUG_RETURN(spider_store_last_sts == -1 ?
+    store_last_sts : spider_store_last_sts);
+}
+
+static int spider_store_last_crd;
+/*
+ -1 : use table parameter
+  0 : do not store
+  1 : do store
+ */
+static MYSQL_SYSVAR_INT(
+  store_last_crd,
+  spider_store_last_crd,
+  PLUGIN_VAR_RQCMDARG,
+  "Store last crd result into system table",
+  NULL,
+  NULL,
+  -1,
+  -1,
+  1,
+  0
+);
+
+int spider_param_store_last_crd(
+  int store_last_crd
+) {
+  DBUG_ENTER("spider_param_store_last_crd");
+  DBUG_RETURN(spider_store_last_crd == -1 ?
+    store_last_crd : spider_store_last_crd);
+}
+
+static int spider_load_sts_at_startup;
+/*
+ -1 : use table parameter
+  0 : do not load
+  1 : do load
+ */
+static MYSQL_SYSVAR_INT(
+  load_sts_at_startup,
+  spider_load_sts_at_startup,
+  PLUGIN_VAR_RQCMDARG,
+  "Load sts from system table at startup",
+  NULL,
+  NULL,
+  -1,
+  -1,
+  1,
+  0
+);
+
+int spider_param_load_sts_at_startup(
+  int load_sts_at_startup
+) {
+  DBUG_ENTER("spider_param_load_sts_at_startup");
+  DBUG_RETURN(spider_load_sts_at_startup == -1 ?
+    load_sts_at_startup : spider_load_sts_at_startup);
+}
+
+static int spider_load_crd_at_startup;
+/*
+ -1 : use table parameter
+  0 : do not load
+  1 : do load
+ */
+static MYSQL_SYSVAR_INT(
+  load_crd_at_startup,
+  spider_load_crd_at_startup,
+  PLUGIN_VAR_RQCMDARG,
+  "Load crd from system table at startup",
+  NULL,
+  NULL,
+  -1,
+  -1,
+  1,
+  0
+);
+
+int spider_param_load_crd_at_startup(
+  int load_crd_at_startup
+) {
+  DBUG_ENTER("spider_param_load_crd_at_startup");
+  DBUG_RETURN(spider_load_crd_at_startup == -1 ?
+    load_crd_at_startup : spider_load_crd_at_startup);
+}
+
+#ifndef WITHOUT_SPIDER_BG_SEARCH
+static uint spider_table_sts_thread_count;
+/*
+  1-: thread count
+ */
+static MYSQL_SYSVAR_UINT(
+  table_sts_thread_count,
+  spider_table_sts_thread_count,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "Static thread count of table sts",
+  NULL,
+  NULL,
+  10,
+  1,
+  4294967295U,
+  0
+);
+
+uint spider_param_table_sts_thread_count()
+{
+  DBUG_ENTER("spider_param_table_sts_thread_count");
+  DBUG_RETURN(spider_table_sts_thread_count);
+}
+
+static uint spider_table_crd_thread_count;
+/*
+  1-: thread count
+ */
+static MYSQL_SYSVAR_UINT(
+  table_crd_thread_count,
+  spider_table_crd_thread_count,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "Static thread count of table crd",
+  NULL,
+  NULL,
+  10,
+  1,
+  4294967295U,
+  0
+);
+
+uint spider_param_table_crd_thread_count()
+{
+  DBUG_ENTER("spider_param_table_crd_thread_count");
+  DBUG_RETURN(spider_table_crd_thread_count);
+}
+#endif
+
+static int spider_slave_trx_isolation;
+/*
+ -1 :off
+  0 :read uncommitted
+  1 :read committed
+  2 :repeatable read
+  3 :serializable
+ */
+static MYSQL_SYSVAR_INT(
+  slave_trx_isolation,
+  spider_slave_trx_isolation,
+  PLUGIN_VAR_RQCMDARG,
+  "Transaction isolation level when Spider table is used by slave SQL thread",
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  3, /* max */
+  0 /* blk */
+);
+
+int spider_param_slave_trx_isolation()
+{
+  DBUG_ENTER("spider_param_slave_trx_isolation");
+  DBUG_RETURN(spider_slave_trx_isolation);
+}
+
+/*
+ -1 :not set
+  0-:seconds of timeout
+ */
+static MYSQL_THDVAR_INT(
+  remote_wait_timeout, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Wait timeout on remote server", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+int spider_param_remote_wait_timeout(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_remote_wait_timeout");
+  if (likely(thd))
+    DBUG_RETURN(THDVAR(thd, remote_wait_timeout));
+  DBUG_RETURN(-1);
+}
+
+/*
+ -1 :not set
+  0-:seconds of timeout
+ */
+static MYSQL_THDVAR_INT(
+  wait_timeout, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Wait timeout of setting to remote server", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  604800, /* def */
+  -1, /* min */
+  2147483647, /* max */
+  0 /* blk */
+);
+
+int spider_param_wait_timeout(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_wait_timeout");
+  if (likely(thd))
+    DBUG_RETURN(THDVAR(thd, wait_timeout));
+  DBUG_RETURN(604800);
+}
+
+/*
+  FALSE: no sync
+  TRUE:  sync
+ */
+static MYSQL_THDVAR_BOOL(
+  sync_sql_mode, /* name */
+  PLUGIN_VAR_OPCMDARG, /* opt */
+  "Sync sql_mode", /* comment */
+  NULL, /* check */
+  NULL, /* update */
+  TRUE /* def */
+);
+
+bool spider_param_sync_sql_mode(
+  THD *thd
+) {
+  DBUG_ENTER("spider_param_sync_sql_mode");
+  DBUG_RETURN(THDVAR(thd, sync_sql_mode));
+}
+
+/*
+ -1 : use table parameter
+  0 : do not strict
+  1 : do strict
+ */
+static MYSQL_THDVAR_INT(
+  strict_group_by, /* name */
+  PLUGIN_VAR_RQCMDARG, /* opt */
+  "Use columns in select clause strictly for group by clause",
+  NULL, /* check */
+  NULL, /* update */
+  -1, /* def */
+  -1, /* min */
+  1, /* max */
+  0 /* blk */
+);
+
+int spider_param_strict_group_by(
+  THD *thd,
+  int strict_group_by
+) {
+  DBUG_ENTER("spider_param_strict_group_by");
+  DBUG_RETURN(THDVAR(thd, strict_group_by) == -1 ?
+    strict_group_by : THDVAR(thd, strict_group_by));
+}
+
+static struct st_mysql_storage_engine spider_storage_engine =
+{ MYSQL_HANDLERTON_INTERFACE_VERSION };
+
+static struct st_mysql_sys_var* spider_system_variables[] = {
+  MYSQL_SYSVAR(support_xa),
+  MYSQL_SYSVAR(table_init_error_interval),
+  MYSQL_SYSVAR(use_table_charset),
+  MYSQL_SYSVAR(conn_recycle_mode),
+  MYSQL_SYSVAR(conn_recycle_strict),
+  MYSQL_SYSVAR(sync_trx_isolation),
+  MYSQL_SYSVAR(use_consistent_snapshot),
+  MYSQL_SYSVAR(internal_xa),
+  MYSQL_SYSVAR(internal_xa_snapshot),
+  MYSQL_SYSVAR(force_commit),
+  MYSQL_SYSVAR(xa_register_mode),
+  MYSQL_SYSVAR(internal_offset),
+  MYSQL_SYSVAR(internal_limit),
+  MYSQL_SYSVAR(split_read),
+  MYSQL_SYSVAR(semi_split_read),
+  MYSQL_SYSVAR(semi_split_read_limit),
+  MYSQL_SYSVAR(init_sql_alloc_size),
+  MYSQL_SYSVAR(reset_sql_alloc),
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+  MYSQL_SYSVAR(hs_result_free_size),
+#endif
+  MYSQL_SYSVAR(multi_split_read),
+  MYSQL_SYSVAR(max_order),
+  MYSQL_SYSVAR(semi_trx_isolation),
+  MYSQL_SYSVAR(semi_table_lock),
+  MYSQL_SYSVAR(semi_table_lock_connection),
+  MYSQL_SYSVAR(block_size),
+  MYSQL_SYSVAR(selupd_lock_mode),
+  MYSQL_SYSVAR(sync_autocommit),
+  MYSQL_SYSVAR(use_default_database),
+  MYSQL_SYSVAR(internal_sql_log_off),
+  MYSQL_SYSVAR(bulk_size),
+  MYSQL_SYSVAR(bulk_update_mode),
+  MYSQL_SYSVAR(bulk_update_size),
+  MYSQL_SYSVAR(buffer_size),
+  MYSQL_SYSVAR(internal_optimize),
+  MYSQL_SYSVAR(internal_optimize_local),
+  MYSQL_SYSVAR(use_flash_logs),
+  MYSQL_SYSVAR(use_snapshot_with_flush_tables),
+  MYSQL_SYSVAR(use_all_conns_snapshot),
+  MYSQL_SYSVAR(lock_exchange),
+  MYSQL_SYSVAR(internal_unlock),
+  MYSQL_SYSVAR(semi_trx),
+  MYSQL_SYSVAR(connect_timeout),
+  MYSQL_SYSVAR(net_read_timeout),
+  MYSQL_SYSVAR(net_write_timeout),
+  MYSQL_SYSVAR(quick_mode),
+  MYSQL_SYSVAR(quick_page_size),
+  MYSQL_SYSVAR(quick_page_byte),
+  MYSQL_SYSVAR(low_mem_read),
+  MYSQL_SYSVAR(select_column_mode),
+#ifndef WITHOUT_SPIDER_BG_SEARCH
+  MYSQL_SYSVAR(bgs_mode),
+  MYSQL_SYSVAR(bgs_first_read),
+  MYSQL_SYSVAR(bgs_second_read),
+#endif
+  MYSQL_SYSVAR(first_read),
+  MYSQL_SYSVAR(second_read),
+  MYSQL_SYSVAR(crd_interval),
+  MYSQL_SYSVAR(crd_mode),
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  MYSQL_SYSVAR(crd_sync),
+#endif
+  MYSQL_SYSVAR(store_last_crd),
+  MYSQL_SYSVAR(load_crd_at_startup),
+  MYSQL_SYSVAR(crd_type),
+  MYSQL_SYSVAR(crd_weight),
+#ifndef WITHOUT_SPIDER_BG_SEARCH
+  MYSQL_SYSVAR(crd_bg_mode),
+#endif
+  MYSQL_SYSVAR(sts_interval),
+  MYSQL_SYSVAR(sts_mode),
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  MYSQL_SYSVAR(sts_sync),
+#endif
+  MYSQL_SYSVAR(store_last_sts),
+  MYSQL_SYSVAR(load_sts_at_startup),
+#ifndef WITHOUT_SPIDER_BG_SEARCH
+  MYSQL_SYSVAR(sts_bg_mode),
+#endif
+  MYSQL_SYSVAR(ping_interval_at_trx_start),
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+  MYSQL_SYSVAR(hs_ping_interval),
+#endif
+  MYSQL_SYSVAR(auto_increment_mode),
+  MYSQL_SYSVAR(same_server_link),
+  MYSQL_SYSVAR(local_lock_table),
+  MYSQL_SYSVAR(use_pushdown_udf),
+  MYSQL_SYSVAR(direct_dup_insert),
+  MYSQL_SYSVAR(udf_table_lock_mutex_count),
+  MYSQL_SYSVAR(udf_table_mon_mutex_count),
+  MYSQL_SYSVAR(udf_ds_bulk_insert_rows),
+  MYSQL_SYSVAR(udf_ds_table_loop_mode),
+  MYSQL_SYSVAR(remote_access_charset),
+  MYSQL_SYSVAR(remote_autocommit),
+  MYSQL_SYSVAR(remote_time_zone),
+  MYSQL_SYSVAR(remote_sql_log_off),
+  MYSQL_SYSVAR(remote_trx_isolation),
+  MYSQL_SYSVAR(remote_default_database),
+  MYSQL_SYSVAR(connect_retry_interval),
+  MYSQL_SYSVAR(connect_retry_count),
+  MYSQL_SYSVAR(connect_mutex),
+  MYSQL_SYSVAR(bka_engine),
+  MYSQL_SYSVAR(bka_mode),
+  MYSQL_SYSVAR(udf_ct_bulk_insert_interval),
+  MYSQL_SYSVAR(udf_ct_bulk_insert_rows),
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+  MYSQL_SYSVAR(hs_r_conn_recycle_mode),
+  MYSQL_SYSVAR(hs_r_conn_recycle_strict),
+  MYSQL_SYSVAR(hs_w_conn_recycle_mode),
+  MYSQL_SYSVAR(hs_w_conn_recycle_strict),
+  MYSQL_SYSVAR(use_hs_read),
+  MYSQL_SYSVAR(use_hs_write),
+#endif
+  MYSQL_SYSVAR(use_handler),
+  MYSQL_SYSVAR(error_read_mode),
+  MYSQL_SYSVAR(error_write_mode),
+  MYSQL_SYSVAR(skip_default_condition),
+  MYSQL_SYSVAR(skip_parallel_search),
+  MYSQL_SYSVAR(direct_order_limit),
+  MYSQL_SYSVAR(read_only_mode),
+#ifdef HA_CAN_BULK_ACCESS
+  MYSQL_SYSVAR(bulk_access_free),
+#endif
+#if MYSQL_VERSION_ID < 50500
+#else
+  MYSQL_SYSVAR(udf_ds_use_real_table),
+#endif
+  MYSQL_SYSVAR(general_log),
+  MYSQL_SYSVAR(index_hint_pushdown),
+  MYSQL_SYSVAR(max_connections),
+  MYSQL_SYSVAR(conn_wait_timeout),
+  MYSQL_SYSVAR(log_result_errors),
+  MYSQL_SYSVAR(log_result_error_with_sql),
+  MYSQL_SYSVAR(version),
+  MYSQL_SYSVAR(internal_xa_id_type),
+  MYSQL_SYSVAR(casual_read),
+  MYSQL_SYSVAR(dry_access),
+  MYSQL_SYSVAR(delete_all_rows_type),
+  MYSQL_SYSVAR(bka_table_name_type),
+  MYSQL_SYSVAR(use_cond_other_than_pk_for_update),
+  MYSQL_SYSVAR(connect_error_interval),
+#ifndef WITHOUT_SPIDER_BG_SEARCH
+  MYSQL_SYSVAR(table_sts_thread_count),
+  MYSQL_SYSVAR(table_crd_thread_count),
+#endif
+  MYSQL_SYSVAR(slave_trx_isolation),
+  MYSQL_SYSVAR(remote_wait_timeout),
+  MYSQL_SYSVAR(wait_timeout),
+  MYSQL_SYSVAR(sync_sql_mode),
+  MYSQL_SYSVAR(strict_group_by),
+  NULL
+};
+
+mysql_declare_plugin(spider)
+{
+  MYSQL_STORAGE_ENGINE_PLUGIN,
+  &spider_storage_engine,
+  "SPIDER",
+  "Kentoku Shiba",
+  "Spider storage engine",
+  PLUGIN_LICENSE_GPL,
+  spider_db_init,
+  spider_db_done,
+  SPIDER_HEX_VERSION,
+  spider_status_variables,
+  spider_system_variables,
+  NULL,
+#if MYSQL_VERSION_ID >= 50600
+  0,
+#endif
+},
+spider_i_s_alloc_mem,
+spider_i_s_wrapper_protocols
+mysql_declare_plugin_end;
+
+#ifdef MARIADB_BASE_VERSION
+maria_declare_plugin(spider)
+{
+  MYSQL_STORAGE_ENGINE_PLUGIN,
+  &spider_storage_engine,
+  "SPIDER",
+  "Kentoku Shiba",
+  "Spider storage engine",
+  PLUGIN_LICENSE_GPL,
+  spider_db_init,
+  spider_db_done,
+  SPIDER_HEX_VERSION,
+  spider_status_variables,
+  spider_system_variables,
+  SPIDER_DETAIL_VERSION,
+  MariaDB_PLUGIN_MATURITY_STABLE
+},
+spider_i_s_alloc_mem_maria,
+spider_i_s_wrapper_protocols_maria
+maria_declare_plugin_end;
+#endif