MDEV-19002 Spider performance optimization with partition

Change the following function for batch call instead of each partition
- store_lock
- external_lock
- start_stmt
- extra
- cond_push
- info_push
- top_table

18 files changed, 2794 insertions, 1936 deletions

diff --git a/storage/spider/ha_spider.cc b/storage/spider/ha_spider.cc
index a7cfe45c8f7..c21f2bdb1ae 100644
--- a/storage/spider/ha_spider.cc
+++ b/storage/spider/ha_spider.cc
@@ -76,11 +76,8 @@ ha_spider::ha_spider(
   spider_alloc_calc_mem_init(mem_calc, 139);
   spider_alloc_calc_mem(spider_current_trx, mem_calc, sizeof(*this));
   share = NULL;
-  trx = NULL;
   conns = NULL;
   need_mons = NULL;
-  condition = NULL;
-  cond_check = FALSE;
   blob_buff = NULL;
   conn_keys = NULL;
   spider_thread_id = 0;
@@ -90,10 +87,9 @@ ha_spider::ha_spider(
   trx_hs_w_conn_adjustment = 0;
 #endif
   search_link_query_id = 0;
-  searched_bitmap = NULL;
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   partition_handler_share = NULL;
-  pt_handler_share_creator = NULL;
+  pt_handler_share_owner = FALSE;
 #endif
 #ifdef HA_MRR_USE_DEFAULT_IMPL
   multi_range_keys = NULL;
@@ -102,7 +98,6 @@ ha_spider::ha_spider(
   append_tblnm_alias = NULL;
   use_index_merge = FALSE;
   is_clone = FALSE;
-  clone_bitmap_init = FALSE;
   pt_clone_source_handler = NULL;
   pt_clone_last_searcher = NULL;
   ft_handler = NULL;
@@ -116,6 +111,7 @@ ha_spider::ha_spider(
 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
   use_fields = FALSE;
 #endif
+  dml_inited = FALSE;
   use_pre_call = FALSE;
   use_pre_action = FALSE;
 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
@@ -128,10 +124,6 @@ ha_spider::ha_spider(
   hs_decrement = FALSE;
   hs_pushed_strref_num = 0;
 #endif
-  direct_update_fields = NULL;
-#endif
-#ifdef INFO_KIND_FORCE_LIMIT_BEGIN
-  info_limit = 9223372036854775807LL;
 #endif
 #ifdef HA_CAN_BULK_ACCESS
   is_bulk_access_clone = FALSE;
@@ -188,11 +180,8 @@ ha_spider::ha_spider(
   spider_alloc_calc_mem_init(mem_calc, 0);
   spider_alloc_calc_mem(spider_current_trx, mem_calc, sizeof(*this));
   share = NULL;
-  trx = NULL;
   conns = NULL;
   need_mons = NULL;
-  condition = NULL;
-  cond_check = FALSE;
   blob_buff = NULL;
   conn_keys = NULL;
   spider_thread_id = 0;
@@ -202,10 +191,9 @@ ha_spider::ha_spider(
   trx_hs_w_conn_adjustment = 0;
 #endif
   search_link_query_id = 0;
-  searched_bitmap = NULL;
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   partition_handler_share = NULL;
-  pt_handler_share_creator = NULL;
+  pt_handler_share_owner = FALSE;
 #endif
 #ifdef HA_MRR_USE_DEFAULT_IMPL
   multi_range_keys = NULL;
@@ -214,7 +202,6 @@ ha_spider::ha_spider(
   append_tblnm_alias = NULL;
   use_index_merge = FALSE;
   is_clone = FALSE;
-  clone_bitmap_init = FALSE;
   pt_clone_source_handler = NULL;
   pt_clone_last_searcher = NULL;
   ft_handler = NULL;
@@ -228,6 +215,7 @@ ha_spider::ha_spider(
 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
   use_fields = FALSE;
 #endif
+  dml_inited = FALSE;
   use_pre_call = FALSE;
   use_pre_action = FALSE;
 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
@@ -240,10 +228,6 @@ ha_spider::ha_spider(
   hs_decrement = FALSE;
   hs_pushed_strref_num = 0;
 #endif
-  direct_update_fields = NULL;
-#endif
-#ifdef INFO_KIND_FORCE_LIMIT_BEGIN
-  info_limit = 9223372036854775807LL;
 #endif
 #ifdef HA_CAN_BULK_ACCESS
   is_bulk_access_clone = FALSE;
@@ -295,6 +279,19 @@ ha_spider::~ha_spider()
 {
   DBUG_ENTER("ha_spider::~ha_spider");
   DBUG_PRINT("info",("spider this=%p", this));
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (pt_handler_share_owner)
+  {
+    spider_free(spider_current_trx, partition_handler_share, MYF(0));
+    pt_handler_share_owner = FALSE;
+  }
+  partition_handler_share = NULL;
+#endif
+  if (wide_handler_owner)
+  {
+    spider_free(spider_current_trx, wide_handler, MYF(0));
+  }
+  wide_handler = NULL;
   spider_free_mem_calc(spider_current_trx, mem_calc_id, sizeof(*this));
   DBUG_VOID_RETURN;
 }
@@ -340,14 +337,16 @@ int ha_spider::open(
   THD *thd = ha_thd();
   int error_num, roop_count;
   int init_sql_alloc_size;
+  ha_spider *spider, *owner;
+  bool wide_handler_alloc = FALSE;
+  SPIDER_WIDE_SHARE *wide_share;
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-  SPIDER_PARTITION_SHARE *partition_share;
-  uchar *idx_read_bitmap, *idx_write_bitmap,
-    *rnd_read_bitmap, *rnd_write_bitmap;
   uint part_num;
-  bool create_pt_handler_share = FALSE, pt_handler_mutex = FALSE,
-    may_be_clone = FALSE;
-  ha_spider **pt_handler_share_handlers;
+  bool pt_handler_share_alloc = FALSE;
+  bool pt_handler_mutex = FALSE;
+  ha_spider **pt_handler_share_handlers = NULL;
+  ha_partition *clone_source;
+  ha_spider *pt_handler_share_key;
 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
   my_hash_value_type hash_value;
 #endif
@@ -357,52 +356,50 @@ int ha_spider::open(
 
   dup_key_idx = (uint) -1;
   conn_kinds = SPIDER_CONN_KIND_MYSQL;
-  if (!spider_get_share(name, table, thd, this, &error_num))
-    goto error_get_share;
-  thr_lock_data_init(&share->lock,&lock,NULL);
-
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-  partition_share = share->partition_share;
   table->file->get_no_parts("", &part_num);
-  if (partition_share)
+  if (part_num)
   {
-    pt_handler_mutex = TRUE;
-    pthread_mutex_lock(&partition_share->pt_handler_mutex);
-/*
-    if (
-      !partition_share->partition_handler_share ||
-      partition_share->partition_handler_share->table != table
-    )
-      create_pt_handler_share = TRUE;
-*/
-#ifdef SPIDER_HAS_HASH_VALUE_TYPE
-    hash_value = my_calc_hash(&partition_share->pt_handler_hash,
-      (uchar*) &table, sizeof(TABLE *));
-    if (!(partition_handler_share = (SPIDER_PARTITION_HANDLER_SHARE*)
-      my_hash_search_using_hash_value(&partition_share->pt_handler_hash,
-      hash_value, (uchar*) &table, sizeof(TABLE *))))
-#else
-    if (!(partition_handler_share = (SPIDER_PARTITION_HANDLER_SHARE*)
-      my_hash_search(&partition_share->pt_handler_hash, (uchar*) &table,
-      sizeof(TABLE *))))
-#endif
+    pt_handler_share_handlers =
+      (ha_spider **) ((ha_partition *) table->file)->get_child_handlers();
+    spider = pt_handler_share_handlers[0];
+    owner = pt_handler_share_handlers[part_num - 1];
+    clone_source = ((ha_partition *) table->file)->get_clone_source();
+    if (clone_source)
     {
-      create_pt_handler_share = TRUE;
+      pt_handler_share_key = (ha_spider *)
+        clone_source->get_child_handlers()[0];
+      is_clone = TRUE;
+    } else {
+      pt_handler_share_key = spider;
     }
-  }
-
-  if (create_pt_handler_share)
-  {
-    if (!(searched_bitmap = (uchar *)
-      spider_bulk_malloc(spider_current_trx, 15, MYF(MY_WME),
+  } else {
+#endif
+    spider = this;
+    owner = this;
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+    clone_source = NULL;
+    pt_handler_share_key = this;
+  }
+#endif
+  if (!spider->wide_handler)
+  {
+    uchar *searched_bitmap;
+    uchar *ft_discard_bitmap;
+    uchar *position_bitmap;
+    uchar *idx_read_bitmap;
+    uchar *idx_write_bitmap;
+    uchar *rnd_read_bitmap;
+    uchar *rnd_write_bitmap;
+    if (!(wide_handler = (SPIDER_WIDE_HANDLER *)
+      spider_bulk_malloc(spider_current_trx, 16, MYF(MY_WME | MY_ZEROFILL),
+        &wide_handler, sizeof(SPIDER_WIDE_HANDLER),
         &searched_bitmap,
           (uint) sizeof(uchar) * no_bytes_in_map(table->read_set),
         &ft_discard_bitmap,
           (uint) sizeof(uchar) * no_bytes_in_map(table->read_set),
         &position_bitmap,
           (uint) sizeof(uchar) * no_bytes_in_map(table->read_set),
-        &partition_handler_share,
-          (uint) sizeof(SPIDER_PARTITION_HANDLER_SHARE),
         &idx_read_bitmap,
           (uint) sizeof(uchar) * no_bytes_in_map(table->read_set),
         &idx_write_bitmap,
@@ -411,103 +408,103 @@ int ha_spider::open(
           (uint) sizeof(uchar) * no_bytes_in_map(table->read_set),
         &rnd_write_bitmap,
           (uint) sizeof(uchar) * no_bytes_in_map(table->read_set),
-        &pt_handler_share_handlers,
-          (uint) sizeof(ha_spider *) * part_num,
         NullS))
     ) {
       error_num = HA_ERR_OUT_OF_MEM;
-      goto error_searched_bitmap_alloc;
-    }
-    DBUG_PRINT("info",("spider create partition_handler_share"));
-    partition_handler_share->use_count = 1;
-/*
-    if (partition_handler_share->use_count < part_num)
-      partition_share->partition_handler_share = partition_handler_share;
-*/
-    DBUG_PRINT("info",("spider table=%p", table));
-    partition_handler_share->table = table;
-    partition_handler_share->searched_bitmap = NULL;
-    partition_handler_share->ft_discard_bitmap = NULL;
-    partition_handler_share->idx_read_bitmap = idx_read_bitmap;
-    partition_handler_share->idx_write_bitmap = idx_write_bitmap;
-    partition_handler_share->rnd_read_bitmap = rnd_read_bitmap;
-    partition_handler_share->rnd_write_bitmap = rnd_write_bitmap;
-    partition_handler_share->between_flg = FALSE;
-    partition_handler_share->idx_bitmap_is_set = FALSE;
-    partition_handler_share->rnd_bitmap_is_set = FALSE;
-    partition_handler_share->table_hash_value = hash_value;
-    partition_handler_share->creator = this;
-    partition_handler_share->parallel_search_query_id = 0;
-    pt_handler_share_creator = this;
-    if (part_num)
-    {
-      partition_handler_share->handlers = (void **) pt_handler_share_handlers;
-      partition_handler_share->handlers[0] = this;
-    } else
-      partition_handler_share->handlers = NULL;
-    uint old_elements = partition_share->pt_handler_hash.array.max_element;
-#ifdef HASH_UPDATE_WITH_HASH_VALUE
-    if (my_hash_insert_with_hash_value(&partition_share->pt_handler_hash,
-      hash_value, (uchar*) partition_handler_share))
+      goto error_wide_handler_alloc;
+    }
+    spider->wide_handler = wide_handler;
+    owner->wide_handler = wide_handler;
+    wide_handler->searched_bitmap = searched_bitmap;
+    wide_handler->ft_discard_bitmap = ft_discard_bitmap;
+    wide_handler->position_bitmap = position_bitmap;
+    wide_handler->idx_read_bitmap = idx_read_bitmap;
+    wide_handler->idx_write_bitmap = idx_write_bitmap;
+    wide_handler->rnd_read_bitmap = rnd_read_bitmap;
+    wide_handler->rnd_write_bitmap = rnd_write_bitmap;
+    wide_handler->owner = owner;
+    owner->wide_handler_owner = TRUE;
+    memset(wide_handler->ft_discard_bitmap, 0xFF,
+      no_bytes_in_map(table->read_set));
+    memset(wide_handler->searched_bitmap, 0,
+      no_bytes_in_map(table->read_set));
+    wide_handler_alloc = TRUE;
+  } else {
+    wide_handler = spider->wide_handler;
+  }
+  if (!share && !spider_get_share(name, table, thd, this, &error_num))
+    goto error_get_share;
+
+  wide_share = share->wide_share;
+  if (wide_handler_alloc)
+  {
+    thr_lock_data_init(&wide_share->lock, &wide_handler->lock, NULL);
+  }
+
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (!wide_handler->partition_handler_share)
+  {
+    pt_handler_mutex = TRUE;
+    pthread_mutex_lock(&wide_share->pt_handler_mutex);
+#ifdef SPIDER_HAS_HASH_VALUE_TYPE
+    hash_value = my_calc_hash(&wide_share->pt_handler_hash,
+      (uchar*) pt_handler_share_key, sizeof(ha_spider *));
+    if (!(partition_handler_share = (SPIDER_PARTITION_HANDLER_SHARE*)
+      my_hash_search_using_hash_value(&wide_share->pt_handler_hash,
+      hash_value, (uchar*) pt_handler_share_key, sizeof(ha_spider *))))
 #else
-    if (my_hash_insert(&partition_share->pt_handler_hash,
-      (uchar*) partition_handler_share))
+    if (!(partition_handler_share = (SPIDER_PARTITION_HANDLER_SHARE*)
+      my_hash_search(&wide_share->pt_handler_hash,
+      (uchar*) pt_handler_share_key, sizeof(ha_spider *))))
 #endif
     {
-      error_num = HA_ERR_OUT_OF_MEM;
-      goto error_hash_insert;
-    }
-    if (partition_share->pt_handler_hash.array.max_element > old_elements)
-    {
-      spider_alloc_calc_mem(spider_current_trx,
-        partition_share->pt_handler_hash,
-        (partition_share->pt_handler_hash.array.max_element - old_elements) *
-        partition_share->pt_handler_hash.array.size_of_element);
-    }
-    pthread_mutex_unlock(&partition_share->pt_handler_mutex);
-    pt_handler_mutex = FALSE;
-  } else {
+      if (!(partition_handler_share = (SPIDER_PARTITION_HANDLER_SHARE *)
+        spider_bulk_malloc(spider_current_trx, 15, MYF(MY_WME | MY_ZEROFILL),
+          &partition_handler_share, sizeof(SPIDER_PARTITION_HANDLER_SHARE),
+          NullS))
+      ) {
+        error_num = HA_ERR_OUT_OF_MEM;
+        goto error_partition_handler_share_alloc;
+      }
+      DBUG_PRINT("info",("spider create partition_handler_share"));
+      DBUG_PRINT("info",("spider table=%p", table));
+      partition_handler_share->table = table;
+      partition_handler_share->table_hash_value = hash_value;
+      partition_handler_share->no_parts = part_num;
+      partition_handler_share->owner = owner;
+      partition_handler_share->parallel_search_query_id = 0;
+      spider->partition_handler_share = partition_handler_share;
+      owner->partition_handler_share = partition_handler_share;
+      owner->pt_handler_share_owner = TRUE;
+      partition_handler_share->handlers = pt_handler_share_handlers;
+      uint old_elements = wide_share->pt_handler_hash.array.max_element;
+#ifdef HASH_UPDATE_WITH_HASH_VALUE
+      if (my_hash_insert_with_hash_value(&wide_share->pt_handler_hash,
+        hash_value, (uchar*) partition_handler_share))
+#else
+      if (my_hash_insert(&wide_share->pt_handler_hash,
+        (uchar*) partition_handler_share))
 #endif
-    if (!(searched_bitmap = (uchar *)
-      spider_bulk_malloc(spider_current_trx, 16, MYF(MY_WME),
-        &searched_bitmap, sizeof(uchar) * no_bytes_in_map(table->read_set),
-        &ft_discard_bitmap, sizeof(uchar) * no_bytes_in_map(table->read_set),
-        &position_bitmap, sizeof(uchar) * no_bytes_in_map(table->read_set),
-        NullS))
-    ) {
-      error_num = HA_ERR_OUT_OF_MEM;
-      goto error_searched_bitmap_alloc;
-    }
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-    if (partition_share)
-    {
-      DBUG_PRINT("info",("spider copy partition_handler_share"));
-/*
-      partition_handler_share = (SPIDER_PARTITION_HANDLER_SHARE *)
-        partition_share->partition_handler_share;
-*/
-      if (part_num)
       {
-        if (partition_handler_share->use_count >= part_num)
-          may_be_clone = TRUE;
-        else {
-          partition_handler_share->handlers[
-            partition_handler_share->use_count] = this;
-          partition_handler_share->use_count++;
-        }
+        error_num = HA_ERR_OUT_OF_MEM;
+        goto error_hash_insert;
+      }
+      if (wide_share->pt_handler_hash.array.max_element > old_elements)
+      {
+        spider_alloc_calc_mem(spider_current_trx,
+          wide_share->pt_handler_hash,
+          (wide_share->pt_handler_hash.array.max_element -
+            old_elements) *
+          wide_share->pt_handler_hash.array.size_of_element);
       }
-/*
-      if (partition_handler_share->use_count == part_num)
-        partition_share->partition_handler_share = NULL;
-*/
-      pthread_mutex_unlock(&partition_share->pt_handler_mutex);
-      pt_handler_mutex = FALSE;
     }
+    pthread_mutex_unlock(&wide_share->pt_handler_mutex);
+    pt_handler_mutex = FALSE;
+    pt_handler_share_alloc = TRUE;
+  } else {
+    partition_handler_share = wide_handler->partition_handler_share;
   }
 #endif
-  memset(ft_discard_bitmap, 0xFF, no_bytes_in_map(table->read_set));
-  memset(searched_bitmap, 0, no_bytes_in_map(table->read_set));
-
   init_sql_alloc_size =
     spider_param_init_sql_alloc_size(thd, share->init_sql_alloc_size);
 
@@ -566,10 +563,6 @@ int ha_spider::open(
     }
   }
 
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-  if (may_be_clone && thd_sql_command(thd) != SQLCOM_ALTER_TABLE)
-    is_clone = TRUE;
-#endif
   if (is_clone)
   {
 #ifdef WITH_PARTITION_STORAGE_ENGINE
@@ -577,28 +570,38 @@ int ha_spider::open(
     {
       for (roop_count = 0; roop_count < (int) part_num; roop_count++)
       {
-        if (((ha_spider *) partition_handler_share->handlers[roop_count])->
-          share == share)
+        if (partition_handler_share->handlers[roop_count]->share == share)
         {
           pt_clone_source_handler =
-            (ha_spider *) partition_handler_share->handlers[roop_count];
+            partition_handler_share->handlers[roop_count];
           break;
         }
       }
     }
 #endif
 
-    sql_command = pt_clone_source_handler->sql_command;
-    result_list.lock_type = pt_clone_source_handler->result_list.lock_type;
-    lock_mode = pt_clone_source_handler->lock_mode;
+    wide_handler->external_lock_type =
+      pt_clone_source_handler->wide_handler->external_lock_type;
 
-    if (!pt_clone_source_handler->clone_bitmap_init)
+    if (wide_handler_alloc)
     {
-      pt_clone_source_handler->set_select_column_mode();
-      pt_clone_source_handler->clone_bitmap_init = TRUE;
+      wide_handler->lock_mode =
+        pt_clone_source_handler->wide_handler->lock_mode;
+      if (!partition_handler_share->clone_bitmap_init)
+      {
+        pt_clone_source_handler->set_select_column_mode();
+        partition_handler_share->clone_bitmap_init = TRUE;
+      }
+      set_clone_searched_bitmap();
+      wide_handler->position_bitmap_init = FALSE;
+      wide_handler->sql_command =
+        pt_clone_source_handler->wide_handler->sql_command;
+    }
+  } else {
+    if (share->semi_table_lock)
+    {
+      wide_handler->semi_table_lock = TRUE;
     }
-    set_clone_searched_bitmap();
-    position_bitmap_init = FALSE;
   }
 #ifdef HA_CAN_BULK_ACCESS
   external_lock_cnt = 0;
@@ -618,50 +621,55 @@ error_reset:
 error_init_blob_buff:
 error_init_result_list:
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-  if (
-    partition_handler_share &&
-    pt_handler_share_creator == this
-  ) {
-    partition_share = share->partition_share;
+error_hash_insert:
+  if (pt_handler_share_alloc)
+  {
+    wide_share = share->wide_share;
     if (!pt_handler_mutex)
-      pthread_mutex_lock(&partition_share->pt_handler_mutex);
-/*
-    if (partition_share->partition_handler_share == partition_handler_share)
-      partition_share->partition_handler_share = NULL;
-*/
+      pthread_mutex_lock(&wide_share->pt_handler_mutex);
 #ifdef HASH_UPDATE_WITH_HASH_VALUE
-    my_hash_delete_with_hash_value(&partition_share->pt_handler_hash,
+    my_hash_delete_with_hash_value(&wide_share->pt_handler_hash,
       partition_handler_share->table_hash_value,
       (uchar*) partition_handler_share);
 #else
-    my_hash_delete(&partition_share->pt_handler_hash,
+    my_hash_delete(&wide_share->pt_handler_hash,
       (uchar*) partition_handler_share);
 #endif
-    pthread_mutex_unlock(&partition_share->pt_handler_mutex);
+    pthread_mutex_unlock(&wide_share->pt_handler_mutex);
     pt_handler_mutex = FALSE;
+    spider_free(spider_current_trx, partition_handler_share, MYF(0));
+    spider->partition_handler_share = NULL;
+    owner->partition_handler_share = NULL;
+    owner->pt_handler_share_owner = FALSE;
   }
-error_hash_insert:
-  partition_handler_share = NULL;
-  pt_handler_share_creator = NULL;
-#endif
-  if (searched_bitmap)
-  {
-    spider_free(spider_current_trx, searched_bitmap, MYF(0));
-    searched_bitmap = NULL;
-  }
-error_searched_bitmap_alloc:
-#ifdef WITH_PARTITION_STORAGE_ENGINE
+error_partition_handler_share_alloc:
   if (pt_handler_mutex)
-    pthread_mutex_unlock(&partition_share->pt_handler_mutex);
+    pthread_mutex_unlock(&wide_share->pt_handler_mutex);
+  partition_handler_share = NULL;
 #endif
   spider_free_share(share);
   share = NULL;
-error_get_share:
   if (conn_keys)
   {
     spider_free(spider_current_trx, conn_keys, MYF(0));
     conn_keys = NULL;
   }
+error_get_share:
+  if (wide_handler_alloc)
+  {
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+    if (pt_handler_share_handlers)
+    {
+      pt_handler_share_handlers[0]->wide_handler = NULL;
+    }
+#endif
+    spider_free(spider_current_trx, wide_handler, MYF(0));
+    spider->wide_handler = NULL;
+    owner->wide_handler = NULL;
+    owner->wide_handler_owner = FALSE;
+  }
+  wide_handler = NULL;
+error_wide_handler_alloc:
   DBUG_RETURN(error_num);
 }
 
@@ -669,9 +677,7 @@ int ha_spider::close()
 {
   int error_num = 0, roop_count, error_num2;
   THD *thd = ha_thd();
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-  SPIDER_PARTITION_SHARE *partition_share;
-#endif
+  SPIDER_WIDE_SHARE *wide_share;
   backup_error_status();
   DBUG_ENTER("ha_spider::close");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -697,8 +703,8 @@ int ha_spider::close()
         bulk_access_link_first->spider));
       DBUG_PRINT("info",("spider bulk_access_link->spider->dbton_handler=%p",
         bulk_access_link_first->spider->dbton_handler));
-      DBUG_PRINT("info",("spider ptr bulk_access_link->spider->dbton_handler=%p",
-        &bulk_access_link_first->spider->dbton_handler));
+      DBUG_PRINT("info",("spider ptr bulk_access_link->spider->dbton_handler="
+        "%p", &bulk_access_link_first->spider->dbton_handler));
       bulk_access_link_current = bulk_access_link_first->next;
       delete_bulk_access_link(bulk_access_link_first);
       bulk_access_link_first = bulk_access_link_current;
@@ -761,34 +767,30 @@ int ha_spider::close()
     conn_keys = NULL;
   }
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-  if (
-    partition_handler_share &&
-    pt_handler_share_creator == this
-  ) {
-    partition_share = share->partition_share;
-    pthread_mutex_lock(&partition_share->pt_handler_mutex);
-/*
-    if (partition_share->partition_handler_share == partition_handler_share)
-      partition_share->partition_handler_share = NULL;
-*/
+  if (pt_handler_share_owner)
+  {
+    wide_share = share->wide_share;
+    pthread_mutex_lock(&wide_share->pt_handler_mutex);
 #ifdef HASH_UPDATE_WITH_HASH_VALUE
-    my_hash_delete_with_hash_value(&partition_share->pt_handler_hash,
+    my_hash_delete_with_hash_value(&wide_share->pt_handler_hash,
       partition_handler_share->table_hash_value,
       (uchar*) partition_handler_share);
 #else
-    my_hash_delete(&partition_share->pt_handler_hash,
+    my_hash_delete(&wide_share->pt_handler_hash,
       (uchar*) partition_handler_share);
 #endif
-    pthread_mutex_unlock(&partition_share->pt_handler_mutex);
+    pthread_mutex_unlock(&wide_share->pt_handler_mutex);
+    spider_free(spider_current_trx, partition_handler_share, MYF(0));
+    pt_handler_share_owner = FALSE;
   }
   partition_handler_share = NULL;
-  pt_handler_share_creator = NULL;
 #endif
-  if (searched_bitmap)
+  if (wide_handler_owner)
   {
-    spider_free(spider_current_trx, searched_bitmap, MYF(0));
-    searched_bitmap = NULL;
+    spider_free(spider_current_trx, wide_handler, MYF(0));
+    wide_handler_owner = FALSE;
   }
+  wide_handler = NULL;
   if (blob_buff)
   {
     delete [] blob_buff;
@@ -833,34 +835,23 @@ int ha_spider::close()
   }
 #endif
 #endif
-#ifdef HA_CAN_BULK_ACCESS
-/*
-  if (init_ha_mem_root)
-  {
-    free_root(&ha_mem_root, MYF(0));
-    init_ha_mem_root = FALSE;
-  }
-*/
-#endif
   is_clone = FALSE;
   pt_clone_source_handler = NULL;
   share = NULL;
-  trx = NULL;
   conns = NULL;
 
   DBUG_RETURN(error_num);
 }
 
-int ha_spider::check_access_kind(
+int ha_spider::check_access_kind_for_connection(
   THD *thd,
   bool write_request
 ) {
   int error_num, roop_count;
-  DBUG_ENTER("ha_spider::check_access_kind");
+  DBUG_ENTER("ha_spider::check_access_kind_for_connection");
   DBUG_PRINT("info",("spider this=%p", this));
-  sql_command = thd_sql_command(thd);
   conn_kinds = 0;
-  switch (sql_command)
+  switch (wide_handler->sql_command)
   {
 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
     case SQLCOM_HS_READ:
@@ -962,33 +953,60 @@ int ha_spider::check_access_kind(
   {
     DBUG_RETURN(error_num);
   }
-  DBUG_PRINT("info",("spider sql_command=%u", sql_command));
+  DBUG_PRINT("info",("spider wide_handler->semi_trx_isolation_chk = %s",
+    wide_handler->semi_trx_isolation_chk ? "TRUE" : "FALSE"));
+  if (wide_handler->semi_trx_isolation_chk)
+  {
+    SPIDER_SET_CONNS_PARAM(semi_trx_isolation_chk, TRUE, conns,
+      share->link_statuses, conn_link_idx, (int) share->link_count,
+      SPIDER_LINK_STATUS_RECOVERY);
+  }
+  DBUG_PRINT("info",("spider wide_handler->semi_trx_chk = %s",
+    wide_handler->semi_trx_chk ? "TRUE" : "FALSE"));
+  if (wide_handler->semi_trx_chk)
+  {
+    SPIDER_SET_CONNS_PARAM(semi_trx_chk, TRUE, conns, share->link_statuses,
+      conn_link_idx, (int) share->link_count, SPIDER_LINK_STATUS_RECOVERY);
+  } else {
+    SPIDER_SET_CONNS_PARAM(semi_trx_chk, FALSE, conns, share->link_statuses,
+      conn_link_idx, (int) share->link_count, SPIDER_LINK_STATUS_RECOVERY);
+  }
+  DBUG_RETURN(0);
+}
+
+void ha_spider::check_access_kind(
+  THD *thd
+) {
+  DBUG_ENTER("ha_spider::check_access_kind");
+  DBUG_PRINT("info",("spider this=%p", this));
+  wide_handler->sql_command = thd_sql_command(thd);
+  DBUG_PRINT("info",("spider sql_command=%u", wide_handler->sql_command));
   DBUG_PRINT("info",("spider thd->query_id=%lld", thd->query_id));
 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
 #ifdef HS_HAS_SQLCOM
-  if (sql_command == SQLCOM_HS_UPDATE)
-    update_request = TRUE;
+  if (wide_handler->sql_command == SQLCOM_HS_UPDATE)
+    wide_handler->update_request = TRUE;
   else
 #endif
-    update_request = FALSE;
+    wide_handler->update_request = FALSE;
 #else
   if (
 #ifdef HS_HAS_SQLCOM
-    sql_command == SQLCOM_HS_UPDATE ||
+    wide_handler->sql_command == SQLCOM_HS_UPDATE ||
 #endif
-    sql_command == SQLCOM_UPDATE ||
-    sql_command == SQLCOM_UPDATE_MULTI ||
+    wide_handler->sql_command == SQLCOM_UPDATE ||
+    wide_handler->sql_command == SQLCOM_UPDATE_MULTI ||
     /* for triggers */
-    sql_command == SQLCOM_INSERT ||
-    sql_command == SQLCOM_INSERT_SELECT ||
-    sql_command == SQLCOM_DELETE ||
-    sql_command == SQLCOM_DELETE_MULTI
+    wide_handler->sql_command == SQLCOM_INSERT ||
+    wide_handler->sql_command == SQLCOM_INSERT_SELECT ||
+    wide_handler->sql_command == SQLCOM_DELETE ||
+    wide_handler->sql_command == SQLCOM_DELETE_MULTI
   )
-    update_request = TRUE;
+    wide_handler->update_request = TRUE;
   else
-    update_request = FALSE;
+    wide_handler->update_request = FALSE;
 #endif
-  DBUG_RETURN(0);
+  DBUG_VOID_RETURN;
 }
 
 #ifdef HA_CAN_BULK_ACCESS
@@ -1002,14 +1020,20 @@ int ha_spider::additional_lock(
   {
     if (is_bulk_access_clone)
     {
-      DBUG_RETURN(check_access_kind(thd, (lock_type >= TL_WRITE_ALLOW_WRITE)));
+      check_access_kind(thd);
+      DBUG_RETURN(check_access_kind_for_connection(thd,
+        (lock_type >= TL_WRITE_ALLOW_WRITE)));
     } else if (bulk_access_link_exec_tgt->called)
     {
-      DBUG_RETURN(bulk_access_link_exec_tgt->spider->check_access_kind(
-        thd, (lock_type >= TL_WRITE_ALLOW_WRITE)));
+      bulk_access_link_exec_tgt->spider->check_access_kind(thd);
+      DBUG_RETURN(bulk_access_link_exec_tgt->spider->
+        check_access_kind_for_connection(
+          thd, (lock_type >= TL_WRITE_ALLOW_WRITE)));
     }
   }
-  DBUG_RETURN(check_access_kind(thd, (lock_type >= TL_WRITE_ALLOW_WRITE)));
+  check_access_kind(thd);
+  DBUG_RETURN(check_access_kind_for_connection(thd,
+    (lock_type >= TL_WRITE_ALLOW_WRITE)));
 }
 #endif
 
@@ -1018,53 +1042,37 @@ THR_LOCK_DATA **ha_spider::store_lock(
   THR_LOCK_DATA **to,
   enum thr_lock_type lock_type
 ) {
-  int error_num, roop_count;
   DBUG_ENTER("ha_spider::store_lock");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (lock_type == TL_IGNORE)
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (
+    wide_handler->stage == SPD_HND_STAGE_STORE_LOCK &&
+    wide_handler->stage_executor != this)
   {
-    *to++ = &lock;
     DBUG_RETURN(to);
   }
-  if ((error_num = check_access_kind(thd,
-    (lock_type >= TL_WRITE_ALLOW_WRITE))))
+  wide_handler->stage = SPD_HND_STAGE_STORE_LOCK;
+  wide_handler->stage_executor = this;
+#endif
+  wide_handler->lock_table_type = 0;
+  if (lock_type == TL_IGNORE)
   {
-    store_error_num = error_num;
+    *to++ = &wide_handler->lock;
     DBUG_RETURN(to);
   }
-  DBUG_PRINT("info",("spider sql_command=%u", sql_command));
+  check_access_kind(thd);
+  DBUG_PRINT("info",("spider sql_command=%u", wide_handler->sql_command));
   DBUG_PRINT("info",("spider lock_type=%d", lock_type));
   DBUG_PRINT("info",("spider thd->query_id=%lld", thd->query_id));
-  if (sql_command == SQLCOM_ALTER_TABLE)
-  {
-    if (trx->query_id != thd->query_id)
-    {
-      spider_free_trx_alter_table(trx);
-      trx->query_id = thd->query_id;
-      trx->tmp_flg = FALSE;
-    }
-    if (!(SPIDER_ALTER_TABLE*) my_hash_search(&trx->trx_alter_table_hash,
-      (uchar*) share->table_name, share->table_name_length))
-    {
-      if (spider_create_trx_alter_table(trx, share, FALSE))
-      {
-        store_error_num = HA_ERR_OUT_OF_MEM;
-        DBUG_RETURN(to);
-      }
-    }
-  }
 
-  this->lock_type = lock_type;
-  selupd_lock_mode = spider_param_selupd_lock_mode(thd,
-    share->selupd_lock_mode);
+  wide_handler->lock_type = lock_type;
   if (
-    sql_command != SQLCOM_DROP_TABLE &&
-    sql_command != SQLCOM_ALTER_TABLE
+    wide_handler->sql_command != SQLCOM_DROP_TABLE &&
+    wide_handler->sql_command != SQLCOM_ALTER_TABLE
   ) {
-    SPIDER_SET_CONNS_PARAM(semi_trx_chk, FALSE, conns, share->link_statuses,
-      conn_link_idx, (int) share->link_count, SPIDER_LINK_STATUS_RECOVERY);
+    wide_handler->semi_trx_chk = FALSE;
   }
-  switch (sql_command)
+  switch (wide_handler->sql_command)
   {
     case SQLCOM_SELECT:
     case SQLCOM_HA_READ:
@@ -1072,17 +1080,14 @@ THR_LOCK_DATA **ha_spider::store_lock(
     case SQLCOM_HS_READ:
 #endif
       if (lock_type == TL_READ_WITH_SHARED_LOCKS)
-        lock_mode = 1;
+        wide_handler->lock_mode = 1;
       else if (lock_type <= TL_READ_NO_INSERT)
       {
-        lock_mode = 0;
-        SPIDER_SET_CONNS_PARAM(semi_trx_isolation_chk, TRUE, conns,
-          share->link_statuses, conn_link_idx, (int) share->link_count,
-          SPIDER_LINK_STATUS_RECOVERY);
+        wide_handler->lock_mode = 0;
+        wide_handler->semi_trx_isolation_chk = TRUE;
       } else
-        lock_mode = -1;
-      SPIDER_SET_CONNS_PARAM(semi_trx_chk, TRUE, conns, share->link_statuses,
-        conn_link_idx, (int) share->link_count, SPIDER_LINK_STATUS_RECOVERY);
+        wide_handler->lock_mode = -1;
+      wide_handler->semi_trx_chk = TRUE;
       break;
     case SQLCOM_UPDATE:
     case SQLCOM_UPDATE_MULTI:
@@ -1103,39 +1108,37 @@ THR_LOCK_DATA **ha_spider::store_lock(
 #endif
       if (lock_type >= TL_READ && lock_type <= TL_READ_NO_INSERT)
       {
-        lock_mode = selupd_lock_mode;
-        SPIDER_SET_CONNS_PARAM(semi_trx_isolation_chk, TRUE, conns,
-          share->link_statuses, conn_link_idx, (int) share->link_count,
-          SPIDER_LINK_STATUS_RECOVERY);
+        wide_handler->lock_mode = -2;
+        wide_handler->semi_trx_isolation_chk = TRUE;
       } else
-        lock_mode = -1;
-      SPIDER_SET_CONNS_PARAM(semi_trx_chk, TRUE, conns, share->link_statuses,
-        conn_link_idx, (int) share->link_count, SPIDER_LINK_STATUS_RECOVERY);
+        wide_handler->lock_mode = -1;
+      wide_handler->semi_trx_chk = TRUE;
       break;
     default:
-        lock_mode = -1;
+        wide_handler->lock_mode = -1;
   }
   switch (lock_type)
   {
     case TL_READ_HIGH_PRIORITY:
-      high_priority = TRUE;
+      wide_handler->high_priority = TRUE;
       break;
     case TL_WRITE_DELAYED:
-      insert_delayed = TRUE;
+      wide_handler->insert_delayed = TRUE;
       break;
     case TL_WRITE_LOW_PRIORITY:
-      low_priority = TRUE;
+      wide_handler->low_priority = TRUE;
       break;
     default:
       break;
   }
 
-  if (lock_type != TL_IGNORE && lock.type == TL_UNLOCK)
+  if (wide_handler->lock_type != TL_IGNORE &&
+    wide_handler->lock.type == TL_UNLOCK)
   {
     if (
-      sql_command == SQLCOM_DROP_TABLE ||
-      sql_command == SQLCOM_ALTER_TABLE ||
-      sql_command == SQLCOM_SHOW_CREATE
+      wide_handler->sql_command == SQLCOM_DROP_TABLE ||
+      wide_handler->sql_command == SQLCOM_ALTER_TABLE ||
+      wide_handler->sql_command == SQLCOM_SHOW_CREATE
     ) {
       if (
         lock_type == TL_READ_NO_INSERT &&
@@ -1148,80 +1151,36 @@ THR_LOCK_DATA **ha_spider::store_lock(
       )
         lock_type = TL_WRITE_ALLOW_WRITE;
     } else if (
-      sql_command == SQLCOM_LOCK_TABLES ||
-      (spider_param_lock_exchange(thd) == 1 && share->semi_table_lock))
+      wide_handler->sql_command == SQLCOM_LOCK_TABLES ||
+      (spider_param_lock_exchange(thd) == 1 && wide_handler->semi_table_lock))
     {
       DBUG_PRINT("info",("spider lock exchange route"));
-      DBUG_PRINT("info",("spider lock_type=%u", this->lock_type));
+      DBUG_PRINT("info",("spider lock_type=%u", wide_handler->lock_type));
       if (
         (
-          this->lock_type == TL_READ ||
-          this->lock_type == TL_READ_NO_INSERT ||
-          this->lock_type == TL_WRITE_LOW_PRIORITY ||
-          this->lock_type == TL_WRITE
+          wide_handler->lock_type == TL_READ ||
+          wide_handler->lock_type == TL_READ_NO_INSERT ||
+          wide_handler->lock_type == TL_WRITE_LOW_PRIORITY ||
+          wide_handler->lock_type == TL_WRITE
         ) &&
         !spider_param_local_lock_table(thd)
       ) {
-        for (
-          roop_count = spider_conn_link_idx_next(share->link_statuses,
-            conn_link_idx, -1, share->link_count,
-            SPIDER_LINK_STATUS_RECOVERY);
-          roop_count < (int) share->link_count;
-          roop_count = spider_conn_link_idx_next(share->link_statuses,
-            conn_link_idx, roop_count, share->link_count,
-            SPIDER_LINK_STATUS_RECOVERY)
-        ) {
-          SPIDER_CONN *conn = conns[roop_count];
-          int appended = 0;
-          if ((error_num = dbton_handler[conn->dbton_id]->
-            append_lock_tables_list(conn, roop_count, &appended)))
-          {
-            store_error_num = error_num;
-            DBUG_RETURN(to);
-          }
-          if (appended)
-          {
-            conn->table_lock = 2;
-          }
-        }
+        wide_handler->lock_table_type = 1;
       }
     } else {
       DBUG_PRINT("info",("spider default lock route"));
-      DBUG_PRINT("info",("spider lock_type=%u", this->lock_type));
+      DBUG_PRINT("info",("spider lock_type=%u", wide_handler->lock_type));
       if (
-        this->lock_type == TL_READ ||
-        this->lock_type == TL_READ_NO_INSERT ||
-        this->lock_type == TL_WRITE_LOW_PRIORITY ||
-        this->lock_type == TL_WRITE
+        wide_handler->lock_type == TL_READ ||
+        wide_handler->lock_type == TL_READ_NO_INSERT ||
+        wide_handler->lock_type == TL_WRITE_LOW_PRIORITY ||
+        wide_handler->lock_type == TL_WRITE
       ) {
-        for (
-          roop_count = spider_conn_link_idx_next(share->link_statuses,
-            conn_link_idx, -1, share->link_count,
-            SPIDER_LINK_STATUS_RECOVERY);
-          roop_count < (int) share->link_count;
-          roop_count = spider_conn_link_idx_next(share->link_statuses,
-            conn_link_idx, roop_count, share->link_count,
-            SPIDER_LINK_STATUS_RECOVERY)
+        if (
+          !spider_param_local_lock_table(thd) &&
+          spider_param_semi_table_lock(thd, wide_handler->semi_table_lock)
         ) {
-          if (
-            conns[roop_count] &&
-            conns[roop_count]->table_lock != 1 &&
-            spider_param_semi_table_lock(thd, share->semi_table_lock) &&
-            !spider_param_local_lock_table(thd)
-          ) {
-            SPIDER_CONN *conn = conns[roop_count];
-            int appended = 0;
-            if ((error_num = dbton_handler[conn->dbton_id]->
-              append_lock_tables_list(conn, roop_count, &appended)))
-            {
-              store_error_num = error_num;
-              DBUG_RETURN(to);
-            }
-            if (appended)
-            {
-              conn->table_lock = 3;
-            }
-          }
+          wide_handler->lock_table_type = 2;
         }
       }
       if (
@@ -1236,9 +1195,9 @@ THR_LOCK_DATA **ha_spider::store_lock(
       )
         lock_type = TL_WRITE_ALLOW_WRITE;
     }
-    lock.type = lock_type;
+    wide_handler->lock.type = lock_type;
   }
-  *to++ = &lock;
+  *to++ = &wide_handler->lock;
   DBUG_RETURN(to);
 }
 
@@ -1246,8 +1205,8 @@ int ha_spider::external_lock(
   THD *thd,
   int lock_type
 ) {
-  int error_num, roop_count;
-  bool sync_trx_isolation = spider_param_sync_trx_isolation(thd);
+  int error_num = 0;
+  SPIDER_TRX *trx;
   backup_error_status();
   DBUG_ENTER("ha_spider::external_lock");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -1255,41 +1214,49 @@ int ha_spider::external_lock(
 #if MYSQL_VERSION_ID < 50500
   DBUG_PRINT("info",("spider thd->options=%x", (int) thd->options));
 #endif
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (
+    wide_handler->stage == SPD_HND_STAGE_EXTERNAL_LOCK &&
+    wide_handler->stage_executor != this)
+  {
+    DBUG_RETURN(0);
+  }
+  wide_handler->stage = SPD_HND_STAGE_EXTERNAL_LOCK;
+  wide_handler->stage_executor = this;
+#endif
 #ifdef HANDLER_HAS_NEED_INFO_FOR_AUTO_INC
   info_auto_called = FALSE;
 #endif
 
-  sql_command = thd_sql_command(thd);
-  if (sql_command == SQLCOM_BEGIN)
-    sql_command = SQLCOM_UNLOCK_TABLES;
-  if (
-    sql_command == SQLCOM_UNLOCK_TABLES &&
-    (error_num = spider_check_trx_and_get_conn(thd, this,
-      FALSE))
-  ) {
+  wide_handler->sql_command = thd_sql_command(thd);
+  if (wide_handler->sql_command == SQLCOM_BEGIN)
+    wide_handler->sql_command = SQLCOM_UNLOCK_TABLES;
+
+  trx = spider_get_trx(thd, TRUE, &error_num);
+  if (error_num)
     DBUG_RETURN(error_num);
-  }
+  wide_handler->trx = trx;
 
-  DBUG_PRINT("info",("spider sql_command=%d", sql_command));
-  DBUG_ASSERT(trx == spider_get_trx(thd, TRUE, &error_num));
+  DBUG_PRINT("info",("spider sql_command=%d", wide_handler->sql_command));
 #ifdef HA_CAN_BULK_ACCESS
-  external_lock_cnt++;
+  wide_handler->external_lock_cnt++;
 #endif
   if (
     lock_type == F_UNLCK &&
-    sql_command != SQLCOM_UNLOCK_TABLES
+    wide_handler->sql_command != SQLCOM_UNLOCK_TABLES
   )
     DBUG_RETURN(0);
   if (store_error_num)
     DBUG_RETURN(store_error_num);
+  wide_handler->external_lock_type = lock_type;
 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
   if ((conn_kinds & SPIDER_CONN_KIND_MYSQL))
   {
 #endif
     if (
       /* SQLCOM_RENAME_TABLE and SQLCOM_DROP_DB don't come here */
-      sql_command == SQLCOM_DROP_TABLE ||
-      sql_command == SQLCOM_ALTER_TABLE
+      wide_handler->sql_command == SQLCOM_DROP_TABLE ||
+      wide_handler->sql_command == SQLCOM_ALTER_TABLE
     ) {
       if (trx->locked_connections)
       {
@@ -1299,277 +1266,59 @@ int ha_spider::external_lock(
       }
       DBUG_RETURN(0);
     }
-    if (!conns[search_link_idx])
+    if (unlikely((error_num = spider_internal_start_trx(this))))
     {
-      my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
-        ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
-      DBUG_RETURN(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM);
-    }
-    for (
-      roop_count = spider_conn_link_idx_next(share->link_statuses,
-        conn_link_idx, -1, share->link_count,
-        SPIDER_LINK_STATUS_RECOVERY);
-      roop_count < (int) share->link_count;
-      roop_count = spider_conn_link_idx_next(share->link_statuses,
-        conn_link_idx, roop_count, share->link_count,
-        SPIDER_LINK_STATUS_RECOVERY)
-    ) {
-      if (sql_command == SQLCOM_TRUNCATE)
-        DBUG_RETURN(0);
-      else if (sql_command != SQLCOM_UNLOCK_TABLES)
-      {
-        DBUG_PRINT("info",("spider conns[%d]->join_trx=%u",
-          roop_count, conns[roop_count]->join_trx));
-        if (
-          (!conns[roop_count]->join_trx &&
-            (error_num = spider_internal_start_trx(this, conns[roop_count],
-              roop_count)))
-        ) {
-          if (
-            share->monitoring_kind[roop_count] &&
-            need_mons[roop_count]
-          ) {
-            error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
-                share,
-                roop_count,
-                (uint32) share->monitoring_sid[roop_count],
-                share->table_name,
-                share->table_name_length,
-                conn_link_idx[roop_count],
-                NULL,
-                0,
-                share->monitoring_kind[roop_count],
-                share->monitoring_limit[roop_count],
-                share->monitoring_flag[roop_count],
-                TRUE
-              );
-          }
-          DBUG_RETURN(check_error_mode(error_num));
-        }
-        result_list.lock_type = lock_type;
-        reset_first_link_idx();
-        if (
-          conns[roop_count]->semi_trx_isolation == -2 &&
-          conns[roop_count]->semi_trx_isolation_chk == TRUE &&
-          sync_trx_isolation &&
-          spider_param_semi_trx_isolation(trx->thd) >= 0
-        ) {
-/*
-          if (conns[roop_count]->trx_isolation !=
-            spider_param_semi_trx_isolation(trx->thd))
-          {
-*/
-            spider_conn_queue_semi_trx_isolation(conns[roop_count],
-              spider_param_semi_trx_isolation(trx->thd));
-/*
-          }
-          conns[roop_count]->semi_trx_isolation =
-            spider_param_semi_trx_isolation(trx->thd);
-          conns[roop_count]->trx_isolation =
-            thd_tx_isolation(conns[roop_count]->thd);
-          DBUG_PRINT("info",("spider conn=%p", conns[roop_count]));
-          DBUG_PRINT("info",("spider conn->trx_isolation=%d",
-            conns[roop_count]->trx_isolation));
-*/
-        } else {
-          if (sync_trx_isolation)
-          {
-            if ((error_num = spider_check_and_set_trx_isolation(
-              conns[roop_count], &need_mons[roop_count])))
-            {
-              if (
-                share->monitoring_kind[roop_count] &&
-                need_mons[roop_count]
-              ) {
-                error_num = spider_ping_table_mon_from_table(
-                    trx,
-                    trx->thd,
-                    share,
-                    roop_count,
-                    (uint32) share->monitoring_sid[roop_count],
-                    share->table_name,
-                    share->table_name_length,
-                    conn_link_idx[roop_count],
-                    NULL,
-                    0,
-                    share->monitoring_kind[roop_count],
-                    share->monitoring_limit[roop_count],
-                    share->monitoring_flag[roop_count],
-                    TRUE
-                  );
-              }
-              DBUG_RETURN(check_error_mode(error_num));
-            }
-          }
-          conns[roop_count]->semi_trx_isolation = -1;
-        }
-      }
-      if (conns[roop_count]->table_lock >= 2)
-      {
-        if (
-          conns[roop_count]->db_conn->have_lock_table_list() &&
-          (error_num = spider_db_lock_tables(this, roop_count))
-        ) {
-          if (
-            share->monitoring_kind[roop_count] &&
-            need_mons[roop_count]
-          ) {
-            error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
-                share,
-                roop_count,
-                (uint32) share->monitoring_sid[roop_count],
-                share->table_name,
-                share->table_name_length,
-                conn_link_idx[roop_count],
-                NULL,
-                0,
-                share->monitoring_kind[roop_count],
-                share->monitoring_limit[roop_count],
-                share->monitoring_flag[roop_count],
-                TRUE
-              );
-          }
-          conns[roop_count]->table_lock = 0;
-          DBUG_RETURN(check_error_mode(error_num));
-        }
-        if (conns[roop_count]->table_lock == 2)
-          conns[roop_count]->table_lock = 1;
-      } else if (sql_command == SQLCOM_UNLOCK_TABLES ||
-        spider_param_internal_unlock(thd) == 1)
-      {
-        if (conns[roop_count]->table_lock == 1)
-        {
-          conns[roop_count]->table_lock = 0;
-          if (!conns[roop_count]->trx_start)
-            conns[roop_count]->disable_reconnect = FALSE;
-          if ((error_num = spider_db_unlock_tables(this, roop_count)))
-          {
-            if (
-              share->monitoring_kind[roop_count] &&
-              need_mons[roop_count]
-            ) {
-              error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  trx->thd,
-                  share,
-                  roop_count,
-                  (uint32) share->monitoring_sid[roop_count],
-                  share->table_name,
-                  share->table_name_length,
-                  conn_link_idx[roop_count],
-                  NULL,
-                  0,
-                  share->monitoring_kind[roop_count],
-                  share->monitoring_limit[roop_count],
-                  share->monitoring_flag[roop_count],
-                  TRUE
-                );
-            }
-            DBUG_RETURN(check_error_mode(error_num));
-          }
-        }
-      }
+      DBUG_RETURN(error_num);
     }
 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
   } else {
-    result_list.lock_type = lock_type;
-    reset_first_link_idx();
     trans_register_ha(trx->thd, FALSE, spider_hton_ptr);
     if (thd_test_options(trx->thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))
       trans_register_ha(trx->thd, TRUE, spider_hton_ptr);
   }
+#endif
 
-  if ((conn_kinds & SPIDER_CONN_KIND_HS_READ))
+  if (wide_handler->lock_table_type > 0 ||
+    wide_handler->sql_command == SQLCOM_UNLOCK_TABLES)
   {
-    SPIDER_CONN *hs_conn;
-    for (
-      roop_count = spider_conn_link_idx_next(share->link_statuses,
-        conn_link_idx, -1, share->link_count,
-        SPIDER_LINK_STATUS_RECOVERY);
-      roop_count < (int) share->link_count;
-      roop_count = spider_conn_link_idx_next(share->link_statuses,
-        conn_link_idx, roop_count, share->link_count,
-        SPIDER_LINK_STATUS_RECOVERY)
-    ) {
-      hs_conn = hs_r_conns[roop_count];
-      if (
-        hs_conn &&
-        hs_conn->hsc_query_id != thd->query_id &&
-        hs_conn->hs_pre_age == hs_conn->hs_age
-      ) {
-        double interval = spider_param_hs_ping_interval(thd);
-        time_t tmp_time = (time_t) time((time_t*) 0);
-        DBUG_PRINT("info",
-          ("spider difftime=%f", difftime(tmp_time, hs_conn->ping_time)));
-        DBUG_PRINT("info", ("spider interval=%f", interval));
-        if (
-          hs_conn->server_lost ||
-          difftime(tmp_time, hs_conn->ping_time) >= interval
-        ) {
-          DBUG_PRINT("info", ("spider hsr[%d] need reconnect", roop_count));
-          hs_conn->hs_pre_age++;
-          hs_conn->ping_time = tmp_time;
+    if (wide_handler->sql_command == SQLCOM_UNLOCK_TABLES)
+    {
+      /* lock tables does not call reset() */
+      /* unlock tables does not call store_lock() */
+      wide_handler->lock_table_type = 0;
+    }
+
+    /* lock/unlock tables */
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+    if (partition_handler_share && partition_handler_share->handlers)
+    {
+      uint roop_count;
+      for (roop_count = 0; roop_count < partition_handler_share->no_parts;
+        ++roop_count)
+      {
+        if (unlikely((error_num =
+          partition_handler_share->handlers[roop_count]->lock_tables())))
+        {
+          DBUG_RETURN(error_num);
         }
-        hs_conn->hsc_query_id = thd->query_id;
       }
-    }
-  }
-  if (
-#if defined(HS_HAS_SQLCOM) && defined(HANDLER_HAS_DIRECT_UPDATE_ROWS)
-    (
-#endif
-      conn_kinds & SPIDER_CONN_KIND_HS_WRITE
-#if defined(HS_HAS_SQLCOM) && defined(HANDLER_HAS_DIRECT_UPDATE_ROWS)
-    ) ||
-    /* for direct_update */
-    sql_command == SQLCOM_HS_UPDATE ||
-    sql_command == SQLCOM_HS_DELETE
+    } else {
 #endif
-  ) {
-    SPIDER_CONN *hs_conn;
-    for (
-      roop_count = spider_conn_link_idx_next(share->link_statuses,
-        conn_link_idx, -1, share->link_count,
-        SPIDER_LINK_STATUS_RECOVERY);
-      roop_count < (int) share->link_count;
-      roop_count = spider_conn_link_idx_next(share->link_statuses,
-        conn_link_idx, roop_count, share->link_count,
-        SPIDER_LINK_STATUS_RECOVERY)
-    ) {
-      hs_conn = hs_w_conns[roop_count];
-      if (
-        hs_conn &&
-        hs_conn->hsc_query_id != thd->query_id &&
-        hs_conn->hs_pre_age == hs_conn->hs_age
-      ) {
-        double interval = spider_param_hs_ping_interval(thd);
-        time_t tmp_time = (time_t) time((time_t*) 0);
-        DBUG_PRINT("info",
-          ("spider difftime=%f", difftime(tmp_time, hs_conn->ping_time)));
-        DBUG_PRINT("info", ("spider interval=%f", interval));
-        if (
-          hs_conn->server_lost ||
-          difftime(tmp_time, hs_conn->ping_time) >= interval
-        ) {
-          DBUG_PRINT("info", ("spider hsw[%d] need reconnect", roop_count));
-          hs_conn->hs_pre_age++;
-          hs_conn->ping_time = tmp_time;
-        }
-        hs_conn->hsc_query_id = thd->query_id;
+      if (unlikely((error_num = lock_tables())))
+      {
+        DBUG_RETURN(error_num);
       }
+#ifdef WITH_PARTITION_STORAGE_ENGINE
     }
-  }
 #endif
+  }
 
-  DBUG_PRINT("info",("spider trx_start=%s", trx->trx_start ? "TRUE" : "FALSE"));
+  DBUG_PRINT("info",("spider trx_start=%s",
+    trx->trx_start ? "TRUE" : "FALSE"));
   /* need to check after spider_internal_start_trx() */
   if (trx->trx_start)
   {
-    switch (sql_command)
+    switch (wide_handler->sql_command)
     {
       case SQLCOM_SELECT:
       case SQLCOM_HA_READ:
@@ -1604,6 +1353,24 @@ int ha_spider::external_lock(
   DBUG_RETURN(0);
 }
 
+int ha_spider::start_stmt(
+  THD *thd,
+  thr_lock_type lock_type
+) {
+  DBUG_ENTER("ha_spider::start_stmt");
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (
+    wide_handler->stage == SPD_HND_STAGE_START_STMT &&
+    wide_handler->stage_executor != this)
+  {
+    DBUG_RETURN(0);
+  }
+  wide_handler->stage = SPD_HND_STAGE_START_STMT;
+  wide_handler->stage_executor = this;
+#endif
+  DBUG_RETURN(0);
+}
+
 int ha_spider::reset()
 {
   int error_num = 0, error_num2, roop_count;
@@ -1673,25 +1440,49 @@ int ha_spider::reset()
 #endif
   result_list.direct_distinct = FALSE;
   store_error_num = 0;
-#ifdef WITH_PARTITION_STORAGE_ENGINE
   if (
-    partition_handler_share &&
-    partition_handler_share->searched_bitmap
+    wide_handler &&
+    wide_handler->sql_command != SQLCOM_END
   ) {
+    wide_handler->sql_command = SQLCOM_END;
+    wide_handler->between_flg = FALSE;
+    wide_handler->idx_bitmap_is_set = FALSE;
+    wide_handler->rnd_bitmap_is_set = FALSE;
+    wide_handler->quick_mode = FALSE;
+    wide_handler->keyread = FALSE;
+    wide_handler->ignore_dup_key = FALSE;
+    wide_handler->write_can_replace = FALSE;
+    wide_handler->insert_with_update = FALSE;
+    wide_handler->low_priority = FALSE;
+    wide_handler->high_priority = FALSE;
+    wide_handler->insert_delayed = FALSE;
+    wide_handler->lock_table_type = 0;
+    wide_handler->semi_trx_isolation_chk = FALSE;
+    wide_handler->semi_trx_chk = FALSE;
     if (!is_clone)
     {
-      partition_handler_share->searched_bitmap = NULL;
-      partition_handler_share->ft_discard_bitmap = NULL;
+      memset(wide_handler->ft_discard_bitmap, 0xFF,
+        no_bytes_in_map(table->read_set));
+      memset(wide_handler->searched_bitmap, 0,
+        no_bytes_in_map(table->read_set));
     }
-    partition_handler_share->between_flg = FALSE;
-    partition_handler_share->idx_bitmap_is_set = FALSE;
-    partition_handler_share->rnd_bitmap_is_set = FALSE;
-  }
+    while (wide_handler->condition)
+    {
+      tmp_cond = wide_handler->condition->next;
+      spider_free(spider_current_trx, wide_handler->condition, MYF(0));
+      wide_handler->condition = tmp_cond;
+    }
+    wide_handler->cond_check = FALSE;
+#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
+    wide_handler->direct_update_fields = NULL;
+#endif
+#ifdef INFO_KIND_FORCE_LIMIT_BEGIN
+    wide_handler->info_limit = 9223372036854775807LL;
+#endif
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+    wide_handler->stage = SPD_HND_STAGE_NONE;
+    wide_handler->stage_executor = NULL;
 #endif
-  if (!is_clone)
-  {
-    memset(ft_discard_bitmap, 0xFF, no_bytes_in_map(table->read_set));
-    memset(searched_bitmap, 0, no_bytes_in_map(table->read_set));
   }
   if (!(tmp_trx = spider_get_trx(thd, TRUE, &error_num2)))
   {
@@ -1701,82 +1492,11 @@ int ha_spider::reset()
   }
   if (share)
   {
-    trx_bak = trx;
-    trx = tmp_trx;
+    trx_bak = wide_handler->trx;
+    wide_handler->trx = tmp_trx;
     if ((error_num2 = spider_db_free_result(this, FALSE)))
       error_num = error_num2;
-    trx = trx_bak;
-/*
-    int semi_table_lock_conn = spider_param_semi_table_lock_connection(thd,
-      share->semi_table_lock_conn);
-    if (semi_table_lock_conn)
-      first_byte = '0' +
-        spider_param_semi_table_lock(thd, share->semi_table_lock);
-    else
-      first_byte = '0';
-    DBUG_PRINT("info",("spider semi_table_lock_conn = %d",
-      semi_table_lock_conn));
-    DBUG_PRINT("info",("spider semi_table_lock = %d",
-      spider_param_semi_table_lock(thd, share->semi_table_lock)));
-    DBUG_PRINT("info",("spider first_byte = %d", first_byte));
-    if (tmp_trx->spider_thread_id != spider_thread_id ||
-      (tmp_trx->trx_conn_adjustment != trx_conn_adjustment &&
-        tmp_trx->trx_conn_adjustment - 1 != trx_conn_adjustment) ||
-      first_byte != *conn_keys[0]
-    ) {
-      DBUG_PRINT("info",(first_byte != *conn_keys[0] ?
-        "spider change conn type" : tmp_trx != trx ? "spider change thd" :
-        "spider next trx"));
-      trx = tmp_trx;
-      spider_thread_id = tmp_trx->spider_thread_id;
-      trx_conn_adjustment = tmp_trx->trx_conn_adjustment;
-
-      first_byte_bak = *conn_keys[0];
-      *conn_keys[0] = first_byte;
-      for (
-        roop_count = spider_conn_link_idx_next(share->link_statuses,
-          conn_link_idx, -1, share->link_count,
-          SPIDER_LINK_STATUS_RECOVERY);
-        roop_count < share->link_count;
-        roop_count = spider_conn_link_idx_next(share->link_statuses,
-          conn_link_idx, roop_count, share->link_count,
-          SPIDER_LINK_STATUS_RECOVERY)
-      ) {
-        *conn_keys[roop_count] = first_byte;
-        if (
-          !(conns[roop_count] =
-            spider_get_conn(share, roop_count, conn_keys[roop_count], trx,
-              this, FALSE, TRUE, SPIDER_CONN_KIND_MYSQL, &error_num))
-        ) {
-          if (
-            share->monitoring_kind[roop_count] &&
-            need_mons[roop_count]
-          ) {
-            error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
-                share,
-                roop_count,
-                (uint32) share->monitoring_sid[roop_count],
-                share->table_name,
-                share->table_name_length,
-                conn_link_idx[roop_count],
-                NULL,
-                0,
-                share->monitoring_kind[roop_count],
-                share->monitoring_limit[roop_count],
-                share->monitoring_flag[roop_count],
-                TRUE
-              );
-          }
-          DBUG_PRINT("info",("spider get conn error"));
-          *conn_keys[0] = first_byte_bak;
-          conns[0] = NULL;
-          DBUG_RETURN(error_num);
-        }
-      }
-    }
-*/
+    wide_handler->trx = trx_bak;
     memset(need_mons, 0, sizeof(int) * share->link_count);
     memset(result_list.casual_read, 0, sizeof(int) * share->link_count);
     rm_bulk_tmp_table();
@@ -1806,19 +1526,12 @@ int ha_spider::reset()
       }
     }
   }
-  quick_mode = FALSE;
-  keyread = FALSE;
-  ignore_dup_key = FALSE;
-  write_can_replace = FALSE;
-  insert_with_update = FALSE;
-  low_priority = FALSE;
-  high_priority = FALSE;
-  insert_delayed = FALSE;
+  dml_inited = FALSE;
   use_pre_call = FALSE;
   use_pre_action = FALSE;
   pre_bitmap_checked = FALSE;
   bulk_insert = FALSE;
-  clone_bitmap_init = FALSE;
+  partition_handler_share->clone_bitmap_init = FALSE;
   result_list.tmp_table_join = FALSE;
   result_list.use_union = FALSE;
   result_list.use_both_key = FALSE;
@@ -1826,13 +1539,6 @@ int ha_spider::reset()
   conn_kinds = SPIDER_CONN_KIND_MYSQL;
   use_index_merge = FALSE;
   init_rnd_handler = FALSE;
-  while (condition)
-  {
-    tmp_cond = condition->next;
-    spider_free(spider_current_trx, condition, MYF(0));
-    condition = tmp_cond;
-  }
-  cond_check = FALSE;
 #ifdef HA_MRR_USE_DEFAULT_IMPL
   if (multi_range_keys)
   {
@@ -1855,10 +1561,6 @@ int ha_spider::reset()
 #endif
 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
   do_direct_update = FALSE;
-  direct_update_fields = NULL;
-#endif
-#ifdef INFO_KIND_FORCE_LIMIT_BEGIN
-  info_limit = 9223372036854775807LL;
 #endif
   prev_index_rnd_init = SPD_NONE;
   result_list.have_sql_kind_backup = FALSE;
@@ -1896,55 +1598,64 @@ int ha_spider::extra(
   DBUG_ENTER("ha_spider::extra");
   DBUG_PRINT("info",("spider this=%p", this));
   DBUG_PRINT("info",("spider operation=%d", (int) operation));
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (
+    wide_handler->stage == SPD_HND_STAGE_EXTRA &&
+    wide_handler->stage_executor != this)
+  {
+    DBUG_RETURN(0);
+  }
+  wide_handler->stage = SPD_HND_STAGE_EXTRA;
+  wide_handler->stage_executor = this;
+#endif
   switch (operation)
   {
     case HA_EXTRA_QUICK:
-      quick_mode = TRUE;
+      wide_handler->quick_mode = TRUE;
       break;
     case HA_EXTRA_KEYREAD:
       if (!is_clone)
       {
-        keyread = TRUE;
+        wide_handler->keyread = TRUE;
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-        if (update_request)
+        if (wide_handler->update_request)
         {
           if (check_partitioned())
-            keyread = FALSE;
+            wide_handler->keyread = FALSE;
         }
 #endif
       }
       break;
     case HA_EXTRA_NO_KEYREAD:
-      keyread = FALSE;
+      wide_handler->keyread = FALSE;
       break;
     case HA_EXTRA_IGNORE_DUP_KEY:
-      ignore_dup_key = TRUE;
+      wide_handler->ignore_dup_key = TRUE;
       break;
     case HA_EXTRA_NO_IGNORE_DUP_KEY:
-      ignore_dup_key = FALSE;
+      wide_handler->ignore_dup_key = FALSE;
       break;
     case HA_EXTRA_WRITE_CAN_REPLACE:
-      write_can_replace = TRUE;
+      wide_handler->write_can_replace = TRUE;
       break;
     case HA_EXTRA_WRITE_CANNOT_REPLACE:
-      write_can_replace = FALSE;
+      wide_handler->write_can_replace = FALSE;
       break;
 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
     case HA_EXTRA_INSERT_WITH_UPDATE:
-      insert_with_update = TRUE;
-      check_insert_dup_update_pushdown();
+      wide_handler->insert_with_update = TRUE;
       break;
 #endif
     case HA_EXTRA_ATTACH_CHILDREN:
       DBUG_PRINT("info",("spider HA_EXTRA_ATTACH_CHILDREN"));
-      if (!(trx = spider_get_trx(ha_thd(), TRUE, &error_num)))
+      if (!(wide_handler->trx = spider_get_trx(ha_thd(), TRUE, &error_num)))
         DBUG_RETURN(error_num);
       break;
 #if MYSQL_VERSION_ID < 50500
 #else
     case HA_EXTRA_ADD_CHILDREN_LIST:
       DBUG_PRINT("info",("spider HA_EXTRA_ADD_CHILDREN_LIST"));
-      if (!(trx = spider_get_trx(ha_thd(), TRUE, &error_num)))
+      if (!(wide_handler->trx = spider_get_trx(ha_thd(), TRUE, &error_num)))
         DBUG_RETURN(error_num);
       break;
 #endif
@@ -1967,7 +1678,8 @@ int ha_spider::extra(
           part_num < spider_user_defined_key_parts(key_info);
           key_part++, part_num++
         ) {
-          spider_set_bit(searched_bitmap, key_part->field->field_index);
+          spider_set_bit(wide_handler->searched_bitmap,
+            key_part->field->field_index);
         }
       } else {
         DBUG_PRINT("info",("spider need all columns"));
@@ -1977,7 +1689,7 @@ int ha_spider::extra(
           *field;
           field++
         ) {
-          spider_set_bit(searched_bitmap, (*field)->field_index);
+          spider_set_bit(wide_handler->searched_bitmap, (*field)->field_index);
         }
       }
       break;
@@ -2009,6 +1721,13 @@ int ha_spider::index_init(
     }
   }
 #endif
+  if (!dml_inited)
+  {
+    if (unlikely((error_num = dml_init())))
+    {
+      DBUG_RETURN(error_num);
+    }
+  }
   pushed_pos = NULL;
   active_index = idx;
   result_list.sorted = sorted;
@@ -2020,20 +1739,21 @@ int ha_spider::index_init(
   if (pre_bitmap_checked)
     pre_bitmap_checked = FALSE;
   else {
-    if (result_list.lock_type == F_WRLCK)
+    if (wide_handler->external_lock_type == F_WRLCK)
     {
       pk_update = FALSE;
 /*
       check_and_start_bulk_update(SPD_BU_START_BY_INDEX_OR_RND_INIT);
 */
       if (
-        update_request &&
+        wide_handler->update_request &&
         share->have_recovery_link &&
         (pk_update = spider_check_pk_update(table))
       ) {
         bitmap_set_all(table->read_set);
         if (is_clone)
-          memset(searched_bitmap, 0xFF, no_bytes_in_map(table->read_set));
+          memset(wide_handler->searched_bitmap, 0xFF,
+            no_bytes_in_map(table->read_set));
       }
     }
 
@@ -2127,7 +1847,7 @@ int ha_spider::index_read_map_internal(
   backup_error_status();
   DBUG_ENTER("ha_spider::index_read_map_internal");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (trx->thd->killed)
+  if (wide_handler->trx->thd->killed)
   {
     my_error(ER_QUERY_INTERRUPTED, MYF(0));
     DBUG_RETURN(ER_QUERY_INTERRUPTED);
@@ -2172,7 +1892,7 @@ int ha_spider::index_read_map_internal(
   DBUG_PRINT("info",("spider result_list.finish_flg = FALSE"));
   result_list.finish_flg = FALSE;
   result_list.record_num = 0;
-  if (keyread)
+  if (wide_handler->keyread)
     result_list.keyread = TRUE;
   else
     result_list.keyread = FALSE;
@@ -2287,7 +2007,8 @@ int ha_spider::index_read_map_internal(
 #ifndef WITHOUT_SPIDER_BG_SEARCH
     if (result_list.bgs_phase > 0)
     {
-      if ((error_num = spider_check_and_init_casual_read(trx->thd, this,
+      if ((error_num = spider_check_and_init_casual_read(
+        wide_handler->trx->thd, this,
         roop_count)))
         DBUG_RETURN(error_num);
       if ((error_num = spider_bg_conn_search(this, roop_count, roop_start,
@@ -2299,8 +2020,8 @@ int ha_spider::index_read_map_internal(
           need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              trx,
-              trx->thd,
+              wide_handler->trx,
+              wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -2363,7 +2084,7 @@ int ha_spider::index_read_map_internal(
         conn_kind[roop_count] != SPIDER_CONN_KIND_MYSQL
       ) {
         connection_ids[roop_count] = conn->connection_id;
-        spider_trx_add_bulk_access_conn(trx, conn);
+        spider_trx_add_bulk_access_conn(wide_handler->trx, conn);
         SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
         pthread_mutex_unlock(&conn->mta_conn_mutex);
       } else {
@@ -2383,8 +2104,8 @@ int ha_spider::index_read_map_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -2402,7 +2123,7 @@ int ha_spider::index_read_map_internal(
           DBUG_RETURN(check_error_mode_eof(error_num));
         }
         spider_conn_set_timeout_from_share(conn, roop_count,
-          trx->thd, share);
+          wide_handler->trx->thd, share);
         if (dbton_hdl->execute_sql(
           sql_type,
           conn,
@@ -2417,8 +2138,8 @@ int ha_spider::index_read_map_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -2448,8 +2169,8 @@ int ha_spider::index_read_map_internal(
               need_mons[roop_count]
             ) {
               error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  trx->thd,
+                  wide_handler->trx,
+                  wide_handler->trx->thd,
                   share,
                   roop_count,
                   (uint32) share->monitoring_sid[roop_count],
@@ -2638,7 +2359,7 @@ int ha_spider::index_read_last_map_internal(
   backup_error_status();
   DBUG_ENTER("ha_spider::index_read_last_map_internal");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (trx->thd->killed)
+  if (wide_handler->trx->thd->killed)
   {
     my_error(ER_QUERY_INTERRUPTED, MYF(0));
     DBUG_RETURN(ER_QUERY_INTERRUPTED);
@@ -2692,7 +2413,7 @@ int ha_spider::index_read_last_map_internal(
   DBUG_PRINT("info",("spider result_list.finish_flg = FALSE"));
   result_list.finish_flg = FALSE;
   result_list.record_num = 0;
-  if (keyread)
+  if (wide_handler->keyread)
     result_list.keyread = TRUE;
   else
     result_list.keyread = FALSE;
@@ -2783,7 +2504,8 @@ int ha_spider::index_read_last_map_internal(
 #ifndef WITHOUT_SPIDER_BG_SEARCH
     if (result_list.bgs_phase > 0)
     {
-      if ((error_num = spider_check_and_init_casual_read(trx->thd, this,
+      if ((error_num = spider_check_and_init_casual_read(
+        wide_handler->trx->thd, this,
         roop_count)))
         DBUG_RETURN(error_num);
       if ((error_num = spider_bg_conn_search(this, roop_count, roop_start,
@@ -2795,8 +2517,8 @@ int ha_spider::index_read_last_map_internal(
           need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              trx,
-              trx->thd,
+              wide_handler->trx,
+              wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -2856,7 +2578,7 @@ int ha_spider::index_read_last_map_internal(
       if (is_bulk_access_clone)
       {
         connection_ids[roop_count] = conn->connection_id;
-        spider_trx_add_bulk_access_conn(trx, conn);
+        spider_trx_add_bulk_access_conn(wide_handler->trx, conn);
         SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
         pthread_mutex_unlock(&conn->mta_conn_mutex);
       } else {
@@ -2876,8 +2598,8 @@ int ha_spider::index_read_last_map_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -2895,7 +2617,7 @@ int ha_spider::index_read_last_map_internal(
           DBUG_RETURN(check_error_mode_eof(error_num));
         }
         spider_conn_set_timeout_from_share(conn, roop_count,
-          trx->thd, share);
+          wide_handler->trx->thd, share);
         if (dbton_hdl->execute_sql(
           sql_type,
           conn,
@@ -2910,8 +2632,8 @@ int ha_spider::index_read_last_map_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -2941,8 +2663,8 @@ int ha_spider::index_read_last_map_internal(
               need_mons[roop_count]
             ) {
               error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  trx->thd,
+                  wide_handler->trx,
+                  wide_handler->trx->thd,
                   share,
                   roop_count,
                   (uint32) share->monitoring_sid[roop_count],
@@ -3025,7 +2747,7 @@ int ha_spider::index_next(
   backup_error_status();
   DBUG_ENTER("ha_spider::index_next");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (trx->thd->killed)
+  if (wide_handler->trx->thd->killed)
   {
     my_error(ER_QUERY_INTERRUPTED, MYF(0));
     DBUG_RETURN(ER_QUERY_INTERRUPTED);
@@ -3071,7 +2793,7 @@ int ha_spider::index_prev(
   backup_error_status();
   DBUG_ENTER("ha_spider::index_prev");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (trx->thd->killed)
+  if (wide_handler->trx->thd->killed)
   {
     my_error(ER_QUERY_INTERRUPTED, MYF(0));
     DBUG_RETURN(ER_QUERY_INTERRUPTED);
@@ -3118,7 +2840,7 @@ int ha_spider::index_first_internal(
   backup_error_status();
   DBUG_ENTER("ha_spider::index_first_internal");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (trx->thd->killed)
+  if (wide_handler->trx->thd->killed)
   {
     my_error(ER_QUERY_INTERRUPTED, MYF(0));
     DBUG_RETURN(ER_QUERY_INTERRUPTED);
@@ -3161,7 +2883,7 @@ int ha_spider::index_first_internal(
     DBUG_PRINT("info",("spider result_list.finish_flg = FALSE"));
     result_list.finish_flg = FALSE;
     result_list.record_num = 0;
-    if (keyread)
+    if (wide_handler->keyread)
       result_list.keyread = TRUE;
     else
       result_list.keyread = FALSE;
@@ -3253,7 +2975,8 @@ int ha_spider::index_first_internal(
 #ifndef WITHOUT_SPIDER_BG_SEARCH
       if (result_list.bgs_phase > 0)
       {
-        if ((error_num = spider_check_and_init_casual_read(trx->thd, this,
+        if ((error_num = spider_check_and_init_casual_read(
+          wide_handler->trx->thd, this,
           roop_count)))
           DBUG_RETURN(error_num);
         if ((error_num = spider_bg_conn_search(this, roop_count, roop_start,
@@ -3265,8 +2988,8 @@ int ha_spider::index_first_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -3327,7 +3050,7 @@ int ha_spider::index_first_internal(
         if (is_bulk_access_clone)
         {
           connection_ids[roop_count] = conn->connection_id;
-          spider_trx_add_bulk_access_conn(trx, conn);
+          spider_trx_add_bulk_access_conn(wide_handler->trx, conn);
           SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
           pthread_mutex_unlock(&conn->mta_conn_mutex);
         } else {
@@ -3347,8 +3070,8 @@ int ha_spider::index_first_internal(
               need_mons[roop_count]
             ) {
               error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  trx->thd,
+                  wide_handler->trx,
+                  wide_handler->trx->thd,
                   share,
                   roop_count,
                   (uint32) share->monitoring_sid[roop_count],
@@ -3366,7 +3089,7 @@ int ha_spider::index_first_internal(
             DBUG_RETURN(check_error_mode_eof(error_num));
           }
           spider_conn_set_timeout_from_share(conn, roop_count,
-            trx->thd, share);
+            wide_handler->trx->thd, share);
           if (dbton_hdl->execute_sql(
             sql_type,
             conn,
@@ -3381,8 +3104,8 @@ int ha_spider::index_first_internal(
               need_mons[roop_count]
             ) {
               error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  trx->thd,
+                  wide_handler->trx,
+                  wide_handler->trx->thd,
                   share,
                   roop_count,
                   (uint32) share->monitoring_sid[roop_count],
@@ -3412,8 +3135,8 @@ int ha_spider::index_first_internal(
                 need_mons[roop_count]
               ) {
                 error_num = spider_ping_table_mon_from_table(
-                    trx,
-                    trx->thd,
+                    wide_handler->trx,
+                    wide_handler->trx->thd,
                     share,
                     roop_count,
                     (uint32) share->monitoring_sid[roop_count],
@@ -3506,7 +3229,7 @@ int ha_spider::index_last_internal(
   backup_error_status();
   DBUG_ENTER("ha_spider::index_last_internal");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (trx->thd->killed)
+  if (wide_handler->trx->thd->killed)
   {
     my_error(ER_QUERY_INTERRUPTED, MYF(0));
     DBUG_RETURN(ER_QUERY_INTERRUPTED);
@@ -3549,7 +3272,7 @@ int ha_spider::index_last_internal(
     DBUG_PRINT("info",("spider result_list.finish_flg = FALSE"));
     result_list.finish_flg = FALSE;
     result_list.record_num = 0;
-    if (keyread)
+    if (wide_handler->keyread)
       result_list.keyread = TRUE;
     else
       result_list.keyread = FALSE;
@@ -3641,7 +3364,8 @@ int ha_spider::index_last_internal(
 #ifndef WITHOUT_SPIDER_BG_SEARCH
       if (result_list.bgs_phase > 0)
       {
-        if ((error_num = spider_check_and_init_casual_read(trx->thd, this,
+        if ((error_num = spider_check_and_init_casual_read(
+          wide_handler->trx->thd, this,
           roop_count)))
           DBUG_RETURN(error_num);
         if ((error_num = spider_bg_conn_search(this, roop_count, roop_start,
@@ -3653,8 +3377,8 @@ int ha_spider::index_last_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -3715,7 +3439,7 @@ int ha_spider::index_last_internal(
         if (is_bulk_access_clone)
         {
           connection_ids[roop_count] = conn->connection_id;
-          spider_trx_add_bulk_access_conn(trx, conn);
+          spider_trx_add_bulk_access_conn(wide_handler->trx, conn);
           SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
           pthread_mutex_unlock(&conn->mta_conn_mutex);
         } else {
@@ -3735,8 +3459,8 @@ int ha_spider::index_last_internal(
               need_mons[roop_count]
             ) {
               error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  trx->thd,
+                  wide_handler->trx,
+                  wide_handler->trx->thd,
                   share,
                   roop_count,
                   (uint32) share->monitoring_sid[roop_count],
@@ -3754,7 +3478,7 @@ int ha_spider::index_last_internal(
             DBUG_RETURN(check_error_mode_eof(error_num));
           }
           spider_conn_set_timeout_from_share(conn, roop_count,
-            trx->thd, share);
+            wide_handler->trx->thd, share);
           if (dbton_hdl->execute_sql(
             sql_type,
             conn,
@@ -3769,8 +3493,8 @@ int ha_spider::index_last_internal(
               need_mons[roop_count]
             ) {
               error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  trx->thd,
+                  wide_handler->trx,
+                  wide_handler->trx->thd,
                   share,
                   roop_count,
                   (uint32) share->monitoring_sid[roop_count],
@@ -3800,8 +3524,8 @@ int ha_spider::index_last_internal(
                 need_mons[roop_count]
               ) {
                 error_num = spider_ping_table_mon_from_table(
-                    trx,
-                    trx->thd,
+                    wide_handler->trx,
+                    wide_handler->trx->thd,
                     share,
                     roop_count,
                     (uint32) share->monitoring_sid[roop_count],
@@ -3895,7 +3619,7 @@ int ha_spider::index_next_same(
   backup_error_status();
   DBUG_ENTER("ha_spider::index_next_same");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (trx->thd->killed)
+  if (wide_handler->trx->thd->killed)
   {
     my_error(ER_QUERY_INTERRUPTED, MYF(0));
     DBUG_RETURN(ER_QUERY_INTERRUPTED);
@@ -3947,7 +3671,7 @@ int ha_spider::read_range_first_internal(
   backup_error_status();
   DBUG_ENTER("ha_spider::read_range_first_internal");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (trx->thd->killed)
+  if (wide_handler->trx->thd->killed)
   {
     my_error(ER_QUERY_INTERRUPTED, MYF(0));
     DBUG_RETURN(ER_QUERY_INTERRUPTED);
@@ -3997,7 +3721,7 @@ int ha_spider::read_range_first_internal(
   DBUG_PRINT("info",("spider result_list.finish_flg = FALSE"));
   result_list.finish_flg = FALSE;
   result_list.record_num = 0;
-  if (keyread)
+  if (wide_handler->keyread)
     result_list.keyread = TRUE;
   else
     result_list.keyread = FALSE;
@@ -4089,7 +3813,8 @@ int ha_spider::read_range_first_internal(
 #ifndef WITHOUT_SPIDER_BG_SEARCH
     if (result_list.bgs_phase > 0)
     {
-      if ((error_num = spider_check_and_init_casual_read(trx->thd, this,
+      if ((error_num = spider_check_and_init_casual_read(
+        wide_handler->trx->thd, this,
         roop_count)))
         DBUG_RETURN(error_num);
       if ((error_num = spider_bg_conn_search(this, roop_count, roop_start,
@@ -4101,8 +3826,8 @@ int ha_spider::read_range_first_internal(
           need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              trx,
-              trx->thd,
+              wide_handler->trx,
+              wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -4162,7 +3887,7 @@ int ha_spider::read_range_first_internal(
       if (is_bulk_access_clone)
       {
         connection_ids[roop_count] = conn->connection_id;
-        spider_trx_add_bulk_access_conn(trx, conn);
+        spider_trx_add_bulk_access_conn(wide_handler->trx, conn);
         SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
         pthread_mutex_unlock(&conn->mta_conn_mutex);
       } else {
@@ -4182,8 +3907,8 @@ int ha_spider::read_range_first_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -4201,7 +3926,7 @@ int ha_spider::read_range_first_internal(
           DBUG_RETURN(check_error_mode_eof(error_num));
         }
         spider_conn_set_timeout_from_share(conn, roop_count,
-          trx->thd, share);
+          wide_handler->trx->thd, share);
         if (dbton_hdl->execute_sql(
           sql_type,
           conn,
@@ -4216,8 +3941,8 @@ int ha_spider::read_range_first_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -4247,8 +3972,8 @@ int ha_spider::read_range_first_internal(
               need_mons[roop_count]
             ) {
               error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  trx->thd,
+                  wide_handler->trx,
+                  wide_handler->trx->thd,
                   share,
                   roop_count,
                   (uint32) share->monitoring_sid[roop_count],
@@ -4338,7 +4063,7 @@ int ha_spider::read_range_next()
   backup_error_status();
   DBUG_ENTER("ha_spider::read_range_next");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (trx->thd->killed)
+  if (wide_handler->trx->thd->killed)
   {
     my_error(ER_QUERY_INTERRUPTED, MYF(0));
     DBUG_RETURN(ER_QUERY_INTERRUPTED);
@@ -4390,17 +4115,18 @@ ha_rows ha_spider::multi_range_read_info_const(
   DBUG_PRINT("info",("spider this=%p", this));
   if (!pre_bitmap_checked)
   {
-    if (result_list.lock_type == F_WRLCK)
+    if (wide_handler->external_lock_type == F_WRLCK)
     {
       pk_update = FALSE;
       if (
-        update_request &&
+        wide_handler->update_request &&
         share->have_recovery_link &&
         (pk_update = spider_check_pk_update(table))
       ) {
         bitmap_set_all(table->read_set);
         if (is_clone)
-          memset(searched_bitmap, 0xFF, no_bytes_in_map(table->read_set));
+          memset(wide_handler->searched_bitmap, 0xFF,
+            no_bytes_in_map(table->read_set));
       }
     }
 
@@ -4454,17 +4180,18 @@ ha_rows ha_spider::multi_range_read_info(
   DBUG_PRINT("info",("spider this=%p", this));
   if (!pre_bitmap_checked)
   {
-    if (result_list.lock_type == F_WRLCK)
+    if (wide_handler->external_lock_type == F_WRLCK)
     {
       pk_update = FALSE;
       if (
-        update_request &&
+        wide_handler->update_request &&
         share->have_recovery_link &&
         (pk_update = spider_check_pk_update(table))
       ) {
         bitmap_set_all(table->read_set);
         if (is_clone)
-          memset(searched_bitmap, 0xFF, no_bytes_in_map(table->read_set));
+          memset(wide_handler->searched_bitmap, 0xFF,
+            no_bytes_in_map(table->read_set));
       }
     }
 
@@ -4499,7 +4226,7 @@ int ha_spider::multi_range_read_init(
   uint mode,
   HANDLER_BUFFER *buf
 ) {
-  bka_mode = spider_param_bka_mode(trx->thd, share->bka_mode);
+  bka_mode = spider_param_bka_mode(wide_handler->trx->thd, share->bka_mode);
   backup_error_status();
   DBUG_ENTER("ha_spider::multi_range_read_init");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -4546,12 +4273,12 @@ int ha_spider::read_multi_range_first_internal(
   backup_error_status();
   DBUG_ENTER("ha_spider::multi_range_read_next_first");
 #else
-  bka_mode = spider_param_bka_mode(trx->thd, share->bka_mode);
+  bka_mode = spider_param_bka_mode(wide_handler->trx->thd, share->bka_mode);
   backup_error_status();
   DBUG_ENTER("ha_spider::read_multi_range_first_internal");
 #endif
   DBUG_PRINT("info",("spider this=%p", this));
-  if (trx->thd->killed)
+  if (wide_handler->trx->thd->killed)
   {
     my_error(ER_QUERY_INTERRUPTED, MYF(0));
     DBUG_RETURN(ER_QUERY_INTERRUPTED);
@@ -4606,7 +4333,7 @@ int ha_spider::read_multi_range_first_internal(
     result_list.multi_split_read <= 1 ||
     (sql_kinds & SPIDER_SQL_KIND_HANDLER)
   ) {
-    if (keyread)
+    if (wide_handler->keyread)
       result_list.keyread = TRUE;
     else
       result_list.keyread = FALSE;
@@ -4721,7 +4448,8 @@ int ha_spider::read_multi_range_first_internal(
 #ifndef WITHOUT_SPIDER_BG_SEARCH
         if (result_list.bgs_phase > 0)
         {
-          if ((error_num = spider_check_and_init_casual_read(trx->thd, this,
+          if ((error_num = spider_check_and_init_casual_read(
+            wide_handler->trx->thd, this,
             roop_count)))
             DBUG_RETURN(error_num);
           error_num = spider_bg_conn_search(this, roop_count, roop_start,
@@ -4733,8 +4461,8 @@ int ha_spider::read_multi_range_first_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -4793,7 +4521,7 @@ int ha_spider::read_multi_range_first_internal(
           if (is_bulk_access_clone)
           {
             connection_ids[roop_count] = conn->connection_id;
-            spider_trx_add_bulk_access_conn(trx, conn);
+            spider_trx_add_bulk_access_conn(wide_handler->trx, conn);
             SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
             pthread_mutex_unlock(&conn->mta_conn_mutex);
 #ifdef HA_MRR_USE_DEFAULT_IMPL
@@ -4819,8 +4547,8 @@ int ha_spider::read_multi_range_first_internal(
                 need_mons[roop_count]
               ) {
                 error_num = spider_ping_table_mon_from_table(
-                    trx,
-                    trx->thd,
+                    wide_handler->trx,
+                    wide_handler->trx->thd,
                     share,
                     roop_count,
                     (uint32) share->monitoring_sid[roop_count],
@@ -4839,7 +4567,7 @@ int ha_spider::read_multi_range_first_internal(
             if (!error_num)
             {
               spider_conn_set_timeout_from_share(conn, roop_count,
-                trx->thd, share);
+                wide_handler->trx->thd, share);
               if (dbton_hdl->execute_sql(
                 sql_type,
                 conn,
@@ -4854,8 +4582,8 @@ int ha_spider::read_multi_range_first_internal(
                   need_mons[roop_count]
                 ) {
                   error_num = spider_ping_table_mon_from_table(
-                      trx,
-                      trx->thd,
+                      wide_handler->trx,
+                      wide_handler->trx->thd,
                       share,
                       roop_count,
                       (uint32) share->monitoring_sid[roop_count],
@@ -4887,8 +4615,8 @@ int ha_spider::read_multi_range_first_internal(
                   need_mons[roop_count]
                 ) {
                   error_num = spider_ping_table_mon_from_table(
-                      trx,
-                      trx->thd,
+                      wide_handler->trx,
+                      wide_handler->trx->thd,
                       share,
                       roop_count,
                       (uint32) share->monitoring_sid[roop_count],
@@ -4987,7 +4715,7 @@ int ha_spider::read_multi_range_first_internal(
     if (error_num)
       DBUG_RETURN(check_error_mode_eof(error_num));
   } else {
-    bool tmp_high_priority = high_priority;
+    bool tmp_high_priority = wide_handler->high_priority;
     bool have_multi_range;
 #ifdef HA_MRR_USE_DEFAULT_IMPL
     const uchar *first_mrr_start_key;
@@ -4996,7 +4724,7 @@ int ha_spider::read_multi_range_first_internal(
     uint first_mrr_end_key_length;
     have_second_range = FALSE;
 #endif
-    if (keyread)
+    if (wide_handler->keyread)
       result_list.keyread = TRUE;
     else
       result_list.keyread = FALSE;
@@ -5382,7 +5110,7 @@ int ha_spider::read_multi_range_first_internal(
             (error_num = set_union_table_name_pos_sql())
           )
             DBUG_RETURN(error_num);
-          high_priority = FALSE;
+          wide_handler->high_priority = FALSE;
           if (
             share->key_hint &&
             (error_num = append_hint_after_table_sql_part(
@@ -5457,7 +5185,7 @@ int ha_spider::read_multi_range_first_internal(
 #ifdef HA_MRR_USE_DEFAULT_IMPL
         while (!range_res);
 #endif
-        high_priority = tmp_high_priority;
+        wide_handler->high_priority = tmp_high_priority;
         if ((error_num = append_union_all_end_sql_part(
           SPIDER_SQL_TYPE_SELECT_SQL)))
           DBUG_RETURN(error_num);
@@ -5516,7 +5244,8 @@ int ha_spider::read_multi_range_first_internal(
 #ifndef WITHOUT_SPIDER_BG_SEARCH
         if (result_list.bgs_phase > 0)
         {
-          if ((error_num = spider_check_and_init_casual_read(trx->thd, this,
+          if ((error_num = spider_check_and_init_casual_read(
+            wide_handler->trx->thd, this,
             roop_count)))
             DBUG_RETURN(error_num);
           if ((error_num = spider_bg_conn_search(this, roop_count, roop_start,
@@ -5528,8 +5257,8 @@ int ha_spider::read_multi_range_first_internal(
               need_mons[roop_count]
             ) {
               error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  trx->thd,
+                  wide_handler->trx,
+                  wide_handler->trx->thd,
                   share,
                   roop_count,
                   (uint32) share->monitoring_sid[roop_count],
@@ -5591,7 +5320,7 @@ int ha_spider::read_multi_range_first_internal(
           if (is_bulk_access_clone)
           {
             connection_ids[roop_count] = conn->connection_id;
-            spider_trx_add_bulk_access_conn(trx, conn);
+            spider_trx_add_bulk_access_conn(wide_handler->trx, conn);
             SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
             pthread_mutex_unlock(&conn->mta_conn_mutex);
 #ifdef HA_MRR_USE_DEFAULT_IMPL
@@ -5617,8 +5346,8 @@ int ha_spider::read_multi_range_first_internal(
                 need_mons[roop_count]
               ) {
                 error_num = spider_ping_table_mon_from_table(
-                    trx,
-                    trx->thd,
+                    wide_handler->trx,
+                    wide_handler->trx->thd,
                     share,
                     roop_count,
                     (uint32) share->monitoring_sid[roop_count],
@@ -5643,7 +5372,7 @@ int ha_spider::read_multi_range_first_internal(
               spider_set_bit(result_list.tmp_table_created, roop_count);
               result_list.tmp_tables_created = TRUE;
               spider_conn_set_timeout_from_share(conn, roop_count,
-                trx->thd, share);
+                wide_handler->trx->thd, share);
               if (dbton_hdl->execute_sql(
                 SPIDER_SQL_TYPE_TMP_SQL,
                 conn,
@@ -5658,8 +5387,8 @@ int ha_spider::read_multi_range_first_internal(
                   need_mons[roop_count]
                 ) {
                   error_num = spider_ping_table_mon_from_table(
-                      trx,
-                      trx->thd,
+                      wide_handler->trx,
+                      wide_handler->trx->thd,
                       share,
                       roop_count,
                       (uint32) share->monitoring_sid[roop_count],
@@ -5679,7 +5408,7 @@ int ha_spider::read_multi_range_first_internal(
               spider_db_discard_multiple_result(this, roop_count, conn);
             }
             spider_conn_set_timeout_from_share(conn, roop_count,
-              trx->thd, share);
+              wide_handler->trx->thd, share);
             if (dbton_hdl->execute_sql(
               sql_type,
               conn,
@@ -5694,8 +5423,8 @@ int ha_spider::read_multi_range_first_internal(
                 need_mons[roop_count]
               ) {
                 error_num = spider_ping_table_mon_from_table(
-                    trx,
-                    trx->thd,
+                    wide_handler->trx,
+                    wide_handler->trx->thd,
                     share,
                     roop_count,
                     (uint32) share->monitoring_sid[roop_count],
@@ -5725,8 +5454,8 @@ int ha_spider::read_multi_range_first_internal(
                   need_mons[roop_count]
                 ) {
                   error_num = spider_ping_table_mon_from_table(
-                      trx,
-                      trx->thd,
+                      wide_handler->trx,
+                      wide_handler->trx->thd,
                       share,
                       roop_count,
                       (uint32) share->monitoring_sid[roop_count],
@@ -6010,7 +5739,7 @@ int ha_spider::read_multi_range_next(
   DBUG_ENTER("ha_spider::read_multi_range_next");
 #endif
   DBUG_PRINT("info",("spider this=%p", this));
-  if (trx->thd->killed)
+  if (wide_handler->trx->thd->killed)
   {
     my_error(ER_QUERY_INTERRUPTED, MYF(0));
     DBUG_RETURN(ER_QUERY_INTERRUPTED);
@@ -6170,7 +5899,8 @@ int ha_spider::read_multi_range_next(
 #ifndef WITHOUT_SPIDER_BG_SEARCH
         if (result_list.bgs_phase > 0)
         {
-          if ((error_num = spider_check_and_init_casual_read(trx->thd, this,
+          if ((error_num = spider_check_and_init_casual_read(
+            wide_handler->trx->thd, this,
             roop_count)))
             DBUG_RETURN(error_num);
           error_num = spider_bg_conn_search(this, roop_count, roop_start,
@@ -6182,8 +5912,8 @@ int ha_spider::read_multi_range_next(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -6242,7 +5972,7 @@ int ha_spider::read_multi_range_next(
           if (is_bulk_access_clone)
           {
             connection_ids[roop_count] = conn->connection_id;
-            spider_trx_add_bulk_access_conn(trx, conn);
+            spider_trx_add_bulk_access_conn(wide_handler->trx, conn);
             SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
             pthread_mutex_unlock(&conn->mta_conn_mutex);
 #ifdef HA_MRR_USE_DEFAULT_IMPL
@@ -6268,8 +5998,8 @@ int ha_spider::read_multi_range_next(
                 need_mons[roop_count]
               ) {
                 error_num = spider_ping_table_mon_from_table(
-                    trx,
-                    trx->thd,
+                    wide_handler->trx,
+                    wide_handler->trx->thd,
                     share,
                     roop_count,
                     (uint32) share->monitoring_sid[roop_count],
@@ -6288,7 +6018,7 @@ int ha_spider::read_multi_range_next(
             if (!error_num)
             {
               spider_conn_set_timeout_from_share(conn, roop_count,
-                trx->thd, share);
+                wide_handler->trx->thd, share);
               if (dbton_hdl->execute_sql(
                 sql_type,
                 conn,
@@ -6303,8 +6033,8 @@ int ha_spider::read_multi_range_next(
                   need_mons[roop_count]
                 ) {
                   error_num = spider_ping_table_mon_from_table(
-                      trx,
-                      trx->thd,
+                      wide_handler->trx,
+                      wide_handler->trx->thd,
                       share,
                       roop_count,
                       (uint32) share->monitoring_sid[roop_count],
@@ -6336,8 +6066,8 @@ int ha_spider::read_multi_range_next(
                   need_mons[roop_count]
                 ) {
                   error_num = spider_ping_table_mon_from_table(
-                      trx,
-                      trx->thd,
+                      wide_handler->trx,
+                      wide_handler->trx->thd,
                       share,
                       roop_count,
                       (uint32) share->monitoring_sid[roop_count],
@@ -6533,7 +6263,7 @@ int ha_spider::read_multi_range_next(
     multi_range_ranges = multi_range_curr;
 #endif
 
-    bool tmp_high_priority = high_priority;
+    bool tmp_high_priority = wide_handler->high_priority;
     bool have_multi_range;
     multi_range_cnt = 0;
     error_num = 0;
@@ -6841,7 +6571,7 @@ int ha_spider::read_multi_range_next(
             (error_num = set_union_table_name_pos_sql())
           )
             DBUG_RETURN(error_num);
-          high_priority = FALSE;
+          wide_handler->high_priority = FALSE;
           if (
             share->key_hint &&
             (error_num = append_hint_after_table_sql_part(
@@ -6911,7 +6641,7 @@ int ha_spider::read_multi_range_next(
 #ifdef HA_MRR_USE_DEFAULT_IMPL
         while (!range_res);
 #endif
-        high_priority = tmp_high_priority;
+        wide_handler->high_priority = tmp_high_priority;
         if ((error_num =
           append_union_all_end_sql_part(SPIDER_SQL_TYPE_SELECT_SQL)))
           DBUG_RETURN(error_num);
@@ -6969,7 +6699,8 @@ int ha_spider::read_multi_range_next(
 #ifndef WITHOUT_SPIDER_BG_SEARCH
         if (result_list.bgs_phase > 0)
         {
-          if ((error_num = spider_check_and_init_casual_read(trx->thd, this,
+          if ((error_num = spider_check_and_init_casual_read(
+            wide_handler->trx->thd, this,
             roop_count)))
             DBUG_RETURN(error_num);
           if ((error_num = spider_bg_conn_search(this, roop_count, roop_start,
@@ -6981,8 +6712,8 @@ int ha_spider::read_multi_range_next(
               need_mons[roop_count]
             ) {
               error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  trx->thd,
+                  wide_handler->trx,
+                  wide_handler->trx->thd,
                   share,
                   roop_count,
                   (uint32) share->monitoring_sid[roop_count],
@@ -7044,7 +6775,7 @@ int ha_spider::read_multi_range_next(
           if (is_bulk_access_clone)
           {
             connection_ids[roop_count] = conn->connection_id;
-            spider_trx_add_bulk_access_conn(trx, conn);
+            spider_trx_add_bulk_access_conn(wide_handler->trx, conn);
             SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
             pthread_mutex_unlock(&conn->mta_conn_mutex);
 #ifdef HA_MRR_USE_DEFAULT_IMPL
@@ -7070,8 +6801,8 @@ int ha_spider::read_multi_range_next(
                 need_mons[roop_count]
               ) {
                 error_num = spider_ping_table_mon_from_table(
-                    trx,
-                    trx->thd,
+                    wide_handler->trx,
+                    wide_handler->trx->thd,
                     share,
                     roop_count,
                     (uint32) share->monitoring_sid[roop_count],
@@ -7096,7 +6827,7 @@ int ha_spider::read_multi_range_next(
               spider_set_bit(result_list.tmp_table_created, roop_count);
               result_list.tmp_tables_created = TRUE;
               spider_conn_set_timeout_from_share(conn, roop_count,
-                trx->thd, share);
+                wide_handler->trx->thd, share);
               if (dbton_hdl->execute_sql(
                 SPIDER_SQL_TYPE_TMP_SQL,
                 conn,
@@ -7111,8 +6842,8 @@ int ha_spider::read_multi_range_next(
                   need_mons[roop_count]
                 ) {
                   error_num = spider_ping_table_mon_from_table(
-                      trx,
-                      trx->thd,
+                      wide_handler->trx,
+                      wide_handler->trx->thd,
                       share,
                       roop_count,
                       (uint32) share->monitoring_sid[roop_count],
@@ -7132,7 +6863,7 @@ int ha_spider::read_multi_range_next(
               spider_db_discard_multiple_result(this, roop_count, conn);
             }
             spider_conn_set_timeout_from_share(conn, roop_count,
-              trx->thd, share);
+              wide_handler->trx->thd, share);
             if (dbton_hdl->execute_sql(
               sql_type,
               conn,
@@ -7147,8 +6878,8 @@ int ha_spider::read_multi_range_next(
                 need_mons[roop_count]
               ) {
                 error_num = spider_ping_table_mon_from_table(
-                    trx,
-                    trx->thd,
+                    wide_handler->trx,
+                    wide_handler->trx->thd,
                     share,
                     roop_count,
                     (uint32) share->monitoring_sid[roop_count],
@@ -7178,8 +6909,8 @@ int ha_spider::read_multi_range_next(
                   need_mons[roop_count]
                 ) {
                   error_num = spider_ping_table_mon_from_table(
-                      trx,
-                      trx->thd,
+                      wide_handler->trx,
+                      wide_handler->trx->thd,
                       share,
                       roop_count,
                       (uint32) share->monitoring_sid[roop_count],
@@ -7338,15 +7069,22 @@ int ha_spider::rnd_init(
   DBUG_ENTER("ha_spider::rnd_init");
   DBUG_PRINT("info",("spider this=%p", this));
   DBUG_PRINT("info",("spider scan=%s", scan ? "TRUE" : "FALSE"));
+  if (!dml_inited)
+  {
+    if (unlikely((error_num = dml_init())))
+    {
+      DBUG_RETURN(error_num);
+    }
+  }
   pushed_pos = NULL;
 /*
-  if (result_list.lock_type == F_WRLCK)
+  if (wide_handler->external_lock_type == F_WRLCK)
     check_and_start_bulk_update(SPD_BU_START_BY_INDEX_OR_RND_INIT);
 */
   rnd_scan_and_first = scan;
   if (
     scan &&
-    sql_command != SQLCOM_ALTER_TABLE
+    wide_handler->sql_command != SQLCOM_ALTER_TABLE
   ) {
     spider_set_result_list_param(this);
     pk_update = FALSE;
@@ -7411,14 +7149,15 @@ int ha_spider::rnd_init(
       use_spatial_index = FALSE;
 
       if (
-        update_request &&
+        wide_handler->update_request &&
         share->have_recovery_link &&
-        result_list.lock_type == F_WRLCK &&
+        wide_handler->external_lock_type == F_WRLCK &&
         (pk_update = spider_check_pk_update(table))
       ) {
         bitmap_set_all(table->read_set);
         if (is_clone)
-          memset(searched_bitmap, 0xFF, no_bytes_in_map(table->read_set));
+          memset(wide_handler->searched_bitmap, 0xFF,
+            no_bytes_in_map(table->read_set));
       }
 
       set_select_column_mode();
@@ -7488,17 +7227,17 @@ int ha_spider::rnd_next_internal(
 ) {
   int error_num;
   ha_spider *direct_limit_offset_spider =
-    (ha_spider *) partition_handler_share->creator;
+    (ha_spider *) partition_handler_share->owner;
   backup_error_status();
   DBUG_ENTER("ha_spider::rnd_next_internal");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (trx->thd->killed)
+  if (wide_handler->trx->thd->killed)
   {
     my_error(ER_QUERY_INTERRUPTED, MYF(0));
     DBUG_RETURN(ER_QUERY_INTERRUPTED);
   }
   /* do not copy table data at alter table */
-  if (sql_command == SQLCOM_ALTER_TABLE)
+  if (wide_handler->sql_command == SQLCOM_ALTER_TABLE)
     DBUG_RETURN(HA_ERR_END_OF_FILE);
 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
   do_direct_update = FALSE;
@@ -7644,7 +7383,8 @@ int ha_spider::rnd_next_internal(
 #ifndef WITHOUT_SPIDER_BG_SEARCH
       if (result_list.bgs_phase > 0)
       {
-        if ((error_num = spider_check_and_init_casual_read(trx->thd, this,
+        if ((error_num = spider_check_and_init_casual_read(
+          wide_handler->trx->thd, this,
           roop_count)))
           DBUG_RETURN(error_num);
         if ((error_num = spider_bg_conn_search(this, roop_count, roop_start,
@@ -7656,8 +7396,8 @@ int ha_spider::rnd_next_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -7716,8 +7456,8 @@ int ha_spider::rnd_next_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -7735,7 +7475,7 @@ int ha_spider::rnd_next_internal(
           DBUG_RETURN(check_error_mode_eof(error_num));
         }
         spider_conn_set_timeout_from_share(conn, roop_count,
-          trx->thd, share);
+          wide_handler->trx->thd, share);
         if (dbton_hdl->execute_sql(
           sql_type,
           conn,
@@ -7750,8 +7490,8 @@ int ha_spider::rnd_next_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -7781,8 +7521,8 @@ int ha_spider::rnd_next_internal(
               need_mons[roop_count]
             ) {
               error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  trx->thd,
+                  wide_handler->trx,
+                  wide_handler->trx->thd,
                   share,
                   roop_count,
                   (uint32) share->monitoring_sid[roop_count],
@@ -7899,15 +7639,15 @@ void ha_spider::position(
     DBUG_PRINT("info",("spider self position"));
     DBUG_PRINT("info",
       ("spider current_row_num=%lld", result_list.current_row_num));
-    if (!position_bitmap_init)
+    if (!wide_handler->position_bitmap_init)
     {
       if (select_column_mode)
       {
         spider_db_handler *dbton_hdl =
           dbton_handler[result_list.current->dbton_id];
-        dbton_hdl->copy_minimum_select_bitmap(position_bitmap);
+        dbton_hdl->copy_minimum_select_bitmap(wide_handler->position_bitmap);
       }
-      position_bitmap_init = TRUE;
+      wide_handler->position_bitmap_init = TRUE;
     }
     spider_db_create_position(this, (SPIDER_POSITION *) ref);
   }
@@ -7929,7 +7669,7 @@ int ha_spider::rnd_pos(
       ((uchar *) table->read_set->bitmap)[roop_count]));
   }
 #endif
-  if (trx->thd->killed)
+  if (wide_handler->trx->thd->killed)
   {
     my_error(ER_QUERY_INTERRUPTED, MYF(0));
     DBUG_RETURN(ER_QUERY_INTERRUPTED);
@@ -8145,7 +7885,7 @@ int ha_spider::ft_read_internal(
   backup_error_status();
   DBUG_ENTER("ha_spider::ft_read_internal");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (trx->thd->killed)
+  if (wide_handler->trx->thd->killed)
   {
     my_error(ER_QUERY_INTERRUPTED, MYF(0));
     DBUG_RETURN(ER_QUERY_INTERRUPTED);
@@ -8165,7 +7905,7 @@ int ha_spider::ft_read_internal(
     DBUG_PRINT("info",("spider result_list.finish_flg = FALSE"));
     result_list.finish_flg = FALSE;
     result_list.record_num = 0;
-    if (keyread)
+    if (wide_handler->keyread)
       result_list.keyread = TRUE;
     else
       result_list.keyread = FALSE;
@@ -8266,7 +8006,8 @@ int ha_spider::ft_read_internal(
 #ifndef WITHOUT_SPIDER_BG_SEARCH
       if (result_list.bgs_phase > 0)
       {
-        if ((error_num = spider_check_and_init_casual_read(trx->thd, this,
+        if ((error_num = spider_check_and_init_casual_read(
+          wide_handler->trx->thd, this,
           roop_count)))
           DBUG_RETURN(error_num);
         if ((error_num = spider_bg_conn_search(this, roop_count, roop_start,
@@ -8278,8 +8019,8 @@ int ha_spider::ft_read_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -8332,8 +8073,8 @@ int ha_spider::ft_read_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -8350,7 +8091,8 @@ int ha_spider::ft_read_internal(
           }
           DBUG_RETURN(check_error_mode_eof(error_num));
         }
-        spider_conn_set_timeout_from_share(conn, roop_count, trx->thd, share);
+        spider_conn_set_timeout_from_share(conn, roop_count,
+          wide_handler->trx->thd, share);
         if (dbton_hdl->execute_sql(
           SPIDER_SQL_TYPE_SELECT_SQL,
           conn,
@@ -8365,8 +8107,8 @@ int ha_spider::ft_read_internal(
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -8396,8 +8138,8 @@ int ha_spider::ft_read_internal(
               need_mons[roop_count]
             ) {
               error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  trx->thd,
+                  wide_handler->trx,
+                  wide_handler->trx->thd,
                   share,
                   roop_count,
                   (uint32) share->monitoring_sid[roop_count],
@@ -8496,7 +8238,7 @@ int ha_spider::info(
 #ifdef HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT
   auto_inc_temporary = FALSE;
 #endif
-  sql_command = thd_sql_command(thd);
+  wide_handler->sql_command = thd_sql_command(thd);
 /*
   if (
     sql_command == SQLCOM_DROP_TABLE ||
@@ -8517,8 +8259,8 @@ int ha_spider::info(
       }
     }
     if (
-      sql_command == SQLCOM_DROP_TABLE ||
-      sql_command == SQLCOM_ALTER_TABLE
+      wide_handler->sql_command == SQLCOM_DROP_TABLE ||
+      wide_handler->sql_command == SQLCOM_ALTER_TABLE
     )
       DBUG_RETURN(0);
 /*
@@ -8549,7 +8291,7 @@ int ha_spider::info(
         pthread_mutex_unlock(&share->sts_mutex);
       else {
         if ((spider_init_error_table =
-          spider_get_init_error_table(trx, share, FALSE)))
+          spider_get_init_error_table(wide_handler->trx, share, FALSE)))
         {
           DBUG_PRINT("info",("spider diff=%f",
             difftime(tmp_time, spider_init_error_table->init_error_time)));
@@ -8558,7 +8300,7 @@ int ha_spider::info(
             spider_param_table_init_error_interval())
           {
             pthread_mutex_unlock(&share->sts_mutex);
-            if (sql_command == SQLCOM_SHOW_CREATE)
+            if (wide_handler->sql_command == SQLCOM_SHOW_CREATE)
             {
               if (thd->is_error())
               {
@@ -8584,9 +8326,7 @@ int ha_spider::info(
     if (flag & HA_STATUS_AUTO)
     {
       if (
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-        share->partition_share &&
-#endif
+        share->wide_share &&
         tmp_auto_increment_mode == 1 &&
         !share->lgtm_tblhnd_share->auto_increment_init
       ) {
@@ -8619,7 +8359,8 @@ int ha_spider::info(
                 if (
                   spider_init_error_table ||
                   (spider_init_error_table =
-                    spider_get_init_error_table(trx, share, TRUE))
+                    spider_get_init_error_table(wide_handler->trx,
+                      share, TRUE))
                 ) {
                   spider_init_error_table->init_error = error_num;
                   if ((spider_init_error_table->init_error_with_message =
@@ -8632,7 +8373,7 @@ int ha_spider::info(
                 share->init_error = TRUE;
                 share->init = TRUE;
               }
-              if (sql_command == SQLCOM_SHOW_CREATE)
+              if (wide_handler->sql_command == SQLCOM_SHOW_CREATE)
               {
                 if (thd->is_error())
                 {
@@ -8657,8 +8398,8 @@ int ha_spider::info(
                 need_mons[search_link_idx]
               ) {
                 error_num = spider_ping_table_mon_from_table(
-                    trx,
-                    trx->thd,
+                    wide_handler->trx,
+                    wide_handler->trx->thd,
                     share,
                     search_link_idx,
                     (uint32) share->monitoring_sid[search_link_idx],
@@ -8678,7 +8419,8 @@ int ha_spider::info(
                 if (
                   spider_init_error_table ||
                   (spider_init_error_table =
-                    spider_get_init_error_table(trx, share, TRUE))
+                    spider_get_init_error_table(wide_handler->trx,
+                      share, TRUE))
                 ) {
                   spider_init_error_table->init_error = error_num;
 /*
@@ -8695,7 +8437,7 @@ int ha_spider::info(
                 share->init_error = TRUE;
                 share->init = TRUE;
               }
-              if (sql_command == SQLCOM_SHOW_CREATE)
+              if (wide_handler->sql_command == SQLCOM_SHOW_CREATE)
               {
                 if (thd->is_error())
                 {
@@ -8724,7 +8466,7 @@ int ha_spider::info(
               if ((error_num = spider_create_sts_thread(share)))
               {
                 pthread_mutex_unlock(&share->sts_mutex);
-                if (sql_command == SQLCOM_SHOW_CREATE)
+                if (wide_handler->sql_command == SQLCOM_SHOW_CREATE)
                 {
                   if (thd->is_error())
                   {
@@ -8755,7 +8497,7 @@ int ha_spider::info(
     {
       if ((error_num = check_crd()))
       {
-        if (sql_command == SQLCOM_SHOW_CREATE)
+        if (wide_handler->sql_command == SQLCOM_SHOW_CREATE)
         {
           if (thd->is_error())
           {
@@ -8794,8 +8536,7 @@ int ha_spider::info(
 #ifdef HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT
       auto_inc_temporary = FALSE;
 #endif
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-      if (share->partition_share && table->next_number_field)
+      if (share->wide_share && table->next_number_field)
       {
         ulonglong first_value, nb_reserved_values;
         if (
@@ -8832,12 +8573,9 @@ int ha_spider::info(
             share->lgtm_tblhnd_share->auto_increment_value;
         }
       } else {
-#endif
         stats.auto_increment_value =
           share->lgtm_tblhnd_share->auto_increment_value;
-#ifdef WITH_PARTITION_STORAGE_ENGINE
       }
-#endif
     }
   }
   if (flag & HA_STATUS_ERRKEY)
@@ -8876,7 +8614,7 @@ ha_rows ha_spider::records_in_range(
       pthread_mutex_unlock(&share->crd_mutex);
     else {
       if ((spider_init_error_table =
-        spider_get_init_error_table(trx, share, FALSE)))
+        spider_get_init_error_table(wide_handler->trx, share, FALSE)))
       {
         DBUG_PRINT("info",("spider diff=%f",
           difftime(tmp_time, spider_init_error_table->init_error_time)));
@@ -8914,6 +8652,15 @@ ha_rows ha_spider::records_in_range(
       share->static_key_cardinality[inx] == -1 &&
       difftime(tmp_time, share->crd_get_time) >= crd_interval
     ) {
+      if (!dml_inited)
+      {
+        if (unlikely((error_num = dml_init())))
+        {
+          if (check_error_mode(error_num))
+            my_errno = error_num;
+          DBUG_RETURN(HA_POS_ERROR);
+        }
+      }
       if (
         crd_interval == 0 ||
         !pthread_mutex_trylock(&share->crd_mutex)
@@ -8939,8 +8686,8 @@ ha_rows ha_spider::records_in_range(
                 need_mons[search_link_idx]
               ) {
                 error_num = spider_ping_table_mon_from_table(
-                    trx,
-                    trx->thd,
+                    wide_handler->trx,
+                    wide_handler->trx->thd,
                     share,
                     search_link_idx,
                     (uint32) share->monitoring_sid[search_link_idx],
@@ -8960,7 +8707,8 @@ ha_rows ha_spider::records_in_range(
                 if (
                   spider_init_error_table ||
                   (spider_init_error_table =
-                    spider_get_init_error_table(trx, share, TRUE))
+                    spider_get_init_error_table(wide_handler->trx,
+                      share, TRUE))
                 ) {
                   spider_init_error_table->init_error = error_num;
 /*
@@ -9148,6 +8896,15 @@ ha_rows ha_spider::records_in_range(
     DBUG_RETURN((ha_rows) rows);
   } else if (crd_mode == 3)
   {
+    if (!dml_inited)
+    {
+      if (unlikely((error_num = dml_init())))
+      {
+        if (check_error_mode(error_num))
+          my_errno = error_num;
+        DBUG_RETURN(HA_POS_ERROR);
+      }
+    }
     result_list.key_info = &table->key_info[inx];
     DBUG_RETURN(spider_db_explain_select(start_key, end_key, this,
       search_link_idx));
@@ -9180,7 +8937,7 @@ int ha_spider::check_crd()
       pthread_mutex_unlock(&share->crd_mutex);
     else {
       if ((spider_init_error_table =
-        spider_get_init_error_table(trx, share, FALSE)))
+        spider_get_init_error_table(wide_handler->trx, share, FALSE)))
       {
         DBUG_PRINT("info",("spider diff=%f",
           difftime(tmp_time, spider_init_error_table->init_error_time)));
@@ -9239,8 +8996,8 @@ int ha_spider::check_crd()
               need_mons[search_link_idx]
             ) {
               error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  trx->thd,
+                  wide_handler->trx,
+                  wide_handler->trx->thd,
                   share,
                   search_link_idx,
                   (uint32) share->monitoring_sid[search_link_idx],
@@ -9260,7 +9017,7 @@ int ha_spider::check_crd()
               if (
                 spider_init_error_table ||
                 (spider_init_error_table =
-                  spider_get_init_error_table(trx, share, TRUE))
+                  spider_get_init_error_table(wide_handler->trx, share, TRUE))
               ) {
                 spider_init_error_table->init_error = error_num;
                 if ((spider_init_error_table->init_error_with_message =
@@ -9320,7 +9077,7 @@ int ha_spider::pre_records()
   backup_error_status();
   DBUG_ENTER("ha_spider::pre_records");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (sql_command == SQLCOM_ALTER_TABLE)
+  if (wide_handler->sql_command == SQLCOM_ALTER_TABLE)
   {
     DBUG_RETURN(0);
   }
@@ -9328,7 +9085,7 @@ int ha_spider::pre_records()
   {
     DBUG_RETURN(0);
   }
-  THD *thd = trx->thd;
+  THD *thd = wide_handler->trx->thd;
   if (
     spider_param_sync_autocommit(thd) &&
     (!thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))
@@ -9351,7 +9108,7 @@ ha_rows ha_spider::records()
   backup_error_status();
   DBUG_ENTER("ha_spider::records");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (sql_command == SQLCOM_ALTER_TABLE)
+  if (wide_handler->sql_command == SQLCOM_ALTER_TABLE)
   {
     use_pre_action = FALSE;
     DBUG_RETURN(0);
@@ -9362,7 +9119,7 @@ ha_rows ha_spider::records()
   }
   if (!use_pre_action && !this->result_list.direct_limit_offset)
   {
-    THD *thd = trx->thd;
+    THD *thd = wide_handler->trx->thd;
     if (
       spider_param_sync_autocommit(thd) &&
       (!thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))
@@ -9390,7 +9147,14 @@ int ha_spider::pre_calculate_checksum()
   backup_error_status();
   DBUG_ENTER("ha_spider::pre_calculate_checksum");
   DBUG_PRINT("info",("spider this=%p", this));
-  THD *thd = trx->thd;
+  THD *thd = wide_handler->trx->thd;
+  if (!dml_inited)
+  {
+    if (unlikely((error_num = dml_init())))
+    {
+      DBUG_RETURN(error_num);
+    }
+  }
   if (
     spider_param_sync_autocommit(thd) &&
     (!thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))
@@ -9414,9 +9178,16 @@ int ha_spider::calculate_checksum()
   backup_error_status();
   DBUG_ENTER("ha_spider::calculate_checksum");
   DBUG_PRINT("info",("spider this=%p", this));
+  if (!dml_inited)
+  {
+    if (unlikely((error_num = dml_init())))
+    {
+      DBUG_RETURN(error_num);
+    }
+  }
   if (!use_pre_action && !this->result_list.direct_limit_offset)
   {
-    THD *thd = trx->thd;
+    THD *thd = wide_handler->trx->thd;
     if (
       spider_param_sync_autocommit(thd) &&
       (!thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))
@@ -9506,6 +9277,36 @@ ulonglong ha_spider::table_flags() const
   DBUG_RETURN(flags);
 }
 
+ulong ha_spider::table_flags_for_partition()
+{
+  DBUG_ENTER("ha_spider::table_flags_for_partition");
+  DBUG_PRINT("info",("spider this=%p", this));
+  DBUG_RETURN(
+#ifdef HA_PT_CALL_AT_ONCE_STORE_LOCK
+    HA_PT_CALL_AT_ONCE_STORE_LOCK |
+#endif
+#ifdef HA_PT_CALL_AT_ONCE_EXTERNAL_LOCK
+    HA_PT_CALL_AT_ONCE_EXTERNAL_LOCK |
+#endif
+#ifdef HA_PT_CALL_AT_ONCE_START_STMT
+    HA_PT_CALL_AT_ONCE_START_STMT |
+#endif
+#ifdef HA_PT_CALL_AT_ONCE_EXTRA
+    HA_PT_CALL_AT_ONCE_EXTRA |
+#endif
+#ifdef HA_PT_CALL_AT_ONCE_COND_PUSH
+    HA_PT_CALL_AT_ONCE_COND_PUSH |
+#endif
+#ifdef HA_PT_CALL_AT_ONCE_INFO_PUSH
+    HA_PT_CALL_AT_ONCE_INFO_PUSH |
+#endif
+#ifdef HA_PT_CALL_AT_ONCE_TOP_TABLE
+    HA_PT_CALL_AT_ONCE_TOP_TABLE |
+#endif
+    0
+  );
+}
+
 const char *ha_spider::index_type(
   uint key_number
 ) {
@@ -9633,7 +9434,7 @@ int ha_spider::update_auto_increment()
 /*
   if (
     next_insert_id >= auto_inc_interval_for_cur_row.maximum() &&
-    trx->thd->auto_inc_intervals_forced.get_current()
+    wide_handler->trx->thd->auto_inc_intervals_forced.get_current()
   ) {
     force_auto_increment = TRUE;
     DBUG_PRINT("info",("spider force_auto_increment=TRUE"));
@@ -9857,6 +9658,13 @@ int ha_spider::write_row(
     DBUG_RETURN(error_num);
   }
 #endif
+  if (!dml_inited)
+  {
+    if (unlikely((error_num = dml_init())))
+    {
+      DBUG_RETURN(error_num);
+    }
+  }
 #ifndef SPIDER_WITHOUT_HA_STATISTIC_INCREMENT
   ha_statistic_increment(&SSV::ha_write_count);
 #endif
@@ -9919,19 +9727,21 @@ int ha_spider::write_row(
   if (!bulk_insert || bulk_size < 0)
   {
     direct_dup_insert =
-      spider_param_direct_dup_insert(trx->thd, share->direct_dup_insert);
+      spider_param_direct_dup_insert(wide_handler->trx->thd,
+        share->direct_dup_insert);
     DBUG_PRINT("info",("spider direct_dup_insert=%d", direct_dup_insert));
     if ((error_num = spider_db_bulk_insert_init(this, table)))
       DBUG_RETURN(check_error_mode(error_num));
     if (bulk_insert)
       bulk_size =
 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
-        (insert_with_update && !result_list.insert_dup_update_pushdown) ||
+        (wide_handler->insert_with_update &&
+          !result_list.insert_dup_update_pushdown) ||
 #else
-        insert_with_update ||
+        wide_handler->insert_with_update ||
 #endif
-        (!direct_dup_insert && ignore_dup_key) ?
-        0 : spider_param_bulk_size(trx->thd, share->bulk_size);
+        (!direct_dup_insert && wide_handler->ignore_dup_key) ?
+        0 : spider_param_bulk_size(wide_handler->trx->thd, share->bulk_size);
     else
       bulk_size = 0;
   }
@@ -9955,7 +9765,7 @@ int ha_spider::pre_write_row(
 ) {
   int error_num;
   ulonglong option_backup = 0;
-  THD *thd = trx->thd;
+  THD *thd = wide_handler->trx->thd;
   DBUG_ENTER("ha_spider::pre_write_row");
   DBUG_PRINT("info",("spider this=%p", this));
 #if MYSQL_VERSION_ID < 50500
@@ -10193,7 +10003,7 @@ int ha_spider::direct_update_rows_init(
   st_select_lex *select_lex;
   longlong select_limit;
   longlong offset_limit;
-  THD *thd = trx->thd;
+  THD *thd = wide_handler->trx->thd;
   DBUG_ENTER("ha_spider::direct_update_rows_init");
   DBUG_PRINT("info",("spider this=%p", this));
 #ifdef HA_CAN_BULK_ACCESS
@@ -10222,6 +10032,13 @@ int ha_spider::direct_update_rows_init(
 #endif
   }
 #endif
+  if (!dml_inited)
+  {
+    if (unlikely((error_num = dml_init())))
+    {
+      DBUG_RETURN(error_num);
+    }
+  }
   direct_update_init(
     thd,
 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
@@ -10271,7 +10088,7 @@ int ha_spider::direct_update_rows_init(
       }
       result_list.direct_order_limit = TRUE;
     }
-    trx->direct_update_count++;
+    wide_handler->trx->direct_update_count++;
     DBUG_PRINT("info",("spider OK"));
     DBUG_RETURN(0);
   }
@@ -10314,7 +10131,7 @@ int ha_spider::direct_update_rows_init(
       DBUG_RETURN(error_num);
     }
 #endif
-    trx->direct_update_count++;
+    wide_handler->trx->direct_update_count++;
     DBUG_PRINT("info",("spider OK"));
     DBUG_RETURN(0);
   }
@@ -10343,10 +10160,10 @@ int ha_spider::direct_update_rows_init()
   st_select_lex *select_lex;
   longlong select_limit;
   longlong offset_limit;
-  List_iterator<Item> it(*direct_update_fields);
+  List_iterator<Item> it(*wide_handler->direct_update_fields);
   Item *item;
   Field *field;
-  THD *thd = trx->thd;
+  THD *thd = wide_handler->trx->thd;
   DBUG_ENTER("ha_spider::direct_update_rows_init");
   DBUG_PRINT("info",("spider this=%p", this));
   if (thd->variables.time_zone != UTC)
@@ -10395,14 +10212,21 @@ int ha_spider::direct_update_rows_init()
 #endif
   }
 #endif
+  if (!dml_inited)
+  {
+    if (unlikely(dml_init()))
+    {
+      DBUG_RETURN(HA_ERR_WRONG_COMMAND);
+    }
+  }
   direct_update_init(
     thd,
     FALSE
   );
-  if (!condition)
-    cond_check = FALSE;
+  if (!wide_handler->condition)
+    wide_handler->cond_check = FALSE;
   spider_get_select_limit(this, &select_lex, &select_limit, &offset_limit);
-  if (direct_update_fields)
+  if (wide_handler->direct_update_fields)
   {
     if (
 #if MYSQL_VERSION_ID < 50500
@@ -10438,20 +10262,20 @@ int ha_spider::direct_update_rows_init()
       }
       result_list.direct_order_limit = TRUE;
     }
-    trx->direct_update_count++;
+    wide_handler->trx->direct_update_count++;
     DBUG_PRINT("info",("spider OK"));
     DBUG_RETURN(0);
   }
 
   DBUG_PRINT("info",("spider offset_limit=%lld", offset_limit));
-  DBUG_PRINT("info",("spider sql_command=%u", sql_command));
+  DBUG_PRINT("info",("spider sql_command=%u", wide_handler->sql_command));
   DBUG_PRINT("info",("spider do_direct_update=%s",
     do_direct_update ? "TRUE" : "FALSE"));
   if (
     !offset_limit &&
     do_direct_update
   ) {
-    trx->direct_update_count++;
+    wide_handler->trx->direct_update_count++;
     DBUG_PRINT("info",("spider OK"));
     DBUG_RETURN(0);
   }
@@ -10500,6 +10324,13 @@ int ha_spider::pre_direct_update_rows_init(
     bulk_access_link_current->called = TRUE;
     DBUG_RETURN(error_num);
   }
+  if (!dml_inited)
+  {
+    if (unlikely((error_num = dml_init())))
+    {
+      DBUG_RETURN(error_num);
+    }
+  }
 #ifdef SPIDER_MDEV_16246
   pre_direct_init_result = direct_update_rows_init(
     update_fields, mode, ranges, range_count, sorted, new_data);
@@ -10544,6 +10375,13 @@ int ha_spider::pre_direct_update_rows_init()
     bulk_access_link_current->called = TRUE;
     DBUG_RETURN(error_num);
   }
+  if (!dml_inited)
+  {
+    if (unlikely((error_num = dml_init())))
+    {
+      DBUG_RETURN(error_num);
+    }
+  }
 #ifdef SPIDER_MDEV_16246
   pre_direct_init_result = direct_update_rows_init(update_fields);
 #else
@@ -10773,7 +10611,7 @@ int ha_spider::direct_delete_rows_init(
   st_select_lex *select_lex;
   longlong select_limit;
   longlong offset_limit;
-  THD *thd = trx->thd;
+  THD *thd = wide_handler->trx->thd;
   DBUG_ENTER("ha_spider::direct_delete_rows_init");
   DBUG_PRINT("info",("spider this=%p", this));
 #ifdef HA_CAN_BULK_ACCESS
@@ -10795,6 +10633,13 @@ int ha_spider::direct_delete_rows_init(
       mode, ranges, range_count, sorted));
   }
 #endif
+  if (!dml_inited)
+  {
+    if (unlikely((error_num = dml_init())))
+    {
+      DBUG_RETURN(error_num);
+    }
+  }
   direct_update_init(
     thd,
 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
@@ -10841,7 +10686,7 @@ int ha_spider::direct_delete_rows_init(
       }
       result_list.direct_order_limit = TRUE;
     }
-    trx->direct_delete_count++;
+    wide_handler->trx->direct_delete_count++;
     DBUG_PRINT("info",("spider OK"));
     DBUG_RETURN(0);
   }
@@ -10864,7 +10709,7 @@ int ha_spider::direct_delete_rows_init(
       DBUG_RETURN(error_num);
     }
 #endif
-    trx->direct_delete_count++;
+    wide_handler->trx->direct_delete_count++;
     DBUG_PRINT("info",("spider OK"));
     DBUG_RETURN(0);
   }
@@ -10878,7 +10723,7 @@ int ha_spider::direct_delete_rows_init()
   st_select_lex *select_lex;
   longlong select_limit;
   longlong offset_limit;
-  THD *thd = trx->thd;
+  THD *thd = wide_handler->trx->thd;
   DBUG_ENTER("ha_spider::direct_delete_rows_init");
   DBUG_PRINT("info",("spider this=%p", this));
 #ifdef HA_CAN_BULK_ACCESS
@@ -10899,12 +10744,19 @@ int ha_spider::direct_delete_rows_init()
     DBUG_RETURN(bulk_access_link_exec_tgt->spider->direct_delete_rows_init());
   }
 #endif
+  if (!dml_inited)
+  {
+    if (unlikely(dml_init()))
+    {
+      DBUG_RETURN(HA_ERR_WRONG_COMMAND);
+    }
+  }
   direct_update_init(
     thd,
     FALSE
   );
-  if (!condition)
-    cond_check = FALSE;
+  if (!wide_handler->condition)
+    wide_handler->cond_check = FALSE;
   spider_get_select_limit(this, &select_lex, &select_limit, &offset_limit);
   if (
 #if MYSQL_VERSION_ID < 50500
@@ -10939,7 +10791,7 @@ int ha_spider::direct_delete_rows_init()
     }
     result_list.direct_order_limit = TRUE;
   }
-  trx->direct_delete_count++;
+  wide_handler->trx->direct_delete_count++;
   DBUG_PRINT("info",("spider OK"));
   DBUG_RETURN(0);
 }
@@ -10965,6 +10817,13 @@ int ha_spider::pre_direct_delete_rows_init(
     bulk_access_link_current->called = TRUE;
     DBUG_RETURN(error_num);
   }
+  if (!dml_inited)
+  {
+    if (unlikely((error_num = dml_init())))
+    {
+      DBUG_RETURN(error_num);
+    }
+  }
   pre_direct_init_result = direct_delete_rows_init(
     mode, ranges, range_count, sorted);
   DBUG_RETURN(pre_direct_init_result);
@@ -10983,6 +10842,13 @@ int ha_spider::pre_direct_delete_rows_init()
     bulk_access_link_current->called = TRUE;
     DBUG_RETURN(error_num);
   }
+  if (!dml_inited)
+  {
+    if (unlikely((error_num = dml_init())))
+    {
+      DBUG_RETURN(error_num);
+    }
+  }
   pre_direct_init_result = direct_delete_rows_init();
   DBUG_RETURN(pre_direct_init_result);
 }
@@ -11146,7 +11012,8 @@ int ha_spider::delete_all_rows()
     sql_kind[roop_count] = SPIDER_SQL_KIND_SQL;
   if ((error_num = spider_db_delete_all_rows(this)))
     DBUG_RETURN(check_error_mode(error_num));
-  if (sql_command == SQLCOM_TRUNCATE && table->found_next_number_field)
+  if (wide_handler->sql_command == SQLCOM_TRUNCATE &&
+    table->found_next_number_field)
   {
     DBUG_PRINT("info",("spider reset auto increment"));
     pthread_mutex_lock(&share->lgtm_tblhnd_share->auto_increment_mutex);
@@ -11175,7 +11042,7 @@ int ha_spider::truncate()
       table_share->db.str, table_share->table_name.str);
     DBUG_RETURN(ER_SPIDER_READ_ONLY_NUM);
   }
-  sql_command = SQLCOM_TRUNCATE;
+  wide_handler->sql_command = SQLCOM_TRUNCATE;
   if ((error_num = spider_check_trx_and_get_conn(thd, this, FALSE)))
   {
     DBUG_RETURN(error_num);
@@ -11188,7 +11055,8 @@ int ha_spider::truncate()
     sql_kind[roop_count] = SPIDER_SQL_KIND_SQL;
   if ((error_num = spider_db_delete_all_rows(this)))
     DBUG_RETURN(check_error_mode(error_num));
-  if (sql_command == SQLCOM_TRUNCATE && table->found_next_number_field)
+  if (wide_handler->sql_command == SQLCOM_TRUNCATE &&
+    table->found_next_number_field)
   {
     DBUG_PRINT("info",("spider reset auto increment"));
     pthread_mutex_lock(&share->lgtm_tblhnd_share->auto_increment_mutex);
@@ -11208,10 +11076,10 @@ int ha_spider::truncate()
 void ha_spider::bulk_req_exec()
 {
   int need_mon;
-  SPIDER_CONN *conn = trx->bulk_access_conn_first;
+  SPIDER_CONN *conn = wide_handler->trx->bulk_access_conn_first;
   DBUG_ENTER("ha_spider::bulk_req_exec");
   DBUG_PRINT("info",("spider this=%p", this));
-  DBUG_PRINT("info",("spider trx=%p", trx));
+  DBUG_PRINT("info",("spider trx=%p", wide_handler->trx));
   DBUG_PRINT("info",("spider first_conn=%p", conn));
   while (conn)
   {
@@ -11248,7 +11116,7 @@ void ha_spider::bulk_req_exec()
     }
     conn = conn->bulk_access_next;
   }
-  trx->bulk_access_conn_first = NULL;
+  wide_handler->trx->bulk_access_conn_first = NULL;
   DBUG_VOID_RETURN;
 }
 #endif
@@ -11270,7 +11138,7 @@ double ha_spider::read_time(
 ) {
   DBUG_ENTER("ha_spider::read_time");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (keyread)
+  if (wide_handler->keyread)
   {
     DBUG_PRINT("info",("spider read_time(keyread) = %.6f",
       share->read_rate * table->key_info[index].key_length *
@@ -11553,6 +11421,27 @@ void ha_spider::update_create_info(
 ) {
   DBUG_ENTER("ha_spider::update_create_info");
   DBUG_PRINT("info",("spider this=%p", this));
+  if (wide_handler && wide_handler->sql_command == SQLCOM_ALTER_TABLE)
+  {
+    SPIDER_TRX *trx = wide_handler->trx;
+    THD *thd = trx->thd;
+    if (trx->query_id != thd->query_id)
+    {
+      spider_free_trx_alter_table(trx);
+      trx->query_id = thd->query_id;
+      trx->tmp_flg = FALSE;
+    }
+    if (!(SPIDER_ALTER_TABLE*) my_hash_search(&trx->trx_alter_table_hash,
+      (uchar*) share->table_name, share->table_name_length))
+    {
+      if (spider_create_trx_alter_table(trx, share, FALSE))
+      {
+        store_error_num = HA_ERR_OUT_OF_MEM;
+        DBUG_VOID_RETURN;
+      }
+    }
+  }
+
   if (!create_info->connect_string.str)
   {
     create_info->connect_string.str = table->s->connect_string.str;
@@ -12071,6 +11960,54 @@ bool ha_spider::is_fatal_error(
   DBUG_RETURN(TRUE);
 }
 
+int ha_spider::set_top_table_and_fields(
+  TABLE *top_table,
+  Field **top_table_field,
+  uint top_table_fields
+) {
+  DBUG_ENTER("ha_spider::set_top_table_and_fields");
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (
+    wide_handler->stage == SPD_HND_STAGE_SET_TOP_TABLE_AND_FIELDS &&
+    wide_handler->stage_executor != this)
+  {
+    DBUG_RETURN(0);
+  }
+  wide_handler->stage = SPD_HND_STAGE_SET_TOP_TABLE_AND_FIELDS;
+  wide_handler->stage_executor = this;
+#endif
+  if (!wide_handler->set_top_table_fields)
+  {
+    wide_handler->set_top_table_fields = TRUE;
+    wide_handler->top_table = top_table;
+    wide_handler->top_table_field = top_table_field;
+    wide_handler->top_table_fields = top_table_fields;
+  }
+  DBUG_RETURN(0);
+}
+void ha_spider::clear_top_table_fields()
+{
+  DBUG_ENTER("ha_spider::clear_top_table_fields");
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (
+    wide_handler->stage == SPD_HND_STAGE_CLEAR_TOP_TABLE_FIELDS &&
+    wide_handler->stage_executor != this)
+  {
+    DBUG_VOID_RETURN;
+  }
+  wide_handler->stage = SPD_HND_STAGE_CLEAR_TOP_TABLE_FIELDS;
+  wide_handler->stage_executor = this;
+#endif
+  if (wide_handler->set_top_table_fields)
+  {
+    wide_handler->set_top_table_fields = FALSE;
+    wide_handler->top_table = NULL;
+    wide_handler->top_table_field = NULL;
+    wide_handler->top_table_fields = 0;
+  }
+  DBUG_VOID_RETURN;
+}
+
 Field *ha_spider::get_top_table_field(
   uint16 field_index
 ) {
@@ -12084,9 +12021,9 @@ Field *ha_spider::get_top_table_field(
 #endif
   DBUG_PRINT("info",("spider field_index=%u", field_index));
 #ifdef HANDLER_HAS_TOP_TABLE_FIELDS
-  if (set_top_table_fields)
+  if (wide_handler->set_top_table_fields)
   {
-    field = top_table->field[field_index];
+    field = wide_handler->top_table->field[field_index];
   } else {
 #endif
     field = table->field[field_index];
@@ -12110,12 +12047,12 @@ Field *ha_spider::field_exchange(
   DBUG_PRINT("info",("spider in field=%p", field));
   DBUG_PRINT("info",("spider in field->table=%p", field->table));
 #ifdef HANDLER_HAS_TOP_TABLE_FIELDS
-  if (set_top_table_fields)
+  if (wide_handler->set_top_table_fields)
   {
-    DBUG_PRINT("info",("spider top_table=%p", top_table));
-    if (field->table != top_table)
+    DBUG_PRINT("info",("spider top_table=%p", wide_handler->top_table));
+    if (field->table != wide_handler->top_table)
       DBUG_RETURN(NULL);
-    if (!(field = top_table_field[field->field_index]))
+    if (!(field = wide_handler->top_table_field[field->field_index]))
       DBUG_RETURN(NULL);
   } else {
 #endif
@@ -12133,7 +12070,17 @@ const COND *ha_spider::cond_push(
   const COND *cond
 ) {
   DBUG_ENTER("ha_spider::cond_push");
-  cond_check = FALSE;
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (
+    wide_handler->stage == SPD_HND_STAGE_COND_PUSH &&
+    wide_handler->stage_executor != this)
+  {
+    DBUG_RETURN(NULL);
+  }
+  wide_handler->stage = SPD_HND_STAGE_COND_PUSH;
+  wide_handler->stage_executor = this;
+#endif
+  wide_handler->cond_check = FALSE;
   if (cond)
   {
     SPIDER_CONDITION *tmp_cond;
@@ -12142,8 +12089,8 @@ const COND *ha_spider::cond_push(
     )
       DBUG_RETURN(cond);
     tmp_cond->cond = (COND *) cond;
-    tmp_cond->next = condition;
-    condition = tmp_cond;
+    tmp_cond->next = wide_handler->condition;
+    wide_handler->condition = tmp_cond;
   }
   DBUG_RETURN(NULL);
 }
@@ -12151,11 +12098,21 @@ const COND *ha_spider::cond_push(
 void ha_spider::cond_pop()
 {
   DBUG_ENTER("ha_spider::cond_pop");
-  if (condition)
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (
+    wide_handler->stage == SPD_HND_STAGE_COND_POP &&
+    wide_handler->stage_executor != this)
   {
-    SPIDER_CONDITION *tmp_cond = condition->next;
-    spider_free(spider_current_trx, condition, MYF(0));
-    condition = tmp_cond;
+    DBUG_VOID_RETURN;
+  }
+  wide_handler->stage = SPD_HND_STAGE_COND_POP;
+  wide_handler->stage_executor = this;
+#endif
+  if (wide_handler->condition)
+  {
+    SPIDER_CONDITION *tmp_cond = wide_handler->condition->next;
+    spider_free(spider_current_trx, wide_handler->condition, MYF(0));
+    wide_handler->condition = tmp_cond;
   }
   DBUG_VOID_RETURN;
 }
@@ -12167,6 +12124,16 @@ int ha_spider::info_push(
   int error_num = 0;
   DBUG_ENTER("ha_spider::info_push");
   DBUG_PRINT("info",("spider this=%p", this));
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (
+    wide_handler->stage == SPD_HND_STAGE_INFO_PUSH &&
+    wide_handler->stage_executor != this)
+  {
+    DBUG_RETURN(0);
+  }
+  wide_handler->stage = SPD_HND_STAGE_INFO_PUSH;
+  wide_handler->stage_executor = this;
+#endif
 #ifdef HA_CAN_BULK_ACCESS
   if (
 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
@@ -12206,34 +12173,39 @@ int ha_spider::info_push(
       size_t roop_count;
       Field *field;
       SPIDER_HS_UINT32_INFO *tmp_info = (SPIDER_HS_UINT32_INFO *) info;
-      hs_pushed_ret_fields_num = tmp_info->info_size;
-      if (hs_pushed_ret_fields_size < hs_pushed_ret_fields_num)
+      wide_handler->hs_pushed_ret_fields_num = tmp_info->info_size;
+      if (wide_handler->hs_pushed_ret_fields_size <
+        wide_handler->hs_pushed_ret_fields_num)
       {
-        if (hs_pushed_ret_fields)
-          spider_free(spider_current_trx, hs_pushed_ret_fields, MYF(0));
-        if (!(hs_pushed_ret_fields = (uint32 *)
+        if (wide_handler->hs_pushed_ret_fields)
+          spider_free(spider_current_trx, wide_handler->hs_pushed_ret_fields,
+            MYF(0));
+        if (!(wide_handler->hs_pushed_ret_fields = (uint32 *)
           spider_bulk_malloc(spider_current_trx, 17, MYF(MY_WME),
-          &hs_pushed_ret_fields,
-            (uint) (sizeof(uint32) * hs_pushed_ret_fields_num),
+          &wide_handler->hs_pushed_ret_fields,
+            sizeof(uint32) * wide_handler->hs_pushed_ret_fields_num,
           NullS))
         ) {
           DBUG_RETURN(HA_ERR_OUT_OF_MEM);
         }
-        hs_pushed_ret_fields_size = hs_pushed_ret_fields_num;
+        wide_handler->hs_pushed_ret_fields_size =
+          wide_handler->hs_pushed_ret_fields_num;
       }
-      memcpy(hs_pushed_ret_fields, tmp_info->info,
-        sizeof(uint32) * hs_pushed_ret_fields_num);
+      memcpy(wide_handler->hs_pushed_ret_fields, tmp_info->info,
+        sizeof(uint32) * wide_handler->hs_pushed_ret_fields_num);
       bitmap_clear_all(table->read_set);
       bitmap_clear_all(table->write_set);
-      hs_pushed_lcl_fields_num = 0;
-      for (roop_count = 0; roop_count < hs_pushed_ret_fields_num; roop_count++)
+      wide_handler->hs_pushed_lcl_fields_num = 0;
+      for (roop_count = 0; roop_count < wide_handler->hs_pushed_ret_fields_num;
+        roop_count++)
       {
-        field = get_top_table_field(hs_pushed_ret_fields[roop_count]);
+        field = get_top_table_field(
+          wide_handler->hs_pushed_ret_fields[roop_count]);
         if ((field = field_exchange(field)))
         {
           if (!bitmap_is_set(table->read_set, field->field_index))
           {
-            ++hs_pushed_lcl_fields_num;
+            ++wide_handler->hs_pushed_lcl_fields_num;
             bitmap_set_bit(table->read_set, field->field_index);
             bitmap_set_bit(table->write_set, field->field_index);
           }
@@ -12255,172 +12227,168 @@ int ha_spider::info_push(
       }
 #endif
       Field *field;
-      if (hs_pushed_ret_fields)
+      if (wide_handler->hs_pushed_ret_fields)
       {
         field = get_top_table_field(
-          hs_pushed_ret_fields[hs_pushed_strref_num]);
+          wide_handler->hs_pushed_ret_fields[
+            wide_handler->hs_pushed_strref_num]);
       } else {
         field = get_top_table_field(
-          pt_clone_source_handler->hs_pushed_ret_fields[hs_pushed_strref_num]);
+          pt_clone_source_handler->wide_handler->hs_pushed_ret_fields[
+            wide_handler->hs_pushed_strref_num]);
       }
       if (!field_exchange(field))
       {
-        hs_pushed_strref_num++;
+        wide_handler->hs_pushed_strref_num++;
         break;
       }
-      hs_pushed_strref_num++;
-      if ((error_num = push_back_hs_upds(*((SPIDER_HS_STRING_REF*) info))))
+      wide_handler->hs_pushed_strref_num++;
+      if (partition_handler_share && partition_handler_share->handlers)
       {
-        DBUG_RETURN(error_num);
+        size_t roop_count;
+        ha_spider **handlers = partition_handler_share->handlers;
+        for (roop_count = 0; roop_count < partition_handler_share->no_parts;
+          ++roop_count)
+        {
+          if ((error_num = handlers[roop_count]->push_back_hs_upds(
+            *((SPIDER_HS_STRING_REF*) info))))
+          {
+            DBUG_RETURN(error_num);
+          }
+        }
+      } else {
+        if ((error_num = push_back_hs_upds(*((SPIDER_HS_STRING_REF*) info))))
+        {
+          DBUG_RETURN(error_num);
+        }
       }
       break;
     }
     case INFO_KIND_HS_CLEAR_STRING_REF:
       DBUG_PRINT("info",("spider INFO_KIND_HS_CLEAR_STRING_REF"));
-      hs_pushed_strref_num = 0;
-      if ((error_num = reset_hs_upds(SPIDER_SQL_TYPE_UPDATE_HS)))
+      wide_handler->hs_pushed_strref_num = 0;
+      if (partition_handler_share && partition_handler_share->handlers)
       {
-        DBUG_RETURN(error_num);
+        size_t roop_count;
+        ha_spider **handlers = partition_handler_share->handlers;
+        for (roop_count = 0; roop_count < partition_handler_share->no_parts;
+          ++roop_count)
+        {
+          if ((error_num = handlers[roop_count]->reset_hs_upds(
+            SPIDER_SQL_TYPE_UPDATE_HS)))
+          {
+            DBUG_RETURN(error_num);
+          }
+        }
+      } else {
+        if ((error_num = reset_hs_upds(SPIDER_SQL_TYPE_UPDATE_HS)))
+        {
+          DBUG_RETURN(error_num);
+        }
       }
       break;
     case INFO_KIND_HS_INCREMENT_BEGIN:
       DBUG_PRINT("info",("spider INFO_KIND_HS_INCREMENT_BEGIN"));
-      hs_increment = TRUE;
+      wide_handler->hs_increment = TRUE;
       break;
     case INFO_KIND_HS_INCREMENT_END:
       DBUG_PRINT("info",("spider INFO_KIND_HS_INCREMENT_END"));
-      hs_increment = FALSE;
+      wide_handler->hs_increment = FALSE;
       break;
     case INFO_KIND_HS_DECREMENT_BEGIN:
       DBUG_PRINT("info",("spider INFO_KIND_HS_DECREMENT_BEGIN"));
-      hs_decrement = TRUE;
+      wide_handler->hs_decrement = TRUE;
       break;
     case INFO_KIND_HS_DECREMENT_END:
       DBUG_PRINT("info",("spider INFO_KIND_HS_DECREMENT_END"));
-      hs_decrement = FALSE;
+      wide_handler->hs_decrement = FALSE;
       break;
 #endif
 #ifdef INFO_KIND_UPDATE_FIELDS
     case INFO_KIND_UPDATE_FIELDS:
       DBUG_PRINT("info",("spider INFO_KIND_UPDATE_FIELDS"));
-      direct_update_fields = (List<Item> *) info;
-      update_request = TRUE;
+      wide_handler->direct_update_fields = (List<Item> *) info;
+      wide_handler->update_request = TRUE;
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-      if (keyread && check_partitioned())
-        keyread = FALSE;
+      if (wide_handler->keyread && check_partitioned())
+        wide_handler->keyread = FALSE;
 #endif
       break;
 #endif
 #ifdef INFO_KIND_UPDATE_VALUES
     case INFO_KIND_UPDATE_VALUES:
       DBUG_PRINT("info",("spider INFO_KIND_UPDATE_VALUES"));
-      direct_update_values = (List<Item> *) info;
+      wide_handler->direct_update_values = (List<Item> *) info;
       break;
 #endif
 #ifdef INFO_KIND_FORCE_LIMIT_BEGIN
     case INFO_KIND_FORCE_LIMIT_BEGIN:
       DBUG_PRINT("info",("spider INFO_KIND_FORCE_LIMIT_BEGIN"));
-      info_limit = *((longlong *) info);
-/*
-      trx->direct_aggregate_count++;
-*/
+      wide_handler->info_limit = *((longlong *) info);
       break;
     case INFO_KIND_FORCE_LIMIT_END:
       DBUG_PRINT("info",("spider INFO_KIND_FORCE_LIMIT_END"));
-      info_limit = 9223372036854775807LL;
+      wide_handler->info_limit = 9223372036854775807LL;
       break;
 #endif
 #endif
 #ifdef HA_CAN_BULK_ACCESS
     case INFO_KIND_BULK_ACCESS_BEGIN:
       DBUG_PRINT("info",("spider INFO_KIND_BULK_ACCESS_BEGIN"));
-      if (bulk_access_started)
+      if (partition_handler_share && partition_handler_share->handlers)
       {
-        if (!bulk_access_link_current->next)
+        size_t roop_count;
+        ha_spider **handlers = partition_handler_share->handlers;
+        for (roop_count = 0; roop_count < partition_handler_share->no_parts;
+          ++roop_count)
         {
-          if (!(bulk_access_link_current->next = create_bulk_access_link()))
+          if ((error_num = handlers[roop_count]->bulk_access_begin(info)))
           {
-            DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+            DBUG_RETURN(error_num);
           }
-          bulk_access_link_current->next->sequence_num =
-            bulk_access_link_current->sequence_num + 1;
         }
-        bulk_access_link_current = bulk_access_link_current->next;
       } else {
-        if (!bulk_access_link_first)
+        if ((error_num = bulk_access_begin(info)))
         {
-          if (!(bulk_access_link_first = create_bulk_access_link()))
-          {
-            DBUG_RETURN(HA_ERR_OUT_OF_MEM);
-          }
-          bulk_access_link_first->sequence_num = 0;
+          DBUG_RETURN(error_num);
         }
-        bulk_access_link_current = bulk_access_link_first;
-        bulk_access_started = TRUE;
-        bulk_access_executing = FALSE;
-      }
-      if (
-        (error_num = bulk_access_link_current->spider->
-          sync_from_clone_source(this)) ||
-        (error_num = bulk_access_link_current->spider->
-          check_access_kind(trx->thd, (lock_type >= TL_WRITE_ALLOW_WRITE)))
-      ) {
-        DBUG_RETURN(error_num);
       }
-#ifdef HA_CAN_BULK_ACCESS
-#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
-      memset(
-        bulk_access_link_current->spider->result_list.hs_r_bulk_open_index, 0,
-        share->link_bitmap_size);
-      memset(
-        bulk_access_link_current->spider->result_list.hs_w_bulk_open_index, 0,
-        share->link_bitmap_size);
-#endif
-#endif
-/*
-#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
-      if ((error_num = bulk_access_link_current->spider->reset_hs_strs_pos(
-        SPIDER_SQL_TYPE_UPDATE_HS)))
-      {
-        DBUG_RETURN(error_num);
-      }
-#endif
-*/
-      bulk_access_link_current->spider->bulk_access_executing = FALSE;
-      bulk_access_link_current->spider->bulk_access_pre_called = FALSE;
-      bulk_access_link_current->used = TRUE;
-      bulk_access_link_current->called = FALSE;
-      *((void **) info) = bulk_access_link_current;
       break;
     case INFO_KIND_BULK_ACCESS_CURRENT:
       DBUG_PRINT("info",("spider INFO_KIND_BULK_ACCESS_CURRENT"));
-      bulk_access_executing = TRUE;
-      bulk_access_link_exec_tgt = (SPIDER_BULK_ACCESS_LINK *) info;
-      if (bulk_access_link_exec_tgt->spider->pt_clone_source_handler != this)
-      {
-        DBUG_PRINT("info",("spider this=%p", this));
-        DBUG_PRINT("info",("spider pt_clone_source_handler=%p",
-          bulk_access_link_exec_tgt->spider->pt_clone_source_handler));
-        /* partitioned */
-        uint sequence_num = bulk_access_link_exec_tgt->sequence_num;
-        for (
-          bulk_access_link_exec_tgt = bulk_access_link_first;
-          bulk_access_link_exec_tgt;
-          bulk_access_link_exec_tgt = bulk_access_link_exec_tgt->next
-        ) {
-          if (bulk_access_link_exec_tgt->sequence_num >= sequence_num)
+      if (partition_handler_share && partition_handler_share->handlers)
+      {
+        size_t roop_count;
+        ha_spider **handlers = partition_handler_share->handlers;
+        for (roop_count = 0; roop_count < partition_handler_share->no_parts;
+          ++roop_count)
+        {
+          if ((error_num = handlers[roop_count]->bulk_access_current(info)))
           {
-            DBUG_ASSERT(
-              bulk_access_link_exec_tgt->sequence_num == sequence_num);
-            break;
+            DBUG_RETURN(error_num);
           }
         }
+      } else {
+        if ((error_num = bulk_access_current(info)))
+        {
+          DBUG_RETURN(error_num);
+        }
       }
-      bulk_access_link_exec_tgt->spider->bulk_access_executing = TRUE;
       break;
     case INFO_KIND_BULK_ACCESS_END:
       DBUG_PRINT("info",("spider INFO_KIND_BULK_ACCESS_END"));
-      bulk_access_started = FALSE;
+      if (partition_handler_share && partition_handler_share->handlers)
+      {
+        size_t roop_count;
+        ha_spider **handlers = partition_handler_share->handlers;
+        for (roop_count = 0; roop_count < partition_handler_share->no_parts;
+          ++roop_count)
+        {
+          handlers[roop_count]->bulk_access_end();
+        }
+      } else {
+        bulk_access_end();
+      }
       break;
 #endif
     default:
@@ -12486,7 +12454,8 @@ void ha_spider::set_ft_discard_bitmap()
             if (!field || !(field = field_exchange(field)))
               continue;
             DBUG_PRINT("info",("spider clear_bit=%u", field->field_index));
-            spider_clear_bit(ft_discard_bitmap, field->field_index);
+            spider_clear_bit(wide_handler->ft_discard_bitmap,
+              field->field_index);
           }
         }
       }
@@ -12512,7 +12481,8 @@ void ha_spider::set_ft_discard_bitmap()
         if (!field || !(field = field_exchange(field)))
           continue;
         DBUG_PRINT("info",("spider field_index=%u", field->field_index));
-        if (!spider_bit_is_set(ft_discard_bitmap, field->field_index))
+        if (!spider_bit_is_set(wide_handler->ft_discard_bitmap,
+          field->field_index))
         {
           bool match_flag = FALSE;
           List_iterator_fast<Item_func_match> fmi(*select_lex->ftfunc_list);
@@ -12538,7 +12508,8 @@ void ha_spider::set_ft_discard_bitmap()
           if (!match_flag)
           {
             DBUG_PRINT("info",("spider set_bit=%u", field->field_index));
-            spider_set_bit(ft_discard_bitmap, field->field_index);
+            spider_set_bit(wide_handler->ft_discard_bitmap,
+              field->field_index);
           }
         }
       }
@@ -12554,18 +12525,19 @@ void ha_spider::set_searched_bitmap()
   for (roop_count = 0; roop_count < (int) ((table_share->fields + 7) / 8);
     roop_count++)
   {
-    searched_bitmap[roop_count] =
+    wide_handler->searched_bitmap[roop_count] =
       ((uchar *) table->read_set->bitmap)[roop_count] |
       ((uchar *) table->write_set->bitmap)[roop_count];
     DBUG_PRINT("info",("spider roop_count=%d", roop_count));
     DBUG_PRINT("info",("spider searched_bitmap=%d",
-      searched_bitmap[roop_count]));
+      wide_handler->searched_bitmap[roop_count]));
     DBUG_PRINT("info",("spider read_set=%d",
       ((uchar *) table->read_set->bitmap)[roop_count]));
     DBUG_PRINT("info",("spider write_set=%d",
       ((uchar *) table->write_set->bitmap)[roop_count]));
   }
-  if (sql_command == SQLCOM_UPDATE || sql_command == SQLCOM_UPDATE_MULTI)
+  if (wide_handler->sql_command == SQLCOM_UPDATE ||
+    wide_handler->sql_command == SQLCOM_UPDATE_MULTI)
   {
     DBUG_PRINT("info",("spider update option start"));
     Item *item;
@@ -12581,7 +12553,7 @@ void ha_spider::set_searched_bitmap()
           DBUG_PRINT("info",("spider field is for different table"));
           continue;
         }
-        spider_set_bit(searched_bitmap, field->field_index);
+        spider_set_bit(wide_handler->searched_bitmap, field->field_index);
         DBUG_PRINT("info",("spider set searched_bitmap=%u",
           field->field_index));
       } else {
@@ -12595,23 +12567,26 @@ void ha_spider::set_searched_bitmap()
 void ha_spider::set_clone_searched_bitmap()
 {
   DBUG_ENTER("ha_spider::set_clone_searched_bitmap");
-  DBUG_PRINT("info",("spider searched_bitmap=%p", searched_bitmap));
+  DBUG_PRINT("info",("spider searched_bitmap=%p",
+    wide_handler->searched_bitmap));
 #ifndef DBUG_OFF
   int roop_count;
   for (roop_count = 0; roop_count < (int) ((table_share->fields + 7) / 8);
     roop_count++)
     DBUG_PRINT("info", ("spider before searched_bitmap is %x",
-      ((uchar *) searched_bitmap)[roop_count]));
+      ((uchar *) wide_handler->searched_bitmap)[roop_count]));
 #endif
-  memcpy(searched_bitmap, pt_clone_source_handler->searched_bitmap,
+  memcpy(wide_handler->searched_bitmap,
+    pt_clone_source_handler->wide_handler->searched_bitmap,
     (table_share->fields + 7) / 8);
 #ifndef DBUG_OFF
   for (roop_count = 0; roop_count < (int) ((table_share->fields + 7) / 8);
     roop_count++)
     DBUG_PRINT("info", ("spider after searched_bitmap is %x",
-      ((uchar *) searched_bitmap)[roop_count]));
+      ((uchar *) wide_handler->searched_bitmap)[roop_count]));
 #endif
-  memcpy(ft_discard_bitmap, pt_clone_source_handler->ft_discard_bitmap,
+  memcpy(wide_handler->ft_discard_bitmap,
+    pt_clone_source_handler->wide_handler->ft_discard_bitmap,
     (table_share->fields + 7) / 8);
   DBUG_VOID_RETURN;
 }
@@ -12643,7 +12618,7 @@ void ha_spider::set_searched_bitmap_from_item_list()
     if (!field || !(field = field_exchange(field)))
       continue;
     DBUG_PRINT("info",("spider field_index=%u", field->field_index));
-    spider_set_bit(searched_bitmap, field->field_index);
+    spider_set_bit(wide_handler->searched_bitmap, field->field_index);
   }
   DBUG_VOID_RETURN;
 }
@@ -12654,9 +12629,9 @@ void ha_spider::set_select_column_mode()
   KEY *key_info;
   KEY_PART_INFO *key_part;
   Field *field;
-  THD *thd = trx->thd;
+  THD *thd = wide_handler->trx->thd;
   DBUG_ENTER("ha_spider::set_select_column_mode");
-  position_bitmap_init = FALSE;
+  wide_handler->position_bitmap_init = FALSE;
 #ifndef DBUG_OFF
   for (roop_count = 0; roop_count < (int) ((table_share->fields + 7) / 8);
     roop_count++)
@@ -12667,72 +12642,48 @@ void ha_spider::set_select_column_mode()
     share->select_column_mode);
   if (select_column_mode)
   {
-    DBUG_PRINT("info",("spider searched_bitmap=%p", searched_bitmap));
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-    if (
-      partition_handler_share &&
-      partition_handler_share->searched_bitmap
-    ) {
-      if (partition_handler_share->searched_bitmap != searched_bitmap)
-      {
-        memcpy(searched_bitmap, partition_handler_share->searched_bitmap,
-          (table_share->fields + 7) / 8);
-        memcpy(ft_discard_bitmap, partition_handler_share->ft_discard_bitmap,
-          (table_share->fields + 7) / 8);
-      }
-      partition_handler_share->between_flg = FALSE;
-      DBUG_PRINT("info",("spider copy searched_bitmap"));
-    } else {
-#endif
-      set_searched_bitmap();
-      set_searched_bitmap_from_item_list();
-      if (result_list.lock_type == F_WRLCK && sql_command != SQLCOM_SELECT)
-      {
+    DBUG_PRINT("info",("spider searched_bitmap=%p",
+      wide_handler->searched_bitmap));
+    set_searched_bitmap();
+    set_searched_bitmap_from_item_list();
+    if (wide_handler->external_lock_type == F_WRLCK &&
+      wide_handler->sql_command != SQLCOM_SELECT)
+    {
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-        uint part_num = 0;
-        if (update_request)
-          part_num = check_partitioned();
+      uint part_num = 0;
+      if (wide_handler->update_request)
+        part_num = check_partitioned();
 #endif
-        if (
+      if (
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-          part_num ||
+        part_num ||
 #endif
-          table_share->primary_key == MAX_KEY
-        ) {
-          /* need all columns */
-          for (roop_count = 0; roop_count < (int) table_share->fields;
-            roop_count++)
-            spider_set_bit(searched_bitmap, roop_count);
-        } else {
-          /* need primary key columns */
-          key_info = &table_share->key_info[table_share->primary_key];
-          key_part = key_info->key_part;
-          for (roop_count = 0;
-            roop_count < (int) spider_user_defined_key_parts(key_info);
-            roop_count++)
-          {
-            field = key_part[roop_count].field;
-            spider_set_bit(searched_bitmap, field->field_index);
-          }
-        }
-#ifndef DBUG_OFF
+        table_share->primary_key == MAX_KEY
+      ) {
+        /* need all columns */
+        for (roop_count = 0; roop_count < (int) table_share->fields;
+          roop_count++)
+          spider_set_bit(wide_handler->searched_bitmap, roop_count);
+      } else {
+        /* need primary key columns */
+        key_info = &table_share->key_info[table_share->primary_key];
+        key_part = key_info->key_part;
         for (roop_count = 0;
-          roop_count < (int) ((table_share->fields + 7) / 8);
+          roop_count < (int) spider_user_defined_key_parts(key_info);
           roop_count++)
-          DBUG_PRINT("info", ("spider change bitmap is %x",
-            searched_bitmap[roop_count]));
-#endif
-      }
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-      if (partition_handler_share)
-      {
-        partition_handler_share->searched_bitmap = searched_bitmap;
-        partition_handler_share->ft_discard_bitmap = ft_discard_bitmap;
-        partition_handler_share->between_flg = TRUE;
-        DBUG_PRINT("info",("spider set searched_bitmap"));
+        {
+          field = key_part[roop_count].field;
+          spider_set_bit(wide_handler->searched_bitmap, field->field_index);
+        }
       }
-    }
+#ifndef DBUG_OFF
+      for (roop_count = 0;
+        roop_count < (int) ((table_share->fields + 7) / 8);
+        roop_count++)
+        DBUG_PRINT("info", ("spider change bitmap is %x",
+          wide_handler->searched_bitmap[roop_count]));
 #endif
+    }
   }
   DBUG_VOID_RETURN;
 }
@@ -12740,55 +12691,55 @@ void ha_spider::set_select_column_mode()
 #ifdef WITH_PARTITION_STORAGE_ENGINE
 void ha_spider::check_select_column(bool rnd)
 {
-  THD *thd = trx->thd;
+  THD *thd = wide_handler->trx->thd;
   DBUG_ENTER("ha_spider::check_select_column");
   select_column_mode = spider_param_select_column_mode(thd,
     share->select_column_mode);
-  if (select_column_mode && partition_handler_share)
+  if (select_column_mode)
   {
     if (!rnd)
     {
-      if (partition_handler_share->between_flg)
+      if (wide_handler->between_flg)
       {
-        memcpy(partition_handler_share->idx_read_bitmap,
+        memcpy(wide_handler->idx_read_bitmap,
           table->read_set->bitmap, (table_share->fields + 7) / 8);
-        memcpy(partition_handler_share->idx_write_bitmap,
+        memcpy(wide_handler->idx_write_bitmap,
           table->write_set->bitmap, (table_share->fields + 7) / 8);
-        partition_handler_share->between_flg = FALSE;
-        partition_handler_share->idx_bitmap_is_set = TRUE;
+        wide_handler->between_flg = FALSE;
+        wide_handler->idx_bitmap_is_set = TRUE;
         DBUG_PRINT("info",("spider set idx_bitmap"));
-      } else if (partition_handler_share->idx_bitmap_is_set)
+      } else if (wide_handler->idx_bitmap_is_set)
       {
         memcpy(table->read_set->bitmap,
-          partition_handler_share->idx_read_bitmap,
+          wide_handler->idx_read_bitmap,
           (table_share->fields + 7) / 8);
         memcpy(table->write_set->bitmap,
-          partition_handler_share->idx_write_bitmap,
+          wide_handler->idx_write_bitmap,
           (table_share->fields + 7) / 8);
         DBUG_PRINT("info",("spider copy idx_bitmap"));
       }
     } else {
       if (
-        !partition_handler_share->rnd_bitmap_is_set &&
+        !wide_handler->rnd_bitmap_is_set &&
         (
-          partition_handler_share->between_flg ||
-          partition_handler_share->idx_bitmap_is_set
+          wide_handler->between_flg ||
+          wide_handler->idx_bitmap_is_set
         )
       ) {
-        memcpy(partition_handler_share->rnd_read_bitmap,
+        memcpy(wide_handler->rnd_read_bitmap,
           table->read_set->bitmap, (table_share->fields + 7) / 8);
-        memcpy(partition_handler_share->rnd_write_bitmap,
+        memcpy(wide_handler->rnd_write_bitmap,
           table->write_set->bitmap, (table_share->fields + 7) / 8);
-        partition_handler_share->between_flg = FALSE;
-        partition_handler_share->rnd_bitmap_is_set = TRUE;
+        wide_handler->between_flg = FALSE;
+        wide_handler->rnd_bitmap_is_set = TRUE;
         DBUG_PRINT("info",("spider set rnd_bitmap"));
-      } else if (partition_handler_share->rnd_bitmap_is_set)
+      } else if (wide_handler->rnd_bitmap_is_set)
       {
         memcpy(table->read_set->bitmap,
-          partition_handler_share->rnd_read_bitmap,
+          wide_handler->rnd_read_bitmap,
           (table_share->fields + 7) / 8);
         memcpy(table->write_set->bitmap,
-          partition_handler_share->rnd_write_bitmap,
+          wide_handler->rnd_write_bitmap,
           (table_share->fields + 7) / 8);
         DBUG_PRINT("info",("spider copy rnd_bitmap"));
       }
@@ -13007,11 +12958,11 @@ int ha_spider::check_ha_range_eof()
     result_list.use_both_key ? "TRUE" : "FALSE"));
   DBUG_PRINT("info",("spider sql_kind[%u]=%u",
     search_link_idx, sql_kind[search_link_idx]));
-  DBUG_PRINT("info",("spider sql_command=%u", sql_command));
+  DBUG_PRINT("info",("spider sql_command=%u", wide_handler->sql_command));
   if (
     result_list.use_both_key &&
     (sql_kind[search_link_idx] & SPIDER_SQL_KIND_HANDLER) &&
-    sql_command != SQLCOM_HA_READ
+    wide_handler->sql_command != SQLCOM_HA_READ
   ) {
     int cmp_result = key_cmp(result_list.key_info->key_part,
       end_key->key, end_key->length);
@@ -13089,8 +13040,8 @@ int ha_spider::drop_tmp_tables()
             need_mons[roop_count]
           ) {
             tmp_error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -13110,7 +13061,7 @@ int ha_spider::drop_tmp_tables()
         if (!tmp_error_num)
         {
           spider_conn_set_timeout_from_share(conn, roop_count,
-            trx->thd, share);
+            wide_handler->trx->thd, share);
           if (dbton_hdl->execute_sql(
             SPIDER_SQL_TYPE_DROP_TMP_TABLE_SQL,
             conn,
@@ -13125,8 +13076,8 @@ int ha_spider::drop_tmp_tables()
               need_mons[roop_count]
             ) {
               tmp_error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  trx->thd,
+                  wide_handler->trx,
+                  wide_handler->trx->thd,
                   share,
                   roop_count,
                   (uint32) share->monitoring_sid[roop_count],
@@ -13245,8 +13196,8 @@ int ha_spider::close_opened_handler(
         need_mons[link_idx]
       ) {
         error_num2 = spider_ping_table_mon_from_table(
-          trx,
-          trx->thd,
+          wide_handler->trx,
+          wide_handler->trx->thd,
           share,
           link_idx,
           (uint32) share->monitoring_sid[link_idx],
@@ -13264,9 +13215,10 @@ int ha_spider::close_opened_handler(
       error_num = error_num2;
     }
     spider_clear_bit(m_handler_opened, link_idx);
-    if (release_conn)
+    if (release_conn && !conns[link_idx]->join_trx)
     {
-      spider_free_conn_from_trx(trx, conns[link_idx], FALSE, FALSE, NULL);
+      spider_free_conn_from_trx(wide_handler->trx, conns[link_idx],
+        FALSE, FALSE, NULL);
       conns[link_idx] = NULL;
     }
   }
@@ -13281,8 +13233,8 @@ int ha_spider::close_opened_handler(
         need_mons[link_idx]
       ) {
         error_num2 = spider_ping_table_mon_from_table(
-          trx,
-          trx->thd,
+          wide_handler->trx,
+          wide_handler->trx->thd,
           share,
           link_idx,
           (uint32) share->monitoring_sid[link_idx],
@@ -13300,16 +13252,18 @@ int ha_spider::close_opened_handler(
       error_num = error_num2;
     }
     spider_clear_bit(r_handler_opened, link_idx);
-    if (release_conn)
+    if (release_conn && !hs_w_conns[link_idx]->join_trx)
     {
       if (
         !hs_r_conns[link_idx]->opened_handlers &&
-        trx->trx_hs_r_conn_adjustment == trx_hs_r_conn_adjustment &&
-        spider_param_hs_r_conn_recycle_mode(trx->thd) != 2
+        wide_handler->trx->trx_hs_r_conn_adjustment ==
+          trx_hs_r_conn_adjustment &&
+        spider_param_hs_r_conn_recycle_mode(wide_handler->trx->thd) != 2
       ) {
-        trx->trx_hs_r_conn_adjustment++;
+        wide_handler->trx->trx_hs_r_conn_adjustment++;
       }
-      spider_free_conn_from_trx(trx, hs_r_conns[link_idx], FALSE, FALSE, NULL);
+      spider_free_conn_from_trx(wide_handler->trx, hs_r_conns[link_idx],
+        FALSE, FALSE, NULL);
       hs_r_conns[link_idx] = NULL;
     }
   }
@@ -13323,8 +13277,8 @@ int ha_spider::close_opened_handler(
         need_mons[link_idx]
       ) {
         error_num2 = spider_ping_table_mon_from_table(
-          trx,
-          trx->thd,
+          wide_handler->trx,
+          wide_handler->trx->thd,
           share,
           link_idx,
           (uint32) share->monitoring_sid[link_idx],
@@ -13342,16 +13296,18 @@ int ha_spider::close_opened_handler(
       error_num = error_num2;
     }
     spider_clear_bit(w_handler_opened, link_idx);
-    if (release_conn)
+    if (release_conn && !hs_w_conns[link_idx]->join_trx)
     {
       if (
         !hs_w_conns[link_idx]->opened_handlers &&
-        trx->trx_hs_w_conn_adjustment == trx_hs_w_conn_adjustment &&
-        spider_param_hs_w_conn_recycle_mode(trx->thd) != 2
+        wide_handler->trx->trx_hs_w_conn_adjustment ==
+          trx_hs_w_conn_adjustment &&
+        spider_param_hs_w_conn_recycle_mode(wide_handler->trx->thd) != 2
       ) {
-        trx->trx_hs_w_conn_adjustment++;
+        wide_handler->trx->trx_hs_w_conn_adjustment++;
       }
-      spider_free_conn_from_trx(trx, hs_w_conns[link_idx], FALSE, FALSE, NULL);
+      spider_free_conn_from_trx(wide_handler->trx, hs_w_conns[link_idx],
+        FALSE, FALSE, NULL);
       hs_w_conns[link_idx] = NULL;
     }
   }
@@ -13425,8 +13381,8 @@ int ha_spider::index_handler_init()
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -13532,8 +13488,8 @@ int ha_spider::rnd_handler_init()
             need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                trx,
-                trx->thd,
+                wide_handler->trx,
+                wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -13720,7 +13676,7 @@ void ha_spider::check_pre_call(
     thd->query_id != partition_handler_share->parallel_search_query_id
   ) {
     partition_handler_share->parallel_search_query_id = thd->query_id;
-    ++trx->parallel_search_count;
+    ++wide_handler->trx->parallel_search_count;
   }
   use_pre_call = use_parallel;
   if (!use_pre_call)
@@ -13742,7 +13698,7 @@ void ha_spider::check_pre_call(
 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
 void ha_spider::check_insert_dup_update_pushdown()
 {
-  THD *thd = trx->thd;
+  THD *thd = wide_handler->trx->thd;
   DBUG_ENTER("ha_spider::check_insert_dup_update_pushdown");
   DBUG_PRINT("info",("spider this=%p", this));
   if (!spider_param_direct_dup_insert(thd, share->direct_dup_insert))
@@ -13750,8 +13706,8 @@ void ha_spider::check_insert_dup_update_pushdown()
     DBUG_PRINT("info",("spider FALSE by direct_dup_insert"));
     DBUG_VOID_RETURN;
   }
-  direct_update_fields = &thd->lex->update_list;
-  direct_update_values = &thd->lex->value_list;
+  wide_handler->direct_update_fields = &thd->lex->update_list;
+  wide_handler->direct_update_values = &thd->lex->value_list;
   if (!append_dup_update_pushdown_sql_part(NULL, 0))
   {
     result_list.insert_dup_update_pushdown = TRUE;
@@ -13846,14 +13802,14 @@ int ha_spider::sync_from_clone_source(
   if (!synced_from_clone_source)
   {
     DBUG_PRINT("info",("spider synced from clone source all"));
-    trx = spider->trx;
+    wide_handler->trx = spider->wide_handler->trx;
     sql_command = spider->sql_command;
 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
     conn_kinds = spider->conn_kinds;
     memcpy(conn_kind, spider->conn_kind, sizeof(uint) * share->link_count);
 #endif
-    result_list.lock_type = spider->result_list.lock_type;
-    lock_type = spider->lock_type;
+    wide_handler->external_lock_type =
+      spider->wide_handler->external_lock_type;
     selupd_lock_mode = spider->selupd_lock_mode;
     update_request = spider->update_request;
     lock_mode = spider->lock_mode;
@@ -13894,8 +13850,8 @@ int ha_spider::sync_from_clone_source(
     conn_kinds = spider->conn_kinds;
     memcpy(conn_kind, spider->conn_kind, sizeof(uint) * share->link_count);
 #endif
-    result_list.lock_type = spider->result_list.lock_type;
-    lock_type = spider->lock_type;
+    wide_handler->external_lock_type =
+      spider->wide_handler->external_lock_type;
     selupd_lock_mode = spider->selupd_lock_mode;
     update_request = spider->update_request;
     lock_mode = spider->lock_mode;
@@ -13903,7 +13859,8 @@ int ha_spider::sync_from_clone_source(
     insert_delayed = spider->insert_delayed;
     low_priority = spider->low_priority;
 
-    if ((error_num = spider_check_trx_and_get_conn(spider->trx->thd,
+    if ((error_num = spider_check_trx_and_get_conn(
+      spider->wide_handler->trx->thd,
       this, TRUE)))
     {
       DBUG_RETURN(error_num);
@@ -14896,7 +14853,7 @@ int ha_spider::append_sum_select_sql_part(
       DBUG_RETURN(error_num);
     }
   }
-  trx->direct_aggregate_count++;
+  wide_handler->trx->direct_aggregate_count++;
   DBUG_RETURN(0);
 }
 #endif
@@ -15860,14 +15817,16 @@ int ha_spider::mk_bulk_tmp_table_and_bulk_start()
       if (
         !tmp_table[roop_count] &&
         !(tmp_table[roop_count] = spider_mk_sys_tmp_table(
-          trx->thd, table, &result_list.upd_tmp_tbl_prms[roop_count],
+          wide_handler->trx->thd, table,
+          &result_list.upd_tmp_tbl_prms[roop_count],
           &field_name, result_list.update_sqls[roop_count].charset()))
       )
 #else
       if (
         !tmp_table[roop_count] &&
         !(tmp_table[roop_count] = spider_mk_sys_tmp_table(
-          trx->thd, table, &result_list.upd_tmp_tbl_prms[roop_count], "a",
+          wide_handler->trx->thd, table,
+          &result_list.upd_tmp_tbl_prms[roop_count], "a",
           result_list.update_sqls[roop_count].charset()))
       )
 #endif
@@ -15887,7 +15846,8 @@ error_2:
     if (tmp_table[roop_count - 1])
     {
       tmp_table[roop_count - 1]->file->ha_end_bulk_insert();
-      spider_rm_sys_tmp_table(trx->thd, tmp_table[roop_count - 1],
+      spider_rm_sys_tmp_table(wide_handler->trx->thd,
+        tmp_table[roop_count - 1],
         &result_list.upd_tmp_tbl_prms[roop_count - 1]);
       tmp_table[roop_count - 1] = NULL;
     }
@@ -15916,7 +15876,8 @@ void ha_spider::rm_bulk_tmp_table()
   {
     if (tmp_table[roop_count - 1])
     {
-      spider_rm_sys_tmp_table(trx->thd, tmp_table[roop_count - 1],
+      spider_rm_sys_tmp_table(wide_handler->trx->thd,
+        tmp_table[roop_count - 1],
         &result_list.upd_tmp_tbl_prms[roop_count - 1]);
       tmp_table[roop_count - 1] = NULL;
     }
@@ -16052,3 +16013,503 @@ int ha_spider::set_union_table_name_pos_sql()
   }
   DBUG_RETURN(0);
 }
+
+int ha_spider::lock_tables()
+{
+  int error_num, roop_count;
+  DBUG_ENTER("ha_spider::lock_tables");
+  DBUG_PRINT("info",("spider lock_table_type=%u",
+    wide_handler->lock_table_type));
+
+  if ((error_num = spider_check_trx_and_get_conn(wide_handler->trx->thd, this,
+    FALSE)))
+  {
+    DBUG_RETURN(error_num);
+  }
+
+  if (wide_handler->lock_table_type == 1)
+  {
+    for (
+      roop_count = spider_conn_link_idx_next(share->link_statuses,
+        conn_link_idx, -1, share->link_count,
+        SPIDER_LINK_STATUS_RECOVERY);
+      roop_count < (int) share->link_count;
+      roop_count = spider_conn_link_idx_next(share->link_statuses,
+        conn_link_idx, roop_count, share->link_count,
+        SPIDER_LINK_STATUS_RECOVERY)
+    ) {
+      SPIDER_CONN *conn = conns[roop_count];
+      int appended = 0;
+      if ((error_num = dbton_handler[conn->dbton_id]->
+        append_lock_tables_list(conn, roop_count, &appended)))
+      {
+        DBUG_RETURN(error_num);
+      }
+      if (appended)
+      {
+        conn->table_lock = 2;
+      }
+    }
+  } else if (wide_handler->lock_table_type == 2)
+  {
+    for (
+      roop_count = spider_conn_link_idx_next(share->link_statuses,
+        conn_link_idx, -1, share->link_count,
+        SPIDER_LINK_STATUS_RECOVERY);
+      roop_count < (int) share->link_count;
+      roop_count = spider_conn_link_idx_next(share->link_statuses,
+        conn_link_idx, roop_count, share->link_count,
+        SPIDER_LINK_STATUS_RECOVERY)
+    ) {
+      if (
+        conns[roop_count] &&
+        conns[roop_count]->table_lock != 1 &&
+        spider_param_semi_table_lock(wide_handler->trx->thd,
+          share->semi_table_lock)
+      ) {
+        SPIDER_CONN *conn = conns[roop_count];
+        int appended = 0;
+        if ((error_num = dbton_handler[conn->dbton_id]->
+          append_lock_tables_list(conn, roop_count, &appended)))
+        {
+          DBUG_RETURN(error_num);
+        }
+        if (appended)
+        {
+          conn->table_lock = 3;
+        }
+      }
+    }
+  }
+
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+  if ((conn_kinds & SPIDER_CONN_KIND_MYSQL))
+  {
+#endif
+    if (!conns[search_link_idx])
+    {
+      my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
+        ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
+      DBUG_RETURN(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM);
+    }
+    for (
+      roop_count = spider_conn_link_idx_next(share->link_statuses,
+        conn_link_idx, -1, share->link_count,
+        SPIDER_LINK_STATUS_RECOVERY);
+      roop_count < (int) share->link_count;
+      roop_count = spider_conn_link_idx_next(share->link_statuses,
+        conn_link_idx, roop_count, share->link_count,
+        SPIDER_LINK_STATUS_RECOVERY)
+    ) {
+      if (wide_handler->sql_command != SQLCOM_UNLOCK_TABLES)
+      {
+        DBUG_PRINT("info",("spider conns[%d]->join_trx=%u",
+          roop_count, conns[roop_count]->join_trx));
+        if (
+          (!conns[roop_count]->join_trx &&
+            (error_num = spider_internal_start_trx_for_connection(this,
+              conns[roop_count],
+              roop_count)))
+        ) {
+          if (
+            share->monitoring_kind[roop_count] &&
+            need_mons[roop_count]
+          ) {
+            error_num = spider_ping_table_mon_from_table(
+                wide_handler->trx,
+                wide_handler->trx->thd,
+                share,
+                roop_count,
+                (uint32) share->monitoring_sid[roop_count],
+                share->table_name,
+                share->table_name_length,
+                conn_link_idx[roop_count],
+                NULL,
+                0,
+                share->monitoring_kind[roop_count],
+                share->monitoring_limit[roop_count],
+                share->monitoring_flag[roop_count],
+                TRUE
+              );
+          }
+          DBUG_RETURN(check_error_mode(error_num));
+        }
+        reset_first_link_idx();
+      }
+      if (conns[roop_count]->table_lock >= 2)
+      {
+        if (
+          conns[roop_count]->db_conn->have_lock_table_list() &&
+          (error_num = spider_db_lock_tables(this, roop_count))
+        ) {
+          if (
+            share->monitoring_kind[roop_count] &&
+            need_mons[roop_count]
+          ) {
+            error_num = spider_ping_table_mon_from_table(
+                wide_handler->trx,
+                wide_handler->trx->thd,
+                share,
+                roop_count,
+                (uint32) share->monitoring_sid[roop_count],
+                share->table_name,
+                share->table_name_length,
+                conn_link_idx[roop_count],
+                NULL,
+                0,
+                share->monitoring_kind[roop_count],
+                share->monitoring_limit[roop_count],
+                share->monitoring_flag[roop_count],
+                TRUE
+              );
+          }
+          conns[roop_count]->table_lock = 0;
+          DBUG_RETURN(check_error_mode(error_num));
+        }
+        if (conns[roop_count]->table_lock == 2)
+          conns[roop_count]->table_lock = 1;
+      } else if (wide_handler->sql_command == SQLCOM_UNLOCK_TABLES ||
+        spider_param_internal_unlock(wide_handler->trx->thd) == 1)
+      {
+        if (conns[roop_count]->table_lock == 1)
+        {
+          conns[roop_count]->table_lock = 0;
+          if (!conns[roop_count]->trx_start)
+            conns[roop_count]->disable_reconnect = FALSE;
+          if ((error_num = spider_db_unlock_tables(this, roop_count)))
+          {
+            if (
+              share->monitoring_kind[roop_count] &&
+              need_mons[roop_count]
+            ) {
+              error_num = spider_ping_table_mon_from_table(
+                  wide_handler->trx,
+                  wide_handler->trx->thd,
+                  share,
+                  roop_count,
+                  (uint32) share->monitoring_sid[roop_count],
+                  share->table_name,
+                  share->table_name_length,
+                  conn_link_idx[roop_count],
+                  NULL,
+                  0,
+                  share->monitoring_kind[roop_count],
+                  share->monitoring_limit[roop_count],
+                  share->monitoring_flag[roop_count],
+                  TRUE
+                );
+            }
+            DBUG_RETURN(check_error_mode(error_num));
+          }
+        }
+      }
+    }
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+  }
+#endif
+  DBUG_RETURN(0);
+}
+
+int ha_spider::dml_init()
+{
+  int error_num, roop_count;
+  SPIDER_TRX *trx = wide_handler->trx;
+  THD *thd = trx->thd;
+  bool sync_trx_isolation = spider_param_sync_trx_isolation(thd);
+  DBUG_ENTER("ha_spider::dml_init");
+  if (wide_handler->lock_mode == -2)
+  {
+    wide_handler->lock_mode = spider_param_selupd_lock_mode(thd,
+      share->selupd_lock_mode);
+  }
+  if ((error_num = check_access_kind_for_connection(thd,
+    (wide_handler->lock_type >= TL_WRITE_ALLOW_WRITE))))
+  {
+    DBUG_RETURN(error_num);
+  }
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+  if ((conn_kinds & SPIDER_CONN_KIND_MYSQL))
+  {
+#endif
+    if (!conns[search_link_idx])
+    {
+      my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
+        ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
+      DBUG_RETURN(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM);
+    }
+    if (wide_handler->sql_command == SQLCOM_TRUNCATE)
+      DBUG_RETURN(0);
+    for (
+      roop_count = spider_conn_link_idx_next(share->link_statuses,
+        conn_link_idx, -1, share->link_count,
+        SPIDER_LINK_STATUS_RECOVERY);
+      roop_count < (int) share->link_count;
+      roop_count = spider_conn_link_idx_next(share->link_statuses,
+        conn_link_idx, roop_count, share->link_count,
+        SPIDER_LINK_STATUS_RECOVERY)
+    ) {
+      DBUG_PRINT("info",("spider conns[%d]->join_trx=%u",
+        roop_count, conns[roop_count]->join_trx));
+      if (
+        (!conns[roop_count]->join_trx &&
+          (error_num = spider_internal_start_trx_for_connection(this,
+            conns[roop_count],
+            roop_count)))
+      ) {
+        if (
+          share->monitoring_kind[roop_count] &&
+          need_mons[roop_count]
+        ) {
+          error_num = spider_ping_table_mon_from_table(
+              trx,
+              trx->thd,
+              share,
+              roop_count,
+              (uint32) share->monitoring_sid[roop_count],
+              share->table_name,
+              share->table_name_length,
+              conn_link_idx[roop_count],
+              NULL,
+              0,
+              share->monitoring_kind[roop_count],
+              share->monitoring_limit[roop_count],
+              share->monitoring_flag[roop_count],
+              TRUE
+            );
+        }
+        DBUG_RETURN(check_error_mode(error_num));
+      }
+      reset_first_link_idx();
+      if (
+        conns[roop_count]->semi_trx_isolation == -2 &&
+        conns[roop_count]->semi_trx_isolation_chk == TRUE &&
+        sync_trx_isolation &&
+        spider_param_semi_trx_isolation(trx->thd) >= 0
+      ) {
+        spider_conn_queue_semi_trx_isolation(conns[roop_count],
+          spider_param_semi_trx_isolation(trx->thd));
+      } else {
+        if (sync_trx_isolation)
+        {
+          if ((error_num = spider_check_and_set_trx_isolation(
+            conns[roop_count], &need_mons[roop_count])))
+          {
+            if (
+              share->monitoring_kind[roop_count] &&
+              need_mons[roop_count]
+            ) {
+              error_num = spider_ping_table_mon_from_table(
+                  trx,
+                  trx->thd,
+                  share,
+                  roop_count,
+                  (uint32) share->monitoring_sid[roop_count],
+                  share->table_name,
+                  share->table_name_length,
+                  conn_link_idx[roop_count],
+                  NULL,
+                  0,
+                  share->monitoring_kind[roop_count],
+                  share->monitoring_limit[roop_count],
+                  share->monitoring_flag[roop_count],
+                  TRUE
+                );
+            }
+            DBUG_RETURN(check_error_mode(error_num));
+          }
+        }
+        conns[roop_count]->semi_trx_isolation = -1;
+      }
+    }
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+  } else {
+    reset_first_link_idx();
+  }
+  if ((conn_kinds & SPIDER_CONN_KIND_HS_READ))
+  {
+    SPIDER_CONN *hs_conn;
+    for (
+      roop_count = spider_conn_link_idx_next(share->link_statuses,
+        conn_link_idx, -1, share->link_count,
+        SPIDER_LINK_STATUS_RECOVERY);
+      roop_count < (int) share->link_count;
+      roop_count = spider_conn_link_idx_next(share->link_statuses,
+        conn_link_idx, roop_count, share->link_count,
+        SPIDER_LINK_STATUS_RECOVERY)
+    ) {
+      hs_conn = hs_r_conns[roop_count];
+      if (
+        hs_conn &&
+        hs_conn->hsc_query_id != thd->query_id &&
+        hs_conn->hs_pre_age == hs_conn->hs_age
+      ) {
+        double interval = spider_param_hs_ping_interval(thd);
+        time_t tmp_time = (time_t) time((time_t*) 0);
+        DBUG_PRINT("info",
+          ("spider difftime=%f", difftime(tmp_time, hs_conn->ping_time)));
+        DBUG_PRINT("info", ("spider interval=%f", interval));
+        if (
+          hs_conn->server_lost ||
+          difftime(tmp_time, hs_conn->ping_time) >= interval
+        ) {
+          DBUG_PRINT("info", ("spider hsr[%d] need reconnect", roop_count));
+          hs_conn->hs_pre_age++;
+          hs_conn->ping_time = tmp_time;
+        }
+        hs_conn->hsc_query_id = thd->query_id;
+      }
+    }
+  }
+  if (
+#if defined(HS_HAS_SQLCOM) && defined(HANDLER_HAS_DIRECT_UPDATE_ROWS)
+    (
+#endif
+      conn_kinds & SPIDER_CONN_KIND_HS_WRITE
+#if defined(HS_HAS_SQLCOM) && defined(HANDLER_HAS_DIRECT_UPDATE_ROWS)
+    ) ||
+    /* for direct_update */
+    wide_handler->sql_command == SQLCOM_HS_UPDATE ||
+    wide_handler->sql_command == SQLCOM_HS_DELETE
+#endif
+  ) {
+    SPIDER_CONN *hs_conn;
+    for (
+      roop_count = spider_conn_link_idx_next(share->link_statuses,
+        conn_link_idx, -1, share->link_count,
+        SPIDER_LINK_STATUS_RECOVERY);
+      roop_count < (int) share->link_count;
+      roop_count = spider_conn_link_idx_next(share->link_statuses,
+        conn_link_idx, roop_count, share->link_count,
+        SPIDER_LINK_STATUS_RECOVERY)
+    ) {
+      hs_conn = hs_w_conns[roop_count];
+      if (
+        hs_conn &&
+        hs_conn->hsc_query_id != thd->query_id &&
+        hs_conn->hs_pre_age == hs_conn->hs_age
+      ) {
+        double interval = spider_param_hs_ping_interval(thd);
+        time_t tmp_time = (time_t) time((time_t*) 0);
+        DBUG_PRINT("info",
+          ("spider difftime=%f", difftime(tmp_time, hs_conn->ping_time)));
+        DBUG_PRINT("info", ("spider interval=%f", interval));
+        if (
+          hs_conn->server_lost ||
+          difftime(tmp_time, hs_conn->ping_time) >= interval
+        ) {
+          DBUG_PRINT("info", ("spider hsw[%d] need reconnect", roop_count));
+          hs_conn->hs_pre_age++;
+          hs_conn->ping_time = tmp_time;
+        }
+        hs_conn->hsc_query_id = thd->query_id;
+      }
+    }
+  }
+#endif
+#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
+  if (wide_handler->insert_with_update)
+  {
+    check_insert_dup_update_pushdown();
+  }
+#endif
+  dml_inited = TRUE;
+  DBUG_RETURN(0);
+}
+
+#ifdef HA_CAN_BULK_ACCESS
+int ha_spider::bulk_access_begin(
+  void *info
+) {
+  DBUG_ENTER("ha_spider::bulk_access_begin");
+  DBUG_PRINT("info",("spider this=%p", this));
+  if (bulk_access_started)
+  {
+    if (!bulk_access_link_current->next)
+    {
+      if (!(bulk_access_link_current->next = create_bulk_access_link()))
+      {
+        DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+      }
+      bulk_access_link_current->next->sequence_num =
+        bulk_access_link_current->sequence_num + 1;
+    }
+    bulk_access_link_current = bulk_access_link_current->next;
+  } else {
+    if (!bulk_access_link_first)
+    {
+      if (!(bulk_access_link_first = create_bulk_access_link()))
+      {
+        DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+      }
+      bulk_access_link_first->sequence_num = 0;
+    }
+    bulk_access_link_current = bulk_access_link_first;
+    bulk_access_started = TRUE;
+    bulk_access_executing = FALSE;
+  }
+  bulk_access_link_current->spider->
+    check_access_kind(wide_handler->trx->thd);
+  if (
+    (error_num = bulk_access_link_current->spider->
+      sync_from_clone_source(this)) ||
+    (error_num = bulk_access_link_current->spider->
+      check_access_kind_for_connection(wide_handler->trx->thd,
+        (lock_type >= TL_WRITE_ALLOW_WRITE)))
+  ) {
+    DBUG_RETURN(error_num);
+  }
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+  memset(
+    bulk_access_link_current->spider->result_list.hs_r_bulk_open_index, 0,
+    share->link_bitmap_size);
+  memset(
+    bulk_access_link_current->spider->result_list.hs_w_bulk_open_index, 0,
+    share->link_bitmap_size);
+#endif
+  bulk_access_link_current->spider->bulk_access_executing = FALSE;
+  bulk_access_link_current->spider->bulk_access_pre_called = FALSE;
+  bulk_access_link_current->used = TRUE;
+  bulk_access_link_current->called = FALSE;
+  *((void **) info) = bulk_access_link_current;
+  DBUG_RETURN(0);
+}
+
+int ha_spider::bulk_access_current(
+  void *info
+) {
+  DBUG_ENTER("ha_spider::bulk_access_current");
+  DBUG_PRINT("info",("spider this=%p", this));
+  bulk_access_executing = TRUE;
+  bulk_access_link_exec_tgt = (SPIDER_BULK_ACCESS_LINK *) info;
+  if (bulk_access_link_exec_tgt->spider->pt_clone_source_handler != this)
+  {
+    DBUG_PRINT("info",("spider this=%p", this));
+    DBUG_PRINT("info",("spider pt_clone_source_handler=%p",
+      bulk_access_link_exec_tgt->spider->pt_clone_source_handler));
+    /* partitioned */
+    uint sequence_num = bulk_access_link_exec_tgt->sequence_num;
+    for (
+      bulk_access_link_exec_tgt = bulk_access_link_first;
+      bulk_access_link_exec_tgt;
+      bulk_access_link_exec_tgt = bulk_access_link_exec_tgt->next
+    ) {
+      if (bulk_access_link_exec_tgt->sequence_num >= sequence_num)
+      {
+        DBUG_ASSERT(
+          bulk_access_link_exec_tgt->sequence_num == sequence_num);
+        break;
+      }
+    }
+  }
+  bulk_access_link_exec_tgt->spider->bulk_access_executing = TRUE;
+  DBUG_RETURN(0);
+}
+
+void ha_spider::bulk_access_end()
+{
+  DBUG_ENTER("ha_spider::bulk_access_end");
+  DBUG_PRINT("info",("spider this=%p", this));
+  bulk_access_started = FALSE;
+  DBUG_VOID_RETURN;
+}
+#endif
diff --git a/storage/spider/ha_spider.h b/storage/spider/ha_spider.h
index 4a7b685527d..b259e9cf098 100644
--- a/storage/spider/ha_spider.h
+++ b/storage/spider/ha_spider.h
@@ -52,9 +52,7 @@ struct st_spider_ft_info
 class ha_spider: public handler
 {
 public:
-  THR_LOCK_DATA      lock;
   SPIDER_SHARE       *share;
-  SPIDER_TRX         *trx;
   ulonglong          spider_thread_id;
   ulonglong          trx_conn_adjustment;
 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
@@ -90,18 +88,16 @@ public:
   int                search_link_idx;
   int                result_link_idx;
   SPIDER_RESULT_LIST result_list;
-  SPIDER_CONDITION   *condition;
   spider_string      *blob_buff;
-  uchar              *searched_bitmap;
-  uchar              *ft_discard_bitmap;
-  bool               position_bitmap_init;
-  uchar              *position_bitmap;
   SPIDER_POSITION    *pushed_pos;
   SPIDER_POSITION    pushed_pos_buf;
 #ifdef WITH_PARTITION_STORAGE_ENGINE
+  bool               pt_handler_share_owner = FALSE;
   SPIDER_PARTITION_HANDLER_SHARE *partition_handler_share;
-  ha_spider          *pt_handler_share_creator;
 #endif
+  bool                wide_handler_owner = FALSE;
+  SPIDER_WIDE_HANDLER *wide_handler = NULL;
+
 #ifdef HA_CAN_BULK_ACCESS
   int                pre_direct_init_result;
   bool               is_bulk_access_clone;
@@ -116,10 +112,8 @@ public:
   bool               init_ha_mem_root;
   MEM_ROOT           ha_mem_root;
 */
-  ulonglong          external_lock_cnt;
 #endif
   bool               is_clone;
-  bool               clone_bitmap_init;
   ha_spider          *pt_clone_source_handler;
   ha_spider          *pt_clone_last_searcher;
   bool               use_index_merge;
@@ -161,22 +155,11 @@ public:
 
   ha_spider          *next;
 
+  bool               dml_inited;
   bool               rnd_scan_and_first;
-  bool               quick_mode;
-  bool               keyread;
-  bool               ignore_dup_key;
-  bool               write_can_replace;
-  bool               insert_with_update;
-  bool               low_priority;
-  bool               high_priority;
-  bool               insert_delayed;
   bool               use_pre_call;
   bool               use_pre_action;
   bool               pre_bitmap_checked;
-  enum thr_lock_type lock_type;
-  int                lock_mode;
-  uint               sql_command;
-  int                selupd_lock_mode;
   bool               bulk_insert;
 #ifdef HANDLER_HAS_NEED_INFO_FOR_AUTO_INC
   bool               info_auto_called;
@@ -189,12 +172,9 @@ public:
   int                store_error_num;
   uint               dup_key_idx;
   int                select_column_mode;
-  bool               update_request;
   bool               pk_update;
   bool               force_auto_increment;
   int                bka_mode;
-  bool               cond_check;
-  int                cond_check_error;
   int                error_mode;
   ulonglong          store_last_insert_id;
 
@@ -216,14 +196,7 @@ public:
   uint32             **hs_w_ret_fields;
   size_t             *hs_r_ret_fields_num;
   size_t             *hs_w_ret_fields_num;
-  uint32             *hs_pushed_ret_fields;
-  size_t             hs_pushed_ret_fields_num;
-  size_t             hs_pushed_ret_fields_size;
-  size_t             hs_pushed_lcl_fields_num;
   uchar              *tmp_column_bitmap;
-  bool               hs_increment;
-  bool               hs_decrement;
-  uint32             hs_pushed_strref_num;
 #endif
 #endif
 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
@@ -232,11 +205,6 @@ public:
   bool               maybe_do_hs_direct_update;
 #endif
   uint               direct_update_kinds;
-  List<Item>         *direct_update_fields;
-  List<Item>         *direct_update_values;
-#endif
-#ifdef INFO_KIND_FORCE_LIMIT_BEGIN
-  longlong           info_limit;
 #endif
   spider_index_rnd_init prev_index_rnd_init;
 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
@@ -283,10 +251,13 @@ public:
     uint test_if_locked
   );
   int close();
-  int check_access_kind(
+  int check_access_kind_for_connection(
     THD *thd,
     bool write_request
   );
+  void check_access_kind(
+    THD *thd
+  );
 #ifdef HA_CAN_BULK_ACCESS
   int additional_lock(
     THD *thd,
@@ -302,6 +273,10 @@ public:
     THD *thd,
     int lock_type
   );
+  int start_stmt(
+    THD *thd,
+    thr_lock_type lock_type
+  );
   int reset();
   int extra(
     enum ha_extra_function operation
@@ -525,6 +500,7 @@ public:
 #endif
   const char *table_type() const;
   ulonglong table_flags() const;
+  ulong table_flags_for_partition();
   const char *index_type(
     uint key_number
   );
@@ -869,6 +845,12 @@ public:
     int error_num,
     uint flags
   );
+  int set_top_table_and_fields(
+    TABLE *top_table,
+    Field **top_table_field,
+    uint top_table_fields
+  );
+  void clear_top_table_fields();
   Field *get_top_table_field(
     uint16 field_index
   );
@@ -1255,4 +1237,15 @@ public:
 #endif
   int init_union_table_name_pos_sql();
   int set_union_table_name_pos_sql();
+  int lock_tables();
+  int dml_init();
+#ifdef HA_CAN_BULK_ACCESS
+  int bulk_access_begin(
+    void *info
+  );
+  int bulk_access_current(
+    void *info
+  );
+  void bulk_access_end();
+#endif
 };
diff --git a/storage/spider/mysql-test/spider/bugfix/include/insert_select_deinit.inc b/storage/spider/mysql-test/spider/bugfix/include/insert_select_deinit.inc
new file mode 100644
index 00000000000..b8b2f200689
--- /dev/null
+++ b/storage/spider/mysql-test/spider/bugfix/include/insert_select_deinit.inc
@@ -0,0 +1,16 @@
+--connection master_1
+set session spider_direct_dup_insert= @old_spider_direct_dup_insert;
+--let $MASTER_1_COMMENT_2_1= $MASTER_1_COMMENT_2_1_BACKUP
+--let $MASTER_1_COMMENT_2_1_2= $MASTER_1_COMMENT_2_1_2_BACKUP
+--let $CHILD2_1_DROP_TABLES= $CHILD2_1_DROP_TABLES_BACKUP
+--let $CHILD2_1_DROP_TABLES2= $CHILD2_1_DROP_TABLES2_BACKUP
+--let $CHILD2_1_CREATE_TABLES= $CHILD2_1_CREATE_TABLES_BACKUP
+--let $CHILD2_1_CREATE_TABLES2= $CHILD2_1_CREATE_TABLES2_BACKUP
+--let $CHILD2_1_SELECT_TABLES= $CHILD2_1_SELECT_TABLES_BACKUP
+--disable_warnings
+--disable_query_log
+--disable_result_log
+--source ../t/test_deinit.inc
+--enable_result_log
+--enable_query_log
+--enable_warnings
diff --git a/storage/spider/mysql-test/spider/bugfix/include/insert_select_init.inc b/storage/spider/mysql-test/spider/bugfix/include/insert_select_init.inc
new file mode 100644
index 00000000000..62a8821a3c9
--- /dev/null
+++ b/storage/spider/mysql-test/spider/bugfix/include/insert_select_init.inc
@@ -0,0 +1,43 @@
+--disable_warnings
+--disable_query_log
+--disable_result_log
+--source ../t/test_init.inc
+--enable_result_log
+--enable_query_log
+--enable_warnings
+--let $MASTER_1_COMMENT_2_1_BACKUP= $MASTER_1_COMMENT_2_1
+let $MASTER_1_COMMENT_2_1=
+  COMMENT='table "tbl_a", srv "s_2_1"';
+--let $MASTER_1_COMMENT_2_1_2_BACKUP= $MASTER_1_COMMENT_2_1_2
+let $MASTER_1_COMMENT_2_1_2=
+  COMMENT='table "tbl_b", srv "s_2_1"';
+--let $CHILD2_1_DROP_TABLES_BACKUP= $CHILD2_1_DROP_TABLES
+let $CHILD2_1_DROP_TABLES=
+  DROP TABLE IF EXISTS tbl_a;
+--let $CHILD2_1_DROP_TABLES2_BACKUP= $CHILD2_1_DROP_TABLES2
+let $CHILD2_1_DROP_TABLES2=
+  DROP TABLE IF EXISTS tbl_b;
+--let $CHILD2_1_CREATE_TABLES_BACKUP= $CHILD2_1_CREATE_TABLES
+let $CHILD2_1_CREATE_TABLES=
+  CREATE TABLE tbl_a (
+    skey int NOT NULL,
+    dt date NOT NULL,
+    tm time NOT NULL,
+    KEY idx1 (skey,dt,tm)
+  ) $CHILD2_1_ENGINE $CHILD2_1_CHARSET;
+--let $CHILD2_1_CREATE_TABLES2_BACKUP= $CHILD2_1_CREATE_TABLES2
+let $CHILD2_1_CREATE_TABLES2=
+  CREATE TABLE tbl_b (
+    pkey int NOT NULL,
+    dt datetime NOT NULL,
+    PRIMARY KEY (pkey),
+    KEY idx1 (dt)
+  ) $CHILD2_1_ENGINE $CHILD2_1_CHARSET;
+--let $CHILD2_1_SELECT_TABLES_BACKUP= $CHILD2_1_SELECT_TABLES
+let $CHILD2_1_SELECT_TABLES=
+  SELECT pkey, dt FROM tbl_b ORDER BY pkey;
+let $CHILD2_1_SELECT_ARGUMENT1=
+  SELECT argument FROM mysql.general_log WHERE argument LIKE '%select %';
+--connection master_1
+set @old_spider_direct_dup_insert= @@spider_direct_dup_insert;
+set session spider_direct_dup_insert= 1;
diff --git a/storage/spider/mysql-test/spider/bugfix/t/insert_select.cnf b/storage/spider/mysql-test/spider/bugfix/t/insert_select.cnf
new file mode 100644
index 00000000000..05dfd8a0bce
--- /dev/null
+++ b/storage/spider/mysql-test/spider/bugfix/t/insert_select.cnf
@@ -0,0 +1,3 @@
+!include include/default_mysqld.cnf
+!include ../my_1_1.cnf
+!include ../my_2_1.cnf
diff --git a/storage/spider/mysql-test/spider/bugfix/t/insert_select.test b/storage/spider/mysql-test/spider/bugfix/t/insert_select.test
new file mode 100644
index 00000000000..381e72f7b1b
--- /dev/null
+++ b/storage/spider/mysql-test/spider/bugfix/t/insert_select.test
@@ -0,0 +1,99 @@
+--source ../include/insert_select_init.inc
+--echo
+--echo this test is for MDEV-16399
+--echo
+--echo drop and create databases
+
+--connection master_1
+--disable_warnings
+CREATE DATABASE auto_test_local;
+USE auto_test_local;
+
+--connection child2_1
+SET @old_log_output = @@global.log_output;
+SET GLOBAL log_output = 'TABLE,FILE';
+CREATE DATABASE auto_test_remote;
+USE auto_test_remote;
+--enable_warnings
+
+--echo
+--echo create table and insert
+
+--connection child2_1
+--disable_query_log
+echo CHILD2_1_CREATE_TABLES;
+eval $CHILD2_1_CREATE_TABLES;
+echo CHILD2_1_CREATE_TABLES2;
+eval $CHILD2_1_CREATE_TABLES2;
+--enable_query_log
+TRUNCATE TABLE mysql.general_log;
+
+--connection master_1
+--disable_query_log
+echo CREATE TABLE tbl_a (
+    skey int NOT NULL,
+    dt date NOT NULL,
+    tm time NOT NULL,
+    KEY idx1 (skey,dt,tm)
+) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1;
+eval CREATE TABLE tbl_a (
+    skey int NOT NULL,
+    dt date NOT NULL,
+    tm time NOT NULL,
+    KEY idx1 (skey,dt,tm)
+) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1;
+echo CREATE TABLE tbl_b (
+    pkey int NOT NULL,
+    dt datetime NOT NULL,
+    PRIMARY KEY (pkey),
+    KEY idx1 (dt)
+) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1_2;
+eval CREATE TABLE tbl_b (
+    pkey int NOT NULL,
+    dt datetime NOT NULL,
+    PRIMARY KEY (pkey),
+    KEY idx1 (dt)
+) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1_2;
+--enable_query_log
+INSERT INTO tbl_a (skey, dt, tm) VALUES (0, '2012-01-01', '12:00:00'),(1, '2012-02-01', '12:00:00'),(2, '2012-03-01', '12:00:00'),(3, '2012-04-01', '12:00:00'),(4, '2012-05-01', '12:00:00'),(5, '2012-06-01', '12:00:00'),(6, '2012-07-01', '12:00:00'),(7, '2012-08-01', '12:00:00'),(8, '2012-09-01', '12:00:00'),(9, '2012-10-01', '12:00:00');
+INSERT INTO tbl_a (skey, dt, tm) VALUES (0, '2013-01-01', '13:00:00'),(1, '2013-02-01', '13:00:00'),(2, '2013-03-01', '13:00:00'),(3, '2013-04-01', '13:00:00'),(4, '2013-05-01', '13:00:00'),(5, '2013-06-01', '13:00:00'),(6, '2013-07-01', '13:00:00'),(7, '2013-08-01', '13:00:00'),(8, '2013-09-01', '13:00:00'),(9, '2013-10-01', '13:00:00');
+INSERT INTO tbl_a (skey, dt, tm) VALUES (0, '2012-11-01', '11:00:00'),(1, '2012-12-01', '11:00:00'),(2, '2012-11-30', '11:00:00'),(3, '2012-11-29', '11:00:00'),(4, '2012-11-28', '11:00:00'),(5, '2012-11-27', '11:00:00'),(6, '2012-11-26', '11:00:00'),(7, '2012-11-25', '11:00:00'),(8, '2012-11-24', '11:00:00'),(9, '2012-11-23', '11:00:00');
+FLUSH TABLES;
+
+--echo
+--echo select test 1
+
+--connection child2_1
+TRUNCATE TABLE mysql.general_log;
+
+--connection master_1
+INSERT IGNORE INTO tbl_b (SELECT skey, CAST(CONCAT(dt, ' ', tm) AS datetime) FROM tbl_a WHERE skey = 4 AND dt > DATE_ADD('2012-12-01', INTERVAL -10 DAY));
+INSERT IGNORE INTO tbl_b (SELECT skey, CAST(CONCAT(dt, ' ', tm) AS datetime) FROM tbl_a WHERE skey = 3 AND dt > DATE_ADD('2012-12-01', INTERVAL -10 DAY));
+INSERT IGNORE INTO tbl_b (SELECT skey, CAST(CONCAT(dt, ' ', tm) AS datetime) FROM tbl_a WHERE skey = 2 AND dt > DATE_ADD('2012-12-01', INTERVAL -10 DAY));
+INSERT IGNORE INTO tbl_b (SELECT skey, CAST(CONCAT(dt, ' ', tm) AS datetime) FROM tbl_a WHERE skey = 1 AND dt > DATE_ADD('2012-12-01', INTERVAL -10 DAY));
+INSERT IGNORE INTO tbl_b (SELECT skey, CAST(CONCAT(dt, ' ', tm) AS datetime) FROM tbl_a WHERE skey = 0 AND dt > DATE_ADD('2012-12-01', INTERVAL -10 DAY));
+INSERT IGNORE INTO tbl_b (SELECT skey, CAST(CONCAT(dt, ' ', tm) AS datetime) FROM tbl_a WHERE skey = 9 AND dt > DATE_ADD('2012-12-01', INTERVAL -10 DAY));
+INSERT IGNORE INTO tbl_b (SELECT skey, CAST(CONCAT(dt, ' ', tm) AS datetime) FROM tbl_a WHERE skey = 8 AND dt > DATE_ADD('2012-12-01', INTERVAL -10 DAY));
+INSERT IGNORE INTO tbl_b (SELECT skey, CAST(CONCAT(dt, ' ', tm) AS datetime) FROM tbl_a WHERE skey = 7 AND dt > DATE_ADD('2012-12-01', INTERVAL -10 DAY));
+INSERT IGNORE INTO tbl_b (SELECT skey, CAST(CONCAT(dt, ' ', tm) AS datetime) FROM tbl_a WHERE skey = 6 AND dt > DATE_ADD('2012-12-01', INTERVAL -10 DAY));
+INSERT IGNORE INTO tbl_b (SELECT skey, CAST(CONCAT(dt, ' ', tm) AS datetime) FROM tbl_a WHERE skey = 5 AND dt > DATE_ADD('2012-12-01', INTERVAL -10 DAY));
+
+--connection child2_1
+eval $CHILD2_1_SELECT_ARGUMENT1;
+eval $CHILD2_1_SELECT_TABLES;
+
+--echo
+--echo deinit
+--disable_warnings
+
+--connection master_1
+DROP DATABASE IF EXISTS auto_test_local;
+
+--connection child2_1
+DROP DATABASE IF EXISTS auto_test_remote;
+SET GLOBAL log_output = @old_log_output;
+
+--enable_warnings
+--source ../include/insert_select_deinit.inc
+--echo
+--echo end of test
diff --git a/storage/spider/spd_conn.cc b/storage/spider/spd_conn.cc
index 3164356ddf6..ba80a409382 100644
--- a/storage/spider/spd_conn.cc
+++ b/storage/spider/spd_conn.cc
@@ -312,6 +312,10 @@ void spider_free_conn_from_trx(
         }
       } else {
         /* conn_recycle_mode == 0 */
+        if (conn->quick_target)
+        {
+          spider_db_free_result((ha_spider *) conn->quick_target, TRUE);
+        }
         spider_free_conn(conn);
       }
     } else if (roop_count)
@@ -1283,7 +1287,7 @@ int spider_check_and_get_casual_read_conn(
     if (
       !(spider->conns[link_idx] =
         spider_get_conn(spider->share, link_idx,
-          spider->conn_keys[link_idx], spider->trx,
+          spider->conn_keys[link_idx], spider->wide_handler->trx,
           spider, FALSE, TRUE, SPIDER_CONN_KIND_MYSQL,
           &error_num))
     ) {
@@ -1745,7 +1749,8 @@ int spider_set_conn_bg_param(
   int error_num, roop_count, bgs_mode;
   SPIDER_SHARE *share = spider->share;
   SPIDER_RESULT_LIST *result_list = &spider->result_list;
-  THD *thd = spider->trx->thd;
+  SPIDER_WIDE_HANDLER *wide_handler = spider->wide_handler;
+  THD *thd = wide_handler->trx->thd;
   DBUG_ENTER("spider_set_conn_bg_param");
   DBUG_PRINT("info",("spider spider=%p", spider));
   bgs_mode =
@@ -1754,10 +1759,11 @@ int spider_set_conn_bg_param(
     result_list->bgs_phase = 0;
   else if (
     bgs_mode <= 2 &&
-    (result_list->lock_type == F_WRLCK || spider->lock_mode == 2)
+    (wide_handler->external_lock_type == F_WRLCK ||
+      wide_handler->lock_mode == 2)
   )
     result_list->bgs_phase = 0;
-  else if (bgs_mode <= 1 && spider->lock_mode == 1)
+  else if (bgs_mode <= 1 && wide_handler->lock_mode == 1)
     result_list->bgs_phase = 0;
   else {
     result_list->bgs_phase = 1;
@@ -1804,12 +1810,12 @@ int spider_set_conn_bg_param(
       for (
         roop_count = spider_conn_link_idx_next(share->link_statuses,
           spider->conn_link_idx, -1, share->link_count,
-          spider->lock_mode ?
+          spider->wide_handler->lock_mode ?
           SPIDER_LINK_STATUS_RECOVERY : SPIDER_LINK_STATUS_OK);
         roop_count < (int) share->link_count;
         roop_count = spider_conn_link_idx_next(share->link_statuses,
           spider->conn_link_idx, roop_count, share->link_count,
-          spider->lock_mode ?
+          spider->wide_handler->lock_mode ?
           SPIDER_LINK_STATUS_RECOVERY : SPIDER_LINK_STATUS_OK)
       ) {
         if ((error_num = spider_create_conn_thread(spider->conns[roop_count])))
@@ -2688,7 +2694,7 @@ void *spider_bg_conn_action(
                   conn->link_idx);
                 result_list->tmp_tables_created = TRUE;
                 spider_conn_set_timeout_from_share(conn, conn->link_idx,
-                  spider->trx->thd, share);
+                  spider->wide_handler->trx->thd, share);
                 if (dbton_handler->execute_sql(
                   SPIDER_SQL_TYPE_TMP_SQL,
                   conn,
@@ -2706,7 +2712,7 @@ void *spider_bg_conn_action(
               if (!result_list->bgs_error)
               {
                 spider_conn_set_timeout_from_share(conn, conn->link_idx,
-                  spider->trx->thd, share);
+                  spider->wide_handler->trx->thd, share);
                 if (dbton_handler->execute_sql(
                   sql_type,
                   conn,
@@ -2949,6 +2955,7 @@ void *spider_bg_sts_action(
   SPIDER_TRX *trx;
   int error_num = 0, roop_count;
   ha_spider spider;
+  SPIDER_WIDE_HANDLER wide_handler;
   int *need_mons;
   SPIDER_CONN **conns;
   uint *conn_link_idx;
@@ -3042,7 +3049,8 @@ void *spider_bg_sts_action(
     DBUG_RETURN(NULL);
   }
   share->bg_sts_thd = thd;
-  spider.trx = trx;
+  spider.wide_handler = &wide_handler;
+  wide_handler.trx = trx;
   spider.share = share;
   spider.conns = conns;
   spider.conn_link_idx = conn_link_idx;
@@ -3314,6 +3322,7 @@ void *spider_bg_crd_action(
   SPIDER_TRX *trx;
   int error_num = 0, roop_count;
   ha_spider spider;
+  SPIDER_WIDE_HANDLER wide_handler;
   TABLE table;
   int *need_mons;
   SPIDER_CONN **conns;
@@ -3411,7 +3420,8 @@ void *spider_bg_crd_action(
   table.s = share->table_share;
   table.field = share->table_share->field;
   table.key_info = share->table_share->key_info;
-  spider.trx = trx;
+  spider.wide_handler = &wide_handler;
+  wide_handler.trx = trx;
   spider.change_table_ptr(&table, share->table_share);
   spider.share = share;
   spider.conns = conns;
@@ -4097,11 +4107,12 @@ int spider_conn_get_link_status(
 int spider_conn_lock_mode(
   ha_spider *spider
 ) {
-  SPIDER_RESULT_LIST *result_list = &spider->result_list;
+  SPIDER_WIDE_HANDLER *wide_handler = spider->wide_handler;
   DBUG_ENTER("spider_conn_lock_mode");
-  if (result_list->lock_type == F_WRLCK || spider->lock_mode == 2)
+  if (wide_handler->external_lock_type == F_WRLCK ||
+    wide_handler->lock_mode == 2)
     DBUG_RETURN(SPIDER_LOCK_MODE_EXCLUSIVE);
-  else if (spider->lock_mode == 1)
+  else if (wide_handler->lock_mode == 1)
     DBUG_RETURN(SPIDER_LOCK_MODE_SHARED);
   DBUG_RETURN(SPIDER_LOCK_MODE_NO_LOCK);
 }
@@ -4124,7 +4135,7 @@ bool spider_conn_use_handler(
   int lock_mode,
   int link_idx
 ) {
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   int use_handler = spider_param_use_handler(thd,
     spider->share->use_handlers[link_idx]);
   DBUG_ENTER("spider_conn_use_handler");
@@ -4197,7 +4208,7 @@ bool spider_conn_use_handler(
     DBUG_RETURN(FALSE);
   }
   if (
-    spider->sql_command == SQLCOM_HA_READ &&
+    spider->wide_handler->sql_command == SQLCOM_HA_READ &&
     (
       !(use_handler & 2) ||
       (
@@ -4212,7 +4223,7 @@ bool spider_conn_use_handler(
     DBUG_RETURN(TRUE);
   }
   if (
-    spider->sql_command != SQLCOM_HA_READ &&
+    spider->wide_handler->sql_command != SQLCOM_HA_READ &&
     lock_mode == SPIDER_LOCK_MODE_NO_LOCK &&
     spider_param_sync_trx_isolation(thd) &&
     thd_tx_isolation(thd) != ISO_SERIALIZABLE &&
diff --git a/storage/spider/spd_copy_tables.cc b/storage/spider/spd_copy_tables.cc
index 19023a00da3..ed08cb8a6af 100644
--- a/storage/spider/spd_copy_tables.cc
+++ b/storage/spider/spd_copy_tables.cc
@@ -1,4 +1,5 @@
-/* Copyright (C) 2009-2018 Kentoku Shiba
+/* Copyright (C) 2009-2019 Kentoku Shiba
+   Copyright (C) 2019 MariaDB corp
 
   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
@@ -839,6 +840,7 @@ long long spider_copy_tables_body(
   spider_string *tmp_sql = NULL;
   SPIDER_COPY_TABLE_CONN *table_conn, *src_tbl_conn, *dst_tbl_conn;
   SPIDER_CONN *tmp_conn;
+  SPIDER_WIDE_HANDLER *wide_handler;
   spider_db_copy_table *select_ct, *insert_ct;
   MEM_ROOT mem_root;
   longlong bulk_insert_rows;
@@ -1128,13 +1130,15 @@ long long spider_copy_tables_body(
         __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL),
         &tmp_spider->dbton_handler,
           sizeof(spider_db_handler *) * SPIDER_DBTON_SIZE,
+        &wide_handler, sizeof(SPIDER_WIDE_HANDLER),
         NullS))
     ) {
       my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
       goto error;
     }
     tmp_spider->share = table_conn->share;
-    tmp_spider->trx = copy_tables->trx;
+    tmp_spider->wide_handler = wide_handler;
+    wide_handler->trx = copy_tables->trx;
 /*
     if (spider_db_append_set_names(table_conn->share))
     {
@@ -1147,7 +1151,7 @@ long long spider_copy_tables_body(
     tmp_sql[roop_count].set_charset(copy_tables->access_charset);
     tmp_spider->result_list.sqls = &tmp_sql[roop_count];
     tmp_spider->need_mons = &table_conn->need_mon;
-    tmp_spider->lock_type = TL_READ;
+    tmp_spider->wide_handler->lock_type = TL_READ;
     tmp_spider->conn_link_idx = &tmp_conn_link_idx;
     uint dbton_id = tmp_spider->share->use_dbton_ids[0];
     if (!(tmp_spider->dbton_handler[dbton_id] =
@@ -1172,13 +1176,15 @@ long long spider_copy_tables_body(
         __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL),
         &tmp_spider->dbton_handler,
           sizeof(spider_db_handler *) * SPIDER_DBTON_SIZE,
+        &wide_handler, sizeof(SPIDER_WIDE_HANDLER),
         NullS))
     ) {
       my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
       goto error;
     }
     tmp_spider->share = table_conn->share;
-    tmp_spider->trx = copy_tables->trx;
+    tmp_spider->wide_handler = wide_handler;
+    wide_handler->trx = copy_tables->trx;
 /*
     if (spider_db_append_set_names(table_conn->share))
     {
@@ -1191,7 +1197,7 @@ long long spider_copy_tables_body(
     tmp_sql[roop_count].set_charset(copy_tables->access_charset);
     tmp_spider->result_list.sqls = &tmp_sql[roop_count];
     tmp_spider->need_mons = &table_conn->need_mon;
-    tmp_spider->lock_type = TL_WRITE;
+    tmp_spider->wide_handler->lock_type = TL_WRITE;
     tmp_spider->conn_link_idx = &tmp_conn_link_idx;
     uint dbton_id = tmp_spider->share->use_dbton_ids[0];
     if (!(tmp_spider->dbton_handler[dbton_id] =
diff --git a/storage/spider/spd_db_conn.cc b/storage/spider/spd_db_conn.cc
index ad08a264330..729a2b72704 100644
--- a/storage/spider/spd_db_conn.cc
+++ b/storage/spider/spd_db_conn.cc
@@ -278,9 +278,9 @@ int spider_db_ping(
 ) {
   DBUG_ENTER("spider_db_ping");
 #ifndef DBUG_OFF
-  if (spider->trx->thd)
+  if (spider->wide_handler->trx->thd)
     DBUG_PRINT("info", ("spider thd->query_id is %lld",
-      spider->trx->thd->query_id));
+      spider->wide_handler->trx->thd->query_id));
 #endif
   DBUG_RETURN(spider_db_ping_internal(spider->share, conn,
     spider->conn_link_idx[link_idx], &spider->need_mons[link_idx]));
@@ -984,7 +984,8 @@ int spider_db_set_names(
   int link_idx
 ) {
   DBUG_ENTER("spider_db_set_names");
-  DBUG_RETURN(spider_db_set_names_internal(spider->trx, spider->share, conn,
+  DBUG_RETURN(spider_db_set_names_internal(spider->wide_handler->trx,
+    spider->share, conn,
     spider->conn_link_idx[link_idx], &spider->need_mons[link_idx]));
 }
 
@@ -1017,8 +1018,8 @@ int spider_db_query_with_set_names(
       spider->need_mons[link_idx]
     ) {
       error_num = spider_ping_table_mon_from_table(
-          spider->trx,
-          spider->trx->thd,
+          spider->wide_handler->trx,
+          spider->wide_handler->trx->thd,
           share,
           link_idx,
           (uint32) share->monitoring_sid[link_idx],
@@ -1035,7 +1036,8 @@ int spider_db_query_with_set_names(
     }
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (dbton_hdl->execute_sql(
     sql_type,
@@ -1051,8 +1053,8 @@ int spider_db_query_with_set_names(
       spider->need_mons[link_idx]
     ) {
       error_num = spider_ping_table_mon_from_table(
-          spider->trx,
-          spider->trx->thd,
+          spider->wide_handler->trx,
+          spider->wide_handler->trx->thd,
           share,
           link_idx,
           (uint32) share->monitoring_sid[link_idx],
@@ -1104,8 +1106,8 @@ int spider_db_query_for_bulk_update(
       spider->need_mons[link_idx]
     ) {
       error_num = spider_ping_table_mon_from_table(
-          spider->trx,
-          spider->trx->thd,
+          spider->wide_handler->trx,
+          spider->wide_handler->trx->thd,
           share,
           link_idx,
           (uint32) share->monitoring_sid[link_idx],
@@ -1122,7 +1124,8 @@ int spider_db_query_for_bulk_update(
     }
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
   if (dbton_hdl->execute_sql(
@@ -1142,8 +1145,8 @@ int spider_db_query_for_bulk_update(
       spider->need_mons[link_idx]
     ) {
       error_num = spider_ping_table_mon_from_table(
-          spider->trx,
-          spider->trx->thd,
+          spider->wide_handler->trx,
+          spider->wide_handler->trx->thd,
           share,
           link_idx,
           (uint32) share->monitoring_sid[link_idx],
@@ -1159,7 +1162,7 @@ int spider_db_query_for_bulk_update(
         );
     }
     if (
-      spider->ignore_dup_key &&
+      spider->wide_handler->ignore_dup_key &&
       (
         error_num == ER_DUP_ENTRY ||
         error_num == ER_DUP_KEY ||
@@ -1167,7 +1170,7 @@ int spider_db_query_for_bulk_update(
       )
     ) {
       ++(*dup_key_found);
-      spider->trx->thd->clear_error();
+      spider->wide_handler->trx->thd->clear_error();
       DBUG_RETURN(0);
     }
     DBUG_RETURN(error_num);
@@ -1187,8 +1190,8 @@ int spider_db_query_for_bulk_update(
       spider->need_mons[link_idx]
     ) {
       error_num = spider_ping_table_mon_from_table(
-          spider->trx,
-          spider->trx->thd,
+          spider->wide_handler->trx,
+          spider->wide_handler->trx->thd,
           share,
           link_idx,
           (uint32) share->monitoring_sid[link_idx],
@@ -2798,7 +2801,7 @@ int spider_db_fetch_for_item_sum_func(
 ) {
   int error_num;
   SPIDER_SHARE *share = spider->share;
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   DBUG_ENTER("spider_db_fetch_for_item_sum_func");
   DBUG_PRINT("info",("spider Sumfunctype = %d", item_sum->sum_func()));
   switch (item_sum->sum_func())
@@ -3526,7 +3529,8 @@ int spider_db_fetch_minimum_columns(
   ) {
     DBUG_PRINT("info", ("spider field_index %u", (*field)->field_index));
     DBUG_PRINT("info", ("spider searched_bitmap %u",
-      spider_bit_is_set(spider->searched_bitmap, (*field)->field_index)));
+      spider_bit_is_set(spider->wide_handler->searched_bitmap,
+      (*field)->field_index)));
     DBUG_PRINT("info", ("spider read_set %u",
       bitmap_is_set(table->read_set, (*field)->field_index)));
     DBUG_PRINT("info", ("spider write_set %u",
@@ -3708,7 +3712,7 @@ int spider_db_free_result(
   SPIDER_RESULT *result;
   SPIDER_RESULT *prev;
   SPIDER_SHARE *share = spider->share;
-  SPIDER_TRX *trx = spider->trx;
+  SPIDER_TRX *trx = spider->wide_handler->trx;
   SPIDER_POSITION *position;
   int roop_count, error_num;
   DBUG_ENTER("spider_db_free_result");
@@ -4064,8 +4068,9 @@ int spider_db_store_result(
         spider_clear_bit(spider->db_request_phase, link_idx);
       }
       st_spider_db_request_key request_key;
-      request_key.spider_thread_id = spider->trx->spider_thread_id;
-      request_key.query_id = spider->trx->thd->query_id;
+      request_key.spider_thread_id =
+        spider->wide_handler->trx->spider_thread_id;
+      request_key.query_id = spider->wide_handler->trx->thd->query_id;
       request_key.handler = spider;
       request_key.request_id = spider->db_request_id[link_idx];
       request_key.next = NULL;
@@ -4163,8 +4168,9 @@ int spider_db_store_result(
           spider_clear_bit(spider->db_request_phase, link_idx);
         }
         st_spider_db_request_key request_key;
-        request_key.spider_thread_id = spider->trx->spider_thread_id;
-        request_key.query_id = spider->trx->thd->query_id;
+        request_key.spider_thread_id =
+          spider->wide_handler->trx->spider_thread_id;
+        request_key.query_id = spider->wide_handler->trx->thd->query_id;
         request_key.handler = spider;
         request_key.request_id = spider->db_request_id[link_idx];
         request_key.next = NULL;
@@ -4428,8 +4434,8 @@ int spider_db_store_result(
       spider_clear_bit(spider->db_request_phase, link_idx);
     }
     st_spider_db_request_key request_key;
-    request_key.spider_thread_id = spider->trx->spider_thread_id;
-    request_key.query_id = spider->trx->thd->query_id;
+    request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+    request_key.query_id = spider->wide_handler->trx->thd->query_id;
     request_key.handler = spider;
     request_key.request_id = spider->db_request_id[link_idx];
     request_key.next = NULL;
@@ -4474,8 +4480,8 @@ void spider_db_discard_result(
     spider_clear_bit(spider->db_request_phase, link_idx);
   }
   st_spider_db_request_key request_key;
-  request_key.spider_thread_id = spider->trx->spider_thread_id;
-  request_key.query_id = spider->trx->thd->query_id;
+  request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+  request_key.query_id = spider->wide_handler->trx->thd->query_id;
   request_key.handler = spider;
   request_key.request_id = spider->db_request_id[link_idx];
   request_key.next = NULL;
@@ -4500,8 +4506,8 @@ void spider_db_discard_multiple_result(
   {
     spider_clear_bit(spider->db_request_phase, link_idx);
   }
-  request_key.spider_thread_id = spider->trx->spider_thread_id;
-  request_key.query_id = spider->trx->thd->query_id;
+  request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+  request_key.query_id = spider->wide_handler->trx->thd->query_id;
   request_key.handler = spider;
   request_key.request_id = spider->db_request_id[link_idx];
   request_key.next = NULL;
@@ -4809,7 +4815,7 @@ int spider_db_seek_next(
                 DBUG_RETURN(error_num);
               }
               spider_conn_set_timeout_from_share(conn, link_idx,
-                spider->trx->thd, share);
+                spider->wide_handler->trx->thd, share);
               if (dbton_handler->execute_sql(
                 sql_type,
                 conn,
@@ -4899,8 +4905,8 @@ int spider_db_seek_next(
                   spider->need_mons[roop_count]
                 ) {
                   error_num = spider_ping_table_mon_from_table(
-                      spider->trx,
-                      spider->trx->thd,
+                      spider->wide_handler->trx,
+                      spider->wide_handler->trx->thd,
                       share,
                       roop_count,
                       (uint32) share->monitoring_sid[roop_count],
@@ -4919,7 +4925,7 @@ int spider_db_seek_next(
                 DBUG_RETURN(error_num);
               }
               spider_conn_set_timeout_from_share(conn, roop_count,
-                spider->trx->thd, share);
+                spider->wide_handler->trx->thd, share);
               if (dbton_handler->execute_sql(
                 sql_type,
                 conn,
@@ -4934,8 +4940,8 @@ int spider_db_seek_next(
                   spider->need_mons[roop_count]
                 ) {
                   error_num = spider_ping_table_mon_from_table(
-                      spider->trx,
-                      spider->trx->thd,
+                      spider->wide_handler->trx,
+                      spider->wide_handler->trx->thd,
                       share,
                       roop_count,
                       (uint32) share->monitoring_sid[roop_count],
@@ -4967,8 +4973,8 @@ int spider_db_seek_next(
                     spider->need_mons[roop_count]
                   ) {
                     error_num = spider_ping_table_mon_from_table(
-                        spider->trx,
-                        spider->trx->thd,
+                        spider->wide_handler->trx,
+                        spider->wide_handler->trx->thd,
                         share,
                         roop_count,
                         (uint32) share->monitoring_sid[roop_count],
@@ -5153,8 +5159,8 @@ int spider_db_seek_last(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -5171,7 +5177,8 @@ int spider_db_seek_last(
         }
         DBUG_RETURN(error_num);
       }
-      spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, roop_count,
+        spider->wide_handler->trx->thd,
         share);
       if (dbton_handler->execute_sql(
         sql_type,
@@ -5187,8 +5194,8 @@ int spider_db_seek_last(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -5218,8 +5225,8 @@ int spider_db_seek_last(
             spider->need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                spider->trx,
-                spider->trx->thd,
+                spider->wide_handler->trx,
+                spider->wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -5356,8 +5363,8 @@ int spider_db_seek_last(
         spider->need_mons[roop_count]
       ) {
         error_num = spider_ping_table_mon_from_table(
-            spider->trx,
-            spider->trx->thd,
+            spider->wide_handler->trx,
+            spider->wide_handler->trx->thd,
             share,
             roop_count,
             (uint32) share->monitoring_sid[roop_count],
@@ -5374,7 +5381,8 @@ int spider_db_seek_last(
       }
       DBUG_RETURN(error_num);
     }
-    spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
+    spider_conn_set_timeout_from_share(conn, roop_count,
+      spider->wide_handler->trx->thd,
       share);
     if (dbton_handler->execute_sql(
       sql_type,
@@ -5390,8 +5398,8 @@ int spider_db_seek_last(
         spider->need_mons[roop_count]
       ) {
         error_num = spider_ping_table_mon_from_table(
-            spider->trx,
-            spider->trx->thd,
+            spider->wide_handler->trx,
+            spider->wide_handler->trx->thd,
             share,
             roop_count,
             (uint32) share->monitoring_sid[roop_count],
@@ -5421,8 +5429,8 @@ int spider_db_seek_last(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -5521,7 +5529,7 @@ void spider_db_create_position(
   pos->direct_aggregate = result_list->direct_aggregate;
 #endif
   pos->sql_kind = spider->sql_kind[spider->result_link_idx];
-  pos->position_bitmap = spider->position_bitmap;
+  pos->position_bitmap = spider->wide_handler->position_bitmap;
   pos->ft_first = spider->ft_first;
   pos->ft_current = spider->ft_current;
   pos->result = current;
@@ -5893,7 +5901,7 @@ int spider_db_simple_action(
   bool pre_call
 ) {
   int error_num;
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   SPIDER_CONN *conn;
   DBUG_ENTER("spider_db_simple_action");
   if (pre_call)
@@ -6043,7 +6051,8 @@ int spider_db_bulk_insert_init(
       SPIDER_LINK_STATUS_RECOVERY)
   ) {
     if (spider->conns[roop_count])
-      spider->conns[roop_count]->ignore_dup_key = spider->ignore_dup_key;
+      spider->conns[roop_count]->ignore_dup_key =
+        spider->wide_handler->ignore_dup_key;
 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
     if (
       spider_conn_use_handler(spider, spider->lock_mode, roop_count) &&
@@ -6063,8 +6072,8 @@ int spider_db_bulk_insert_init(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -6084,7 +6093,8 @@ int spider_db_bulk_insert_init(
       spider->set_handler_opened(roop_count);
     }
 #else
-    spider_conn_use_handler(spider, spider->lock_mode, roop_count);
+    spider_conn_use_handler(spider, spider->wide_handler->lock_mode,
+      roop_count);
 #endif
   }
 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
@@ -6118,7 +6128,7 @@ int spider_db_bulk_insert(
   SPIDER_RESULT_LIST *result_list = &spider->result_list;
 #endif
   SPIDER_SHARE *share = spider->share;
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   bool mta_conn_mutex_lock_already_backup;
   bool mta_conn_mutex_unlock_later_backup;
   DBUG_ENTER("spider_db_bulk_insert");
@@ -6236,8 +6246,8 @@ int spider_db_bulk_insert(
             spider->need_mons[roop_count2]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                spider->trx,
-                spider->trx->thd,
+                spider->wide_handler->trx,
+                spider->wide_handler->trx->thd,
                 share,
                 roop_count2,
                 (uint32) share->monitoring_sid[roop_count2],
@@ -6254,7 +6264,8 @@ int spider_db_bulk_insert(
           }
           DBUG_RETURN(error_num);
         }
-        spider_conn_set_timeout_from_share(conn, roop_count2, spider->trx->thd,
+        spider_conn_set_timeout_from_share(conn, roop_count2,
+          spider->wide_handler->trx->thd,
           share);
         if (dbton_handler->execute_sql(
           sql_type,
@@ -6286,8 +6297,8 @@ int spider_db_bulk_insert(
             spider->need_mons[roop_count2]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                spider->trx,
-                spider->trx->thd,
+                spider->wide_handler->trx,
+                spider->wide_handler->trx->thd,
                 share,
                 roop_count2,
                 (uint32) share->monitoring_sid[roop_count2],
@@ -6327,8 +6338,9 @@ int spider_db_bulk_insert(
               spider_clear_bit(spider->db_request_phase, roop_count2);
             }
             st_spider_db_request_key request_key;
-            request_key.spider_thread_id = spider->trx->spider_thread_id;
-            request_key.query_id = spider->trx->thd->query_id;
+            request_key.spider_thread_id =
+              spider->wide_handler->trx->spider_thread_id;
+            request_key.query_id = spider->wide_handler->trx->thd->query_id;
             request_key.handler = spider;
             request_key.request_id = spider->db_request_id[roop_count2];
             request_key.next = NULL;
@@ -6447,7 +6459,7 @@ int spider_db_bulk_bulk_insert(
   SPIDER_SHARE *share = spider->share;
   SPIDER_CONN *conn, *first_insert_conn = NULL;
   TABLE *table = spider->get_table();
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   DBUG_ENTER("spider_db_bulk_bulk_insert");
   for (
     roop_count2 = spider_conn_link_idx_next(share->link_statuses,
@@ -6496,8 +6508,9 @@ int spider_db_bulk_bulk_insert(
           spider_clear_bit(spider->db_request_phase, roop_count2);
         }
         st_spider_db_request_key request_key;
-        request_key.spider_thread_id = spider->trx->spider_thread_id;
-        request_key.query_id = spider->trx->thd->query_id;
+        request_key.spider_thread_id =
+          spider->wide_handler->trx->spider_thread_id;
+        request_key.query_id = spider->wide_handler->trx->thd->query_id;
         request_key.handler = spider;
         request_key.request_id = spider->db_request_id[roop_count2];
         request_key.next = NULL;
@@ -6568,7 +6581,7 @@ int spider_db_update_auto_increment(
   int link_idx
 ) {
   int roop_count;
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   ulonglong last_insert_id, affected_rows;
   SPIDER_SHARE *share = spider->share;
   TABLE *table = spider->get_table();
@@ -6730,7 +6743,7 @@ int spider_db_bulk_update_end(
   ha_rows *dup_key_found
 ) {
   int error_num = 0, error_num2, roop_count;
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   SPIDER_SHARE *share = spider->share;
   SPIDER_CONN *conn;
   bool is_error = thd->is_error();
@@ -6905,7 +6918,7 @@ int spider_db_update(
     conn = spider->conns[roop_count];
     spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
 #if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000
-    conn->ignore_dup_key = spider->ignore_dup_key;
+    conn->ignore_dup_key = spider->wide_handler->ignore_dup_key;
 #endif
     if (dbton_hdl->need_lock_before_set_sql_for_exec(
       SPIDER_SQL_TYPE_UPDATE_SQL))
@@ -6938,8 +6951,8 @@ int spider_db_update(
         spider->need_mons[roop_count]
       ) {
         error_num = spider_ping_table_mon_from_table(
-            spider->trx,
-            spider->trx->thd,
+            spider->wide_handler->trx,
+            spider->wide_handler->trx->thd,
             share,
             roop_count,
             (uint32) share->monitoring_sid[roop_count],
@@ -6956,7 +6969,8 @@ int spider_db_update(
       }
       DBUG_RETURN(error_num);
     }
-    spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
+    spider_conn_set_timeout_from_share(conn, roop_count,
+      spider->wide_handler->trx->thd,
       share);
     if (dbton_hdl->execute_sql(
       SPIDER_SQL_TYPE_UPDATE_SQL,
@@ -6975,8 +6989,8 @@ int spider_db_update(
         spider->need_mons[roop_count]
       ) {
         error_num = spider_ping_table_mon_from_table(
-            spider->trx,
-            spider->trx->thd,
+            spider->wide_handler->trx,
+            spider->wide_handler->trx->thd,
             share,
             roop_count,
             (uint32) share->monitoring_sid[roop_count],
@@ -7009,7 +7023,8 @@ int spider_db_update(
         pthread_mutex_unlock(&conn->mta_conn_mutex);
         DBUG_RETURN(error_num);
       }
-      spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, roop_count,
+        spider->wide_handler->trx->thd,
         share);
       if (dbton_hdl->execute_sql(
         SPIDER_SQL_TYPE_INSERT_SQL,
@@ -7028,8 +7043,8 @@ int spider_db_update(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -7255,7 +7270,7 @@ int spider_db_direct_update(
     if (spider->is_bulk_access_clone)
     {
       spider->connection_ids[roop_count] = conn->connection_id;
-      spider_trx_add_bulk_access_conn(spider->trx, conn);
+      spider_trx_add_bulk_access_conn(spider->wide_handler->trx, conn);
     } else {
 #endif
       conn->need_mon = &spider->need_mons[roop_count];
@@ -7272,8 +7287,8 @@ int spider_db_direct_update(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -7290,7 +7305,8 @@ int spider_db_direct_update(
         }
         DBUG_RETURN(error_num);
       }
-      spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, roop_count,
+        spider->wide_handler->trx->thd,
         share);
       if (
         (error_num = dbton_hdl->execute_sql(
@@ -7312,8 +7328,8 @@ int spider_db_direct_update(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -7350,8 +7366,9 @@ int spider_db_direct_update(
           spider_clear_bit(spider->db_request_phase, roop_count);
         }
         st_spider_db_request_key request_key;
-        request_key.spider_thread_id = spider->trx->spider_thread_id;
-        request_key.query_id = spider->trx->thd->query_id;
+        request_key.spider_thread_id =
+          spider->wide_handler->trx->spider_thread_id;
+        request_key.query_id = spider->wide_handler->trx->thd->query_id;
         request_key.handler = spider;
         request_key.request_id = spider->db_request_id[roop_count];
         request_key.next = NULL;
@@ -7515,7 +7532,7 @@ int spider_db_direct_update(
     if (spider->is_bulk_access_clone)
     {
       spider->connection_ids[roop_count] = conn->connection_id;
-      spider_trx_add_bulk_access_conn(spider->trx, conn);
+      spider_trx_add_bulk_access_conn(spider->wide_handler->trx, conn);
     } else {
 #endif
       conn->need_mon = &spider->need_mons[roop_count];
@@ -7532,8 +7549,8 @@ int spider_db_direct_update(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -7550,7 +7567,8 @@ int spider_db_direct_update(
         }
         DBUG_RETURN(error_num);
       }
-      spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, roop_count,
+        spider->wide_handler->trx->thd,
         share);
       if (
         (error_num = dbton_hdl->execute_sql(
@@ -7559,7 +7577,8 @@ int spider_db_direct_update(
           -1,
           &spider->need_mons[roop_count])
         ) &&
-        (error_num != HA_ERR_FOUND_DUPP_KEY || !spider->ignore_dup_key)
+        (error_num != HA_ERR_FOUND_DUPP_KEY ||
+          !spider->wide_handler->ignore_dup_key)
       ) {
         conn->mta_conn_mutex_lock_already = FALSE;
         conn->mta_conn_mutex_unlock_later = FALSE;
@@ -7572,8 +7591,8 @@ int spider_db_direct_update(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -7673,8 +7692,9 @@ int spider_db_bulk_direct_update(
         spider_clear_bit(spider->db_request_phase, roop_count);
       }
       st_spider_db_request_key request_key;
-      request_key.spider_thread_id = spider->trx->spider_thread_id;
-      request_key.query_id = spider->trx->thd->query_id;
+      request_key.spider_thread_id =
+        spider->wide_handler->trx->spider_thread_id;
+      request_key.query_id = spider->wide_handler->trx->thd->query_id;
       request_key.handler = spider;
       request_key.request_id = spider->db_request_id[roop_count];
       request_key.next = NULL;
@@ -7909,7 +7929,7 @@ int spider_db_direct_delete(
     if (spider->is_bulk_access_clone)
     {
       spider->connection_ids[roop_count] = conn->connection_id;
-      spider_trx_add_bulk_access_conn(spider->trx, conn);
+      spider_trx_add_bulk_access_conn(spider->wide_handler->trx, conn);
     } else {
 #endif
       conn->need_mon = &spider->need_mons[roop_count];
@@ -7926,8 +7946,8 @@ int spider_db_direct_delete(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -7944,7 +7964,8 @@ int spider_db_direct_delete(
         }
         DBUG_RETURN(error_num);
       }
-      spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, roop_count,
+        spider->wide_handler->trx->thd,
         share);
       if (dbton_hdl->execute_sql(
         sql_type,
@@ -7960,8 +7981,8 @@ int spider_db_direct_delete(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -7998,8 +8019,9 @@ int spider_db_direct_delete(
           spider_clear_bit(spider->db_request_phase, roop_count);
         }
         st_spider_db_request_key request_key;
-        request_key.spider_thread_id = spider->trx->spider_thread_id;
-        request_key.query_id = spider->trx->thd->query_id;
+        request_key.spider_thread_id =
+          spider->wide_handler->trx->spider_thread_id;
+        request_key.query_id = spider->wide_handler->trx->thd->query_id;
         request_key.handler = spider;
         request_key.request_id = spider->db_request_id[roop_count];
         request_key.next = NULL;
@@ -8131,7 +8153,7 @@ int spider_db_direct_delete(
     if (spider->is_bulk_access_clone)
     {
       spider->connection_ids[roop_count] = conn->connection_id;
-      spider_trx_add_bulk_access_conn(spider->trx, conn);
+      spider_trx_add_bulk_access_conn(spider->wide_handler->trx, conn);
     } else {
 #endif
       conn->need_mon = &spider->need_mons[roop_count];
@@ -8148,8 +8170,8 @@ int spider_db_direct_delete(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -8166,7 +8188,8 @@ int spider_db_direct_delete(
         }
         DBUG_RETURN(error_num);
       }
-      spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, roop_count,
+        spider->wide_handler->trx->thd,
         share);
       if (dbton_hdl->execute_sql(
         sql_type,
@@ -8182,8 +8205,8 @@ int spider_db_direct_delete(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -8268,7 +8291,8 @@ int spider_db_delete_all_rows(
     conn->need_mon = &spider->need_mons[roop_count];
     conn->mta_conn_mutex_lock_already = TRUE;
     conn->mta_conn_mutex_unlock_later = TRUE;
-    spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
+    spider_conn_set_timeout_from_share(conn, roop_count,
+      spider->wide_handler->trx->thd,
       share);
     if (
       (error_num = spider_db_set_names(spider, conn, roop_count)) ||
@@ -8297,8 +8321,8 @@ int spider_db_delete_all_rows(
             spider->need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                spider->trx,
-                spider->trx->thd,
+                spider->wide_handler->trx,
+                spider->wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -8326,8 +8350,8 @@ int spider_db_delete_all_rows(
             spider->need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                spider->trx,
-                spider->trx->thd,
+                spider->wide_handler->trx,
+                spider->wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -8344,7 +8368,8 @@ int spider_db_delete_all_rows(
           }
           DBUG_RETURN(error_num);
         }
-        spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
+        spider_conn_set_timeout_from_share(conn, roop_count,
+          spider->wide_handler->trx->thd,
           share);
         if (dbton_hdl->execute_sql(
           SPIDER_SQL_TYPE_DELETE_SQL,
@@ -8360,8 +8385,8 @@ int spider_db_delete_all_rows(
             spider->need_mons[roop_count]
           ) {
             error_num = spider_ping_table_mon_from_table(
-                spider->trx,
-                spider->trx->thd,
+                spider->wide_handler->trx,
+                spider->wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -8388,8 +8413,8 @@ int spider_db_delete_all_rows(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -8426,7 +8451,7 @@ int spider_db_disable_keys(
   spider_db_handler *dbton_hdl;
   DBUG_ENTER("spider_db_disable_keys");
   if (
-    spider_param_internal_optimize(spider->trx->thd,
+    spider_param_internal_optimize(spider->wide_handler->trx->thd,
       share->internal_optimize) == 1
   ) {
     for (
@@ -8447,8 +8472,8 @@ int spider_db_disable_keys(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -8479,7 +8504,7 @@ int spider_db_enable_keys(
   spider_db_handler *dbton_hdl;
   DBUG_ENTER("spider_db_enable_keys");
   if (
-    spider_param_internal_optimize(spider->trx->thd,
+    spider_param_internal_optimize(spider->wide_handler->trx->thd,
       share->internal_optimize) == 1
   ) {
     for (
@@ -8500,8 +8525,8 @@ int spider_db_enable_keys(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -8533,7 +8558,7 @@ int spider_db_check_table(
   spider_db_handler *dbton_hdl;
   DBUG_ENTER("spider_db_check_table");
   if (
-    spider_param_internal_optimize(spider->trx->thd,
+    spider_param_internal_optimize(spider->wide_handler->trx->thd,
       share->internal_optimize) == 1
   ) {
     for (
@@ -8554,8 +8579,8 @@ int spider_db_check_table(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -8587,7 +8612,7 @@ int spider_db_repair_table(
   spider_db_handler *dbton_hdl;
   DBUG_ENTER("spider_db_repair_table");
   if (
-    spider_param_internal_optimize(spider->trx->thd,
+    spider_param_internal_optimize(spider->wide_handler->trx->thd,
       share->internal_optimize) == 1
   ) {
     for (
@@ -8608,8 +8633,8 @@ int spider_db_repair_table(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -8640,7 +8665,7 @@ int spider_db_analyze_table(
   spider_db_handler *dbton_hdl;
   DBUG_ENTER("spider_db_analyze_table");
   if (
-    spider_param_internal_optimize(spider->trx->thd,
+    spider_param_internal_optimize(spider->wide_handler->trx->thd,
       share->internal_optimize) == 1
   ) {
     for (
@@ -8661,8 +8686,8 @@ int spider_db_analyze_table(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -8693,7 +8718,7 @@ int spider_db_optimize_table(
   spider_db_handler *dbton_hdl;
   DBUG_ENTER("spider_db_optimize_table");
   if (
-    spider_param_internal_optimize(spider->trx->thd,
+    spider_param_internal_optimize(spider->wide_handler->trx->thd,
       share->internal_optimize) == 1
   ) {
     for (
@@ -8714,8 +8739,8 @@ int spider_db_optimize_table(
           spider->need_mons[roop_count]
         ) {
           error_num = spider_ping_table_mon_from_table(
-              spider->trx,
-              spider->trx->thd,
+              spider->wide_handler->trx,
+              spider->wide_handler->trx->thd,
               share,
               roop_count,
               (uint32) share->monitoring_sid[roop_count],
@@ -8764,8 +8789,8 @@ int spider_db_flush_tables(
         spider->need_mons[roop_count]
       ) {
         error_num = spider_ping_table_mon_from_table(
-            spider->trx,
-            spider->trx->thd,
+            spider->wide_handler->trx,
+            spider->wide_handler->trx->thd,
             share,
             roop_count,
             (uint32) share->monitoring_sid[roop_count],
@@ -8812,8 +8837,8 @@ int spider_db_flush_logs(
         spider->need_mons[roop_count]
       ) {
         error_num = spider_ping_table_mon_from_table(
-            spider->trx,
-            spider->trx->thd,
+            spider->wide_handler->trx,
+            spider->wide_handler->trx->thd,
             share,
             roop_count,
             (uint32) share->monitoring_sid[roop_count],
@@ -8992,7 +9017,7 @@ int spider_db_print_item_type_default(
   spider_string *str
 ) {
   DBUG_ENTER("spider_db_print_item_type_default");
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   SPIDER_SHARE *share = spider->share;
   if (spider_param_skip_default_condition(thd,
     share->skip_default_condition))
@@ -9854,12 +9879,13 @@ int spider_db_append_condition(
         DBUG_RETURN(error_num);
     }
   } else {
-    if (spider->cond_check)
-      DBUG_RETURN(spider->cond_check_error);
-    spider->cond_check = TRUE;
-    if ((spider->cond_check_error = spider->append_condition_sql_part(
-      NULL, 0, SPIDER_SQL_TYPE_SELECT_SQL, TRUE)))
-      DBUG_RETURN(spider->cond_check_error);
+    if (spider->wide_handler->cond_check)
+      DBUG_RETURN(spider->wide_handler->cond_check_error);
+    spider->wide_handler->cond_check = TRUE;
+    if ((spider->wide_handler->cond_check_error =
+      spider->append_condition_sql_part(
+        NULL, 0, SPIDER_SQL_TYPE_SELECT_SQL, TRUE)))
+      DBUG_RETURN(spider->wide_handler->cond_check_error);
   }
   DBUG_RETURN(0);
 }
@@ -9876,8 +9902,8 @@ int spider_db_append_update_columns(
 ) {
   int error_num;
   bool add_comma = FALSE;
-  List_iterator_fast<Item> fi(*spider->direct_update_fields),
-    vi(*spider->direct_update_values);
+  List_iterator_fast<Item> fi(*spider->wide_handler->direct_update_fields),
+    vi(*spider->wide_handler->direct_update_values);
   Item *field, *value;
   DBUG_ENTER("spider_db_append_update_columns");
   while ((field = fi++))
@@ -10708,10 +10734,12 @@ int spider_db_udf_ping_table(
     int need_mon = 0;
     uint tmp_conn_link_idx = 0;
     ha_spider spider;
+    SPIDER_WIDE_HANDLER wide_handler;
     uchar db_request_phase = 0;
     ulonglong db_request_id = 0;
     spider.share = share;
-    spider.trx = trx;
+    spider.wide_handler = &wide_handler;
+    wide_handler.trx = trx;
     spider.need_mons = &need_mon;
     spider.conn_link_idx = &tmp_conn_link_idx;
     spider.db_request_phase = &db_request_phase;
@@ -10991,6 +11019,7 @@ int spider_db_udf_ping_table_mon_next(
   int init_sql_alloc_size =
     spider_param_init_sql_alloc_size(thd, share->init_sql_alloc_size);
   ha_spider spider;
+  SPIDER_WIDE_HANDLER wide_handler;
   SPIDER_TRX trx;
   DBUG_ENTER("spider_db_udf_ping_table_mon_next");
   char *sql_buf = (char *) my_alloca(init_sql_alloc_size);
@@ -11005,7 +11034,8 @@ int spider_db_udf_ping_table_mon_next(
   sql_str.length(0);
   trx.thd = thd;
   spider.share = share;
-  spider.trx = &trx;
+  spider.wide_handler = &wide_handler;
+  wide_handler.trx = &trx;
   spider.need_mons = &need_mon;
   spider.conn_link_idx = &tmp_conn_link_idx;
 
@@ -11606,7 +11636,8 @@ int spider_db_open_handler(
       goto error;
     }
 
-    spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+    spider_conn_set_timeout_from_share(conn, link_idx,
+      spider->wide_handler->trx->thd,
       share);
     if (dbton_hdl->execute_sql(
       SPIDER_SQL_TYPE_HANDLER,
@@ -11690,10 +11721,11 @@ int spider_db_open_handler(
     if (spider->is_bulk_access_clone && !spider->bulk_access_executing)
     {
       spider->connection_ids[link_idx] = conn->connection_id;
-      spider_trx_add_bulk_access_conn(spider->trx, conn);
+      spider_trx_add_bulk_access_conn(spider->wide_handler->trx, conn);
     } else {
 #endif
-      spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, link_idx,
+        spider->wide_handler->trx->thd,
         share);
       if (dbton_hdl->execute_sql(
         SPIDER_SQL_TYPE_SELECT_HS,
@@ -11711,8 +11743,9 @@ int spider_db_open_handler(
         spider_clear_bit(spider->db_request_phase, link_idx);
       }
       st_spider_db_request_key request_key;
-      request_key.spider_thread_id = spider->trx->spider_thread_id;
-      request_key.query_id = spider->trx->thd->query_id;
+      request_key.spider_thread_id =
+        spider->wide_handler->trx->spider_thread_id;
+      request_key.query_id = spider->wide_handler->trx->thd->query_id;
       request_key.handler = spider;
       request_key.request_id = spider->db_request_id[link_idx];
       request_key.next = NULL;
@@ -11850,8 +11883,8 @@ int spider_db_bulk_open_handler(
       spider_clear_bit(spider->db_request_phase, link_idx);
     }
     st_spider_db_request_key request_key;
-    request_key.spider_thread_id = spider->trx->spider_thread_id;
-    request_key.query_id = spider->trx->thd->query_id;
+    request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+    request_key.query_id = spider->wide_handler->trx->thd->query_id;
     request_key.handler = spider;
     request_key.request_id = spider->db_request_id[link_idx];
     request_key.next = NULL;
@@ -11907,7 +11940,8 @@ int spider_db_close_handler(
         SPIDER_SQL_TYPE_HANDLER, link_idx)))
         DBUG_RETURN(error_num);
 
-      spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, link_idx,
+        spider->wide_handler->trx->thd,
         spider->share);
       if (dbton_hdl->execute_sql(
         SPIDER_SQL_TYPE_HANDLER,
diff --git a/storage/spider/spd_db_include.h b/storage/spider/spd_db_include.h
index 8d4f972648a..2f386cb60a7 100644
--- a/storage/spider/spd_db_include.h
+++ b/storage/spider/spd_db_include.h
@@ -2045,7 +2045,6 @@ typedef struct st_spider_result_list
 #endif
     int                   quick_phase;
   bool                    keyread;
-  int                     lock_type;
   TABLE                   *table;
 #ifndef WITHOUT_SPIDER_BG_SEARCH
   volatile int            bgs_error;
diff --git a/storage/spider/spd_db_mysql.cc b/storage/spider/spd_db_mysql.cc
index c18f72afa42..0f65a82dfde 100644
--- a/storage/spider/spd_db_mysql.cc
+++ b/storage/spider/spd_db_mysql.cc
@@ -3416,7 +3416,7 @@ int spider_db_mbase::append_lock_tables(
   {
     tmp_spider = tmp_link_for_hash->spider;
     tmp_link_idx = tmp_link_for_hash->link_idx;
-    switch (tmp_spider->lock_type)
+    switch (tmp_spider->wide_handler->lock_type)
     {
       case TL_READ:
         lock_type = SPIDER_DB_TABLE_LOCK_READ_LOCAL;
@@ -3432,7 +3432,8 @@ int spider_db_mbase::append_lock_tables(
         break;
       default:
         // no lock
-        DBUG_PRINT("info",("spider lock_type=%d", tmp_spider->lock_type));
+        DBUG_PRINT("info",("spider lock_type=%d",
+          tmp_spider->wide_handler->lock_type));
         DBUG_RETURN(0);
     }
     conn_link_idx = tmp_spider->conn_link_idx[tmp_link_idx];
@@ -6135,7 +6136,8 @@ int spider_db_mbase_util::open_item_func(
       }
       break;
     case Item_func::UDF_FUNC:
-      use_pushdown_udf = spider_param_use_pushdown_udf(spider->trx->thd,
+      use_pushdown_udf = spider_param_use_pushdown_udf(
+        spider->wide_handler->trx->thd,
         spider->share->use_pushdown_udf);
       if (!use_pushdown_udf)
         DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
@@ -6276,7 +6278,7 @@ int spider_db_mbase_util::open_item_func(
       DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
 #endif
     default:
-      THD *thd = spider->trx->thd;
+      THD *thd = spider->wide_handler->trx->thd;
       SPIDER_SHARE *share = spider->share;
       if (spider_param_skip_default_condition(thd,
         share->skip_default_condition))
@@ -7972,9 +7974,11 @@ int spider_mbase_share::discover_table_structure(
     if (!conn->disable_reconnect)
     {
       ha_spider tmp_spider;
+      SPIDER_WIDE_HANDLER wide_handler;
       int need_mon = 0;
       uint tmp_conn_link_idx = 0;
-      tmp_spider.trx = trx;
+      tmp_spider.wide_handler = &wide_handler;
+      wide_handler.trx = trx;
       tmp_spider.share = spider_share;
       tmp_spider.need_mons = &need_mon;
       tmp_spider.conn_link_idx = &tmp_conn_link_idx;
@@ -8263,7 +8267,7 @@ spider_mariadb_handler::~spider_mariadb_handler()
 int spider_mbase_handler::init()
 {
   uint roop_count;
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   st_spider_share *share = spider->share;
   int init_sql_alloc_size =
     spider_param_init_sql_alloc_size(thd, share->init_sql_alloc_size);
@@ -8699,7 +8703,7 @@ int spider_mbase_handler::append_create_tmp_bka_table(
 ) {
   int error_num;
   SPIDER_SHARE *share = spider->share;
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   char *bka_engine = spider_param_bka_engine(thd, share->bka_engine);
   uint bka_engine_length = strlen(bka_engine),
     cset_length = strlen(table_charset->csname),
@@ -9101,10 +9105,10 @@ int spider_mbase_handler::append_insert(
   direct_insert_kind = SPIDER_SQL_DIRECT_INSERT_KIND_INSERT;
   if (
     (
-      spider->write_can_replace ||
+      spider->wide_handler->write_can_replace ||
       /* for direct_dup_insert without patch for partition */
-      spider->sql_command == SQLCOM_REPLACE ||
-      spider->sql_command == SQLCOM_REPLACE_SELECT
+      spider->wide_handler->sql_command == SQLCOM_REPLACE ||
+      spider->wide_handler->sql_command == SQLCOM_REPLACE_SELECT
     ) &&
     spider->direct_dup_insert
   ) {
@@ -9117,13 +9121,13 @@ int spider_mbase_handler::append_insert(
       DBUG_RETURN(HA_ERR_OUT_OF_MEM);
     str->q_append(SPIDER_SQL_INSERT_STR, SPIDER_SQL_INSERT_LEN);
   }
-  if (spider->low_priority)
+  if (spider->wide_handler->low_priority)
   {
     if (str->reserve(SPIDER_SQL_LOW_PRIORITY_LEN))
       DBUG_RETURN(HA_ERR_OUT_OF_MEM);
     str->q_append(SPIDER_SQL_LOW_PRIORITY_STR, SPIDER_SQL_LOW_PRIORITY_LEN);
   }
-  else if (spider->insert_delayed)
+  else if (spider->wide_handler->insert_delayed)
   {
     if (share->internal_delayed)
     {
@@ -9133,28 +9137,28 @@ int spider_mbase_handler::append_insert(
     }
   }
   else if (
-    spider->lock_type >= TL_WRITE &&
-    !spider->write_can_replace &&
+    spider->wide_handler->lock_type >= TL_WRITE &&
+    !spider->wide_handler->write_can_replace &&
     /* for direct_dup_insert without patch for partition */
-    spider->sql_command != SQLCOM_REPLACE &&
-    spider->sql_command != SQLCOM_REPLACE_SELECT
+    spider->wide_handler->sql_command != SQLCOM_REPLACE &&
+    spider->wide_handler->sql_command != SQLCOM_REPLACE_SELECT
   ) {
     if (str->reserve(SPIDER_SQL_HIGH_PRIORITY_LEN))
       DBUG_RETURN(HA_ERR_OUT_OF_MEM);
     str->q_append(SPIDER_SQL_HIGH_PRIORITY_STR, SPIDER_SQL_HIGH_PRIORITY_LEN);
   }
   if (
-    spider->ignore_dup_key &&
+    spider->wide_handler->ignore_dup_key &&
     spider->direct_dup_insert &&
-    !spider->write_can_replace &&
+    !spider->wide_handler->write_can_replace &&
 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
-    (!spider->insert_with_update || !dup_update_sql.length()) &&
+    (!spider->wide_handler->insert_with_update || !dup_update_sql.length()) &&
 #else
-    !spider->insert_with_update &&
+    !spider->wide_handler->insert_with_update &&
 #endif
     /* for direct_dup_insert without patch for partition */
-    spider->sql_command != SQLCOM_REPLACE &&
-    spider->sql_command != SQLCOM_REPLACE_SELECT
+    spider->wide_handler->sql_command != SQLCOM_REPLACE &&
+    spider->wide_handler->sql_command != SQLCOM_REPLACE_SELECT
   ) {
     direct_insert_kind = SPIDER_SQL_DIRECT_INSERT_KIND_IGNORE;
     if (str->reserve(SPIDER_SQL_SQL_IGNORE_LEN))
@@ -9181,15 +9185,15 @@ int spider_mbase_handler::append_update(
   if (str->reserve(SPIDER_SQL_UPDATE_LEN))
     DBUG_RETURN(HA_ERR_OUT_OF_MEM);
   str->q_append(SPIDER_SQL_UPDATE_STR, SPIDER_SQL_UPDATE_LEN);
-  if (spider->low_priority)
+  if (spider->wide_handler->low_priority)
   {
     if (str->reserve(SPIDER_SQL_LOW_PRIORITY_LEN))
       DBUG_RETURN(HA_ERR_OUT_OF_MEM);
     str->q_append(SPIDER_SQL_LOW_PRIORITY_STR, SPIDER_SQL_LOW_PRIORITY_LEN);
   }
   if (
-    spider->ignore_dup_key &&
-    !spider->insert_with_update
+    spider->wide_handler->ignore_dup_key &&
+    !spider->wide_handler->insert_with_update
   ) {
     if (str->reserve(SPIDER_SQL_SQL_IGNORE_LEN))
       DBUG_RETURN(HA_ERR_OUT_OF_MEM);
@@ -9220,20 +9224,20 @@ int spider_mbase_handler::append_delete(
   if (str->reserve(SPIDER_SQL_DELETE_LEN))
     DBUG_RETURN(HA_ERR_OUT_OF_MEM);
   str->q_append(SPIDER_SQL_DELETE_STR, SPIDER_SQL_DELETE_LEN);
-  if (spider->low_priority)
+  if (spider->wide_handler->low_priority)
   {
     if (str->reserve(SPIDER_SQL_LOW_PRIORITY_LEN))
       DBUG_RETURN(HA_ERR_OUT_OF_MEM);
     str->q_append(SPIDER_SQL_LOW_PRIORITY_STR, SPIDER_SQL_LOW_PRIORITY_LEN);
   }
-  if (spider->quick_mode)
+  if (spider->wide_handler->quick_mode)
   {
     if (str->reserve(SPIDER_SQL_SQL_QUICK_MODE_LEN))
       DBUG_RETURN(HA_ERR_OUT_OF_MEM);
     str->q_append(SPIDER_SQL_SQL_QUICK_MODE_STR,
       SPIDER_SQL_SQL_QUICK_MODE_LEN);
   }
-  if (spider->ignore_dup_key)
+  if (spider->wide_handler->ignore_dup_key)
   {
     if (str->reserve(SPIDER_SQL_SQL_IGNORE_LEN))
       DBUG_RETURN(HA_ERR_OUT_OF_MEM);
@@ -9396,7 +9400,7 @@ int spider_mbase_handler::append_direct_update_set(
   DBUG_ENTER("spider_mbase_handler::append_direct_update_set");
   if (
     spider->direct_update_kinds == SPIDER_SQL_KIND_SQL &&
-    spider->direct_update_fields
+    spider->wide_handler->direct_update_fields
   ) {
     if (str->reserve(SPIDER_SQL_SET_LEN))
       DBUG_RETURN(HA_ERR_OUT_OF_MEM);
@@ -9539,6 +9543,7 @@ int spider_mbase_handler::append_select(
   ulong sql_type
 ) {
   SPIDER_RESULT_LIST *result_list = &spider->result_list;
+  SPIDER_WIDE_HANDLER *wide_handler = spider->wide_handler;
   DBUG_ENTER("spider_mbase_handler::append_select");
   if (sql_type == SPIDER_SQL_TYPE_HANDLER)
   {
@@ -9555,13 +9560,15 @@ int spider_mbase_handler::append_select(
         DBUG_RETURN(HA_ERR_OUT_OF_MEM);
       str->q_append(SPIDER_SQL_DISTINCT_STR, SPIDER_SQL_DISTINCT_LEN);
     }
-    if (result_list->lock_type != F_WRLCK && spider->lock_mode < 1)
+    if (wide_handler->external_lock_type != F_WRLCK &&
+      wide_handler->lock_mode < 1)
     {
       /* no lock */
 #ifdef SPIDER_SQL_CACHE_IS_IN_LEX
-      LEX *lex = spider->trx->thd->lex;
+      LEX *lex = wide_handler->trx->thd->lex;
 #else
-      st_select_lex *select_lex = &spider->trx->thd->lex->select_lex;
+      st_select_lex *select_lex =
+        &wide_handler->trx->thd->lex->select_lex;
 #endif
       if (
 #ifdef SPIDER_SQL_CACHE_IS_IN_LEX
@@ -9599,7 +9606,7 @@ int spider_mbase_handler::append_select(
           SPIDER_SQL_SQL_NO_CACHE_LEN);
       }
     }
-    if (spider->high_priority)
+    if (wide_handler->high_priority)
     {
       if (str->reserve(SPIDER_SQL_HIGH_PRIORITY_LEN))
         DBUG_RETURN(HA_ERR_OUT_OF_MEM);
@@ -10597,7 +10604,7 @@ int spider_mbase_handler::append_update_where(
 ) {
   uint field_name_length;
   Field **field;
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   SPIDER_SHARE *share = spider->share;
   bool no_pk = (table->s->primary_key == MAX_KEY);
   DBUG_ENTER("spider_mbase_handler::append_update_where");
@@ -10763,7 +10770,7 @@ int spider_mbase_handler::append_condition_part(
         ha_where_pos = str->length();
 
         if (
-          spider->sql_command == SQLCOM_HA_READ ||
+          spider->wide_handler->sql_command == SQLCOM_HA_READ ||
           !spider->result_list.use_both_key
         ) {
           if (sql_part2.length())
@@ -10792,7 +10799,7 @@ int spider_mbase_handler::append_condition(
   ulong sql_type
 ) {
   int error_num, restart_pos = 0, start_where_pos;
-  SPIDER_CONDITION *tmp_cond = spider->condition;
+  SPIDER_CONDITION *tmp_cond = spider->wide_handler->condition;
   DBUG_ENTER("spider_mbase_handler::append_condition");
   if (str && start_where)
   {
@@ -10803,7 +10810,7 @@ int spider_mbase_handler::append_condition(
 
   if (spider->is_clone && !tmp_cond)
   {
-    tmp_cond = spider->pt_clone_source_handler->condition;
+    tmp_cond = spider->pt_clone_source_handler->wide_handler->condition;
   }
 
   while (tmp_cond)
@@ -12275,7 +12282,7 @@ int spider_mbase_handler::append_from(
     str->q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN);
     table_name_pos = str->length();
     append_table_name_with_adjusting(str, link_idx, sql_type);
-    if(spider_param_index_hint_pushdown(spider->trx->thd))
+    if(spider_param_index_hint_pushdown(spider->wide_handler->trx->thd))
     {
       if((error_num = append_index_hint(str, link_idx, sql_type)))
       {
@@ -12356,7 +12363,8 @@ int spider_mbase_handler::append_optimize_table(
 ) {
   SPIDER_SHARE *share = spider->share;
   int conn_link_idx = spider->conn_link_idx[link_idx];
-  int local_length = spider_param_internal_optimize_local(spider->trx->thd,
+  int local_length = spider_param_internal_optimize_local(
+    spider->wide_handler->trx->thd,
     share->internal_optimize_local) * SPIDER_SQL_SQL_LOCAL_LEN;
   DBUG_ENTER("spider_mbase_handler::append_optimize_table");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -12401,7 +12409,8 @@ int spider_mbase_handler::append_analyze_table(
 ) {
   SPIDER_SHARE *share = spider->share;
   int conn_link_idx = spider->conn_link_idx[link_idx];
-  int local_length = spider_param_internal_optimize_local(spider->trx->thd,
+  int local_length = spider_param_internal_optimize_local(
+    spider->wide_handler->trx->thd,
     share->internal_optimize_local) * SPIDER_SQL_SQL_LOCAL_LEN;
   DBUG_ENTER("spider_mbase_handler::append_analyze_table");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -12448,7 +12457,8 @@ int spider_mbase_handler::append_repair_table(
 ) {
   SPIDER_SHARE *share = spider->share;
   int conn_link_idx = spider->conn_link_idx[link_idx];
-  int local_length = spider_param_internal_optimize_local(spider->trx->thd,
+  int local_length = spider_param_internal_optimize_local(
+    spider->wide_handler->trx->thd,
     share->internal_optimize_local) * SPIDER_SQL_SQL_LOCAL_LEN;
   DBUG_ENTER("spider_mbase_handler::append_repair_table");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -12658,7 +12668,7 @@ int spider_mbase_handler::append_delete_all_rows(
   int error_num;
   DBUG_ENTER("spider_mbase_handler::append_delete_all_rows");
   DBUG_PRINT("info",("spider this=%p", this));
-  if (spider->sql_command == SQLCOM_TRUNCATE)
+  if (spider->wide_handler->sql_command == SQLCOM_TRUNCATE)
   {
     if ((error_num = append_truncate(str, sql_type, first_link_idx)))
       DBUG_RETURN(error_num);
@@ -12964,7 +12974,7 @@ bool spider_mbase_handler::bulk_tmp_table_created()
 
 int spider_mbase_handler::mk_bulk_tmp_table_and_bulk_start()
 {
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   TABLE *table = spider->get_table();
   DBUG_ENTER("spider_mbase_handler::mk_bulk_tmp_table_and_bulk_start");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -12993,7 +13003,8 @@ void spider_mbase_handler::rm_bulk_tmp_table()
   DBUG_PRINT("info",("spider this=%p", this));
   if (upd_tmp_tbl)
   {
-    spider_rm_sys_tmp_table(spider->trx->thd, upd_tmp_tbl, &upd_tmp_tbl_prm);
+    spider_rm_sys_tmp_table(spider->wide_handler->trx->thd, upd_tmp_tbl,
+      &upd_tmp_tbl_prm);
     upd_tmp_tbl = NULL;
   }
   DBUG_VOID_RETURN;
@@ -13067,9 +13078,12 @@ int spider_mbase_handler::append_lock_tables_list(
   spider_db_mbase *db_conn = (spider_db_mbase *) conn->db_conn;
   DBUG_ENTER("spider_mbase_handler::append_lock_tables_list");
   DBUG_PRINT("info",("spider this=%p", this));
+  DBUG_PRINT("info",("spider db_conn=%p", db_conn));
   tmp_link_for_hash2 = &link_for_hash[link_idx];
   tmp_link_for_hash2->db_table_str =
     &mysql_share->db_table_str[conn_link_idx];
+  DBUG_PRINT("info",("spider db_table_str=%s",
+    tmp_link_for_hash2->db_table_str->c_ptr_safe()));
 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
   tmp_link_for_hash2->db_table_str_hash_value =
     mysql_share->db_table_str_hash_value[conn_link_idx];
@@ -13090,7 +13104,8 @@ int spider_mbase_handler::append_lock_tables_list(
       DBUG_RETURN(error_num);
     *appended = 1;
   } else {
-    if (tmp_link_for_hash->spider->lock_type < spider->lock_type)
+    if (tmp_link_for_hash->spider->wide_handler->lock_type <
+      spider->wide_handler->lock_type)
     {
 #ifdef HASH_UPDATE_WITH_HASH_VALUE
       my_hash_delete_with_hash_value(
@@ -13130,7 +13145,7 @@ int spider_mbase_handler::append_lock_tables_list(
 int spider_mbase_handler::realloc_sql(
   ulong *realloced
 ) {
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   st_spider_share *share = spider->share;
   int init_sql_alloc_size =
     spider_param_init_sql_alloc_size(thd, share->init_sql_alloc_size);
@@ -13587,7 +13602,8 @@ int spider_mbase_handler::show_table_status(
     conn->mta_conn_mutex_lock_already = TRUE;
     conn->mta_conn_mutex_unlock_later = TRUE;
     conn->disable_connect_retry = TRUE;
-    spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+    spider_conn_set_timeout_from_share(conn, link_idx,
+      spider->wide_handler->trx->thd,
       share);
     if (
       (error_num = spider_db_set_names(spider, conn, link_idx)) ||
@@ -13624,7 +13640,8 @@ int spider_mbase_handler::show_table_status(
           pthread_mutex_unlock(&conn->mta_conn_mutex);
           DBUG_RETURN(error_num);
         }
-        spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+        spider_conn_set_timeout_from_share(conn, link_idx,
+          spider->wide_handler->trx->thd,
           share);
         if (spider_db_query(
           conn,
@@ -13648,8 +13665,8 @@ int spider_mbase_handler::show_table_status(
       }
     }
     st_spider_db_request_key request_key;
-    request_key.spider_thread_id = spider->trx->spider_thread_id;
-    request_key.query_id = spider->trx->thd->query_id;
+    request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+    request_key.query_id = spider->wide_handler->trx->thd->query_id;
     request_key.handler = spider;
     request_key.request_id = 1;
     request_key.next = NULL;
@@ -13720,7 +13737,8 @@ int spider_mbase_handler::show_table_status(
     conn->mta_conn_mutex_lock_already = TRUE;
     conn->mta_conn_mutex_unlock_later = TRUE;
     conn->disable_connect_retry = TRUE;
-    spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+    spider_conn_set_timeout_from_share(conn, link_idx,
+      spider->wide_handler->trx->thd,
       share);
     if (
       (error_num = spider_db_set_names(spider, conn, link_idx)) ||
@@ -13757,7 +13775,8 @@ int spider_mbase_handler::show_table_status(
           pthread_mutex_unlock(&conn->mta_conn_mutex);
           DBUG_RETURN(error_num);
         }
-        spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+        spider_conn_set_timeout_from_share(conn, link_idx,
+          spider->wide_handler->trx->thd,
           share);
         if (spider_db_query(
           conn,
@@ -13781,8 +13800,8 @@ int spider_mbase_handler::show_table_status(
       }
     }
     st_spider_db_request_key request_key;
-    request_key.spider_thread_id = spider->trx->spider_thread_id;
-    request_key.query_id = spider->trx->thd->query_id;
+    request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+    request_key.query_id = spider->wide_handler->trx->thd->query_id;
     request_key.handler = spider;
     request_key.request_id = 1;
     request_key.next = NULL;
@@ -13887,7 +13906,8 @@ int spider_mbase_handler::show_index(
     conn->need_mon = &spider->need_mons[link_idx];
     conn->mta_conn_mutex_lock_already = TRUE;
     conn->mta_conn_mutex_unlock_later = TRUE;
-    spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+    spider_conn_set_timeout_from_share(conn, link_idx,
+      spider->wide_handler->trx->thd,
       share);
     if (
       (error_num = spider_db_set_names(spider, conn, link_idx)) ||
@@ -13922,7 +13942,8 @@ int spider_mbase_handler::show_index(
           pthread_mutex_unlock(&conn->mta_conn_mutex);
           DBUG_RETURN(error_num);
         }
-        spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+        spider_conn_set_timeout_from_share(conn, link_idx,
+          spider->wide_handler->trx->thd,
           share);
         if (spider_db_query(
           conn,
@@ -13944,8 +13965,8 @@ int spider_mbase_handler::show_index(
       }
     }
     st_spider_db_request_key request_key;
-    request_key.spider_thread_id = spider->trx->spider_thread_id;
-    request_key.query_id = spider->trx->thd->query_id;
+    request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+    request_key.query_id = spider->wide_handler->trx->thd->query_id;
     request_key.handler = spider;
     request_key.request_id = 1;
     request_key.next = NULL;
@@ -14020,7 +14041,8 @@ int spider_mbase_handler::show_index(
     conn->need_mon = &spider->need_mons[link_idx];
     conn->mta_conn_mutex_lock_already = TRUE;
     conn->mta_conn_mutex_unlock_later = TRUE;
-    spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+    spider_conn_set_timeout_from_share(conn, link_idx,
+      spider->wide_handler->trx->thd,
       share);
     if (
       (error_num = spider_db_set_names(spider, conn, link_idx)) ||
@@ -14055,7 +14077,8 @@ int spider_mbase_handler::show_index(
           pthread_mutex_unlock(&conn->mta_conn_mutex);
           DBUG_RETURN(error_num);
         }
-        spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+        spider_conn_set_timeout_from_share(conn, link_idx,
+          spider->wide_handler->trx->thd,
           share);
         if (spider_db_query(
           conn,
@@ -14077,8 +14100,8 @@ int spider_mbase_handler::show_index(
       }
     }
     st_spider_db_request_key request_key;
-    request_key.spider_thread_id = spider->trx->spider_thread_id;
-    request_key.query_id = spider->trx->thd->query_id;
+    request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+    request_key.query_id = spider->wide_handler->trx->thd->query_id;
     request_key.handler = spider;
     request_key.request_id = 1;
     request_key.next = NULL;
@@ -14208,7 +14231,8 @@ int spider_mbase_handler::simple_action(
   conn->need_mon = &spider->need_mons[link_idx];
   conn->mta_conn_mutex_lock_already = TRUE;
   conn->mta_conn_mutex_unlock_later = TRUE;
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (
     (error_num = spider_db_set_names(spider, conn, link_idx)) ||
@@ -14245,7 +14269,8 @@ int spider_mbase_handler::simple_action(
         DBUG_PRINT("info", ("spider error_num=%d 2", error_num));
         DBUG_RETURN(error_num);
       }
-      spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, link_idx,
+        spider->wide_handler->trx->thd,
         share);
       if (spider_db_query(
         conn,
@@ -14269,8 +14294,8 @@ int spider_mbase_handler::simple_action(
     }
   }
   st_spider_db_request_key request_key;
-  request_key.spider_thread_id = spider->trx->spider_thread_id;
-  request_key.query_id = spider->trx->thd->query_id;
+  request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+  request_key.query_id = spider->wide_handler->trx->thd->query_id;
   request_key.handler = spider;
   request_key.request_id = 1;
   request_key.next = NULL;
@@ -14329,7 +14354,7 @@ int spider_mbase_handler::show_records(
     DBUG_PRINT("info", ("spider error_num=%d", error_num));
     DBUG_RETURN(error_num);
   }
-  spider->trx->direct_aggregate_count++;
+  spider->wide_handler->trx->direct_aggregate_count++;
   DBUG_RETURN(0);
 }
 
@@ -14378,7 +14403,8 @@ ha_rows spider_mbase_handler::explain_select(
   conn->need_mon = &spider->need_mons[link_idx];
   conn->mta_conn_mutex_lock_already = TRUE;
   conn->mta_conn_mutex_unlock_later = TRUE;
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     spider->share);
   if (
     (error_num = spider_db_set_names(spider, conn, link_idx)) ||
@@ -14417,7 +14443,8 @@ ha_rows spider_mbase_handler::explain_select(
         pthread_mutex_unlock(&conn->mta_conn_mutex);
         DBUG_RETURN(HA_POS_ERROR);
       }
-      spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, link_idx,
+        spider->wide_handler->trx->thd,
         spider->share);
       if (spider_db_query(
         conn,
@@ -14446,8 +14473,8 @@ ha_rows spider_mbase_handler::explain_select(
     }
   }
   st_spider_db_request_key request_key;
-  request_key.spider_thread_id = spider->trx->spider_thread_id;
-  request_key.query_id = spider->trx->thd->query_id;
+  request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+  request_key.query_id = spider->wide_handler->trx->thd->query_id;
   request_key.handler = spider;
   request_key.request_id = 1;
   request_key.next = NULL;
@@ -14516,7 +14543,8 @@ int spider_mbase_handler::lock_tables(
       pthread_mutex_unlock(&conn->mta_conn_mutex);
       DBUG_RETURN(error_num);
     }
-    spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+    spider_conn_set_timeout_from_share(conn, link_idx,
+      spider->wide_handler->trx->thd,
       spider->share);
     if (spider_db_query(
       conn,
@@ -14537,7 +14565,7 @@ int spider_mbase_handler::lock_tables(
   if (!conn->table_locked)
   {
     conn->table_locked = TRUE;
-    spider->trx->locked_connections++;
+    spider->wide_handler->trx->locked_connections++;
   }
   DBUG_RETURN(0);
 }
@@ -14552,7 +14580,7 @@ int spider_mbase_handler::unlock_tables(
   {
     spider_string *str = &sql;
     conn->table_locked = FALSE;
-    spider->trx->locked_connections--;
+    spider->wide_handler->trx->locked_connections--;
 
     str->length(0);
     if ((error_num = conn->db_conn->append_unlock_tables(str)))
@@ -14561,7 +14589,8 @@ int spider_mbase_handler::unlock_tables(
     }
     if (str->length())
     {
-      spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, link_idx,
+        spider->wide_handler->trx->thd,
         spider->share);
       if (spider_db_query(
         conn,
@@ -14606,7 +14635,8 @@ int spider_mbase_handler::disable_keys(
     pthread_mutex_unlock(&conn->mta_conn_mutex);
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -14655,7 +14685,8 @@ int spider_mbase_handler::enable_keys(
     pthread_mutex_unlock(&conn->mta_conn_mutex);
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -14705,7 +14736,8 @@ int spider_mbase_handler::check_table(
     pthread_mutex_unlock(&conn->mta_conn_mutex);
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -14755,7 +14787,8 @@ int spider_mbase_handler::repair_table(
     pthread_mutex_unlock(&conn->mta_conn_mutex);
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -14804,7 +14837,8 @@ int spider_mbase_handler::analyze_table(
     pthread_mutex_unlock(&conn->mta_conn_mutex);
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -14853,7 +14887,8 @@ int spider_mbase_handler::optimize_table(
     pthread_mutex_unlock(&conn->mta_conn_mutex);
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -14890,7 +14925,8 @@ int spider_mbase_handler::flush_tables(
   {
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -14915,7 +14951,8 @@ int spider_mbase_handler::flush_logs(
   SPIDER_SHARE *share = spider->share;
   DBUG_ENTER("spider_mbase_handler::flush_logs");
   DBUG_PRINT("info",("spider this=%p", this));
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -15037,16 +15074,17 @@ void spider_mbase_handler::minimum_select_bitmap_create()
       }
     }
   }
-  DBUG_PRINT("info",("spider searched_bitmap=%p", spider->searched_bitmap));
+  DBUG_PRINT("info",("spider searched_bitmap=%p",
+    spider->wide_handler->searched_bitmap));
   for (field_p = table->field; *field_p; field_p++)
   {
     uint field_index = (*field_p)->field_index;
     DBUG_PRINT("info",("spider field_index=%u", field_index));
     DBUG_PRINT("info",("spider ft_discard_bitmap=%s",
-      spider_bit_is_set(spider->ft_discard_bitmap, field_index) ?
+      spider_bit_is_set(spider->wide_handler->ft_discard_bitmap, field_index) ?
         "TRUE" : "FALSE"));
     DBUG_PRINT("info",("spider searched_bitmap=%s",
-      spider_bit_is_set(spider->searched_bitmap, field_index) ?
+      spider_bit_is_set(spider->wide_handler->searched_bitmap, field_index) ?
         "TRUE" : "FALSE"));
     DBUG_PRINT("info",("spider read_set=%s",
       bitmap_is_set(table->read_set, field_index) ?
@@ -15055,10 +15093,10 @@ void spider_mbase_handler::minimum_select_bitmap_create()
       bitmap_is_set(table->write_set, field_index) ?
         "TRUE" : "FALSE"));
     if (
-      spider_bit_is_set(spider->ft_discard_bitmap, field_index) &&
+      spider_bit_is_set(spider->wide_handler->ft_discard_bitmap, field_index) &
       (
-        spider_bit_is_set(spider->searched_bitmap, field_index) ||
-        bitmap_is_set(table->read_set, field_index) ||
+        spider_bit_is_set(spider->wide_handler->searched_bitmap, field_index) |
+        bitmap_is_set(table->read_set, field_index) |
         bitmap_is_set(table->write_set, field_index)
       )
     ) {
diff --git a/storage/spider/spd_db_oracle.cc b/storage/spider/spd_db_oracle.cc
index fd3efd2bd67..bbb03640aa8 100644
--- a/storage/spider/spd_db_oracle.cc
+++ b/storage/spider/spd_db_oracle.cc
@@ -2315,7 +2315,7 @@ int spider_db_oracle::append_lock_tables(
 
     tmp_spider = tmp_link_for_hash->spider;
     tmp_link_idx = tmp_link_for_hash->link_idx;
-    switch (tmp_spider->lock_type)
+    switch (tmp_spider->wide_handler->lock_type)
     {
       case TL_READ:
         lock_type = SPIDER_DB_TABLE_LOCK_READ_LOCAL;
@@ -2331,7 +2331,8 @@ int spider_db_oracle::append_lock_tables(
         break;
       default:
         // no lock
-        DBUG_PRINT("info",("spider lock_type=%d", tmp_spider->lock_type));
+        DBUG_PRINT("info",("spider lock_type=%d",
+          tmp_spider->wide_handler->lock_type));
         DBUG_RETURN(0);
     }
     conn_link_idx = tmp_spider->conn_link_idx[tmp_link_idx];
@@ -4015,7 +4016,8 @@ int spider_db_oracle_util::open_item_func(
       }
       break;
     case Item_func::UDF_FUNC:
-      use_pushdown_udf = spider_param_use_pushdown_udf(spider->trx->thd,
+      use_pushdown_udf = spider_param_use_pushdown_udf(
+        spider->wide_handler->trx->thd,
         spider->share->use_pushdown_udf);
       if (!use_pushdown_udf)
         DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
@@ -4156,7 +4158,7 @@ int spider_db_oracle_util::open_item_func(
       DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
 #endif
     default:
-      THD *thd = spider->trx->thd;
+      THD *thd = spider->wide_handler->trx->thd;
       SPIDER_SHARE *share = spider->share;
       if (spider_param_skip_default_condition(thd,
         share->skip_default_condition))
@@ -5487,7 +5489,7 @@ spider_oracle_handler::~spider_oracle_handler()
 int spider_oracle_handler::init()
 {
   uint roop_count;
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   st_spider_share *share = spider->share;
   int init_sql_alloc_size =
     spider_param_init_sql_alloc_size(thd, share->init_sql_alloc_size);
@@ -5869,7 +5871,7 @@ int spider_oracle_handler::append_create_tmp_bka_table(
 ) {
   int error_num;
   SPIDER_SHARE *share = spider->share;
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   char *bka_engine = spider_param_bka_engine(thd, share->bka_engine);
   uint bka_engine_length = strlen(bka_engine),
     cset_length = strlen(table_charset->csname);
@@ -6479,7 +6481,7 @@ int spider_oracle_handler::append_direct_update_set(
   DBUG_ENTER("spider_oracle_handler::append_direct_update_set");
   if (
     spider->direct_update_kinds == SPIDER_SQL_KIND_SQL &&
-    spider->direct_update_fields
+    spider->wide_handler->direct_update_fields
   ) {
     if (str->reserve(SPIDER_SQL_SET_LEN))
       DBUG_RETURN(HA_ERR_OUT_OF_MEM);
@@ -6587,8 +6589,8 @@ int spider_oracle_handler::append_update_columns(
   uint alias_length
 ) {
   int error_num;
-  List_iterator_fast<Item> fi(*spider->direct_update_fields),
-    vi(*spider->direct_update_values);
+  List_iterator_fast<Item> fi(*spider->wide_handler->direct_update_fields),
+    vi(*spider->wide_handler->direct_update_values);
   Item *field, *value;
   DBUG_ENTER("spider_oracle_handler::append_update_columns");
   while ((field = fi++))
@@ -7618,7 +7620,7 @@ int spider_oracle_handler::append_update_where(
 ) {
   uint field_name_length;
   Field **field;
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   SPIDER_SHARE *share = spider->share;
   bool no_pk = (table->s->primary_key == MAX_KEY);
   DBUG_ENTER("spider_oracle_handler::append_update_where");
@@ -9816,7 +9818,8 @@ int spider_oracle_handler::append_optimize_table(
 ) {
   SPIDER_SHARE *share = spider->share;
   int conn_link_idx = spider->conn_link_idx[link_idx];
-  int local_length = spider_param_internal_optimize_local(spider->trx->thd,
+  int local_length = spider_param_internal_optimize_local(
+    spider->wide_handler->trx->thd,
     share->internal_optimize_local) * SPIDER_SQL_SQL_LOCAL_LEN;
   DBUG_ENTER("spider_oracle_handler::append_optimize_table");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -9861,7 +9864,8 @@ int spider_oracle_handler::append_analyze_table(
 ) {
   SPIDER_SHARE *share = spider->share;
   int conn_link_idx = spider->conn_link_idx[link_idx];
-  int local_length = spider_param_internal_optimize_local(spider->trx->thd,
+  int local_length = spider_param_internal_optimize_local(
+    spider->wide_handler->trx->thd,
     share->internal_optimize_local) * SPIDER_SQL_SQL_LOCAL_LEN;
   DBUG_ENTER("spider_oracle_handler::append_analyze_table");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -9908,7 +9912,8 @@ int spider_oracle_handler::append_repair_table(
 ) {
   SPIDER_SHARE *share = spider->share;
   int conn_link_idx = spider->conn_link_idx[link_idx];
-  int local_length = spider_param_internal_optimize_local(spider->trx->thd,
+  int local_length = spider_param_internal_optimize_local(
+    spider->wide_handler->trx->thd,
     share->internal_optimize_local) * SPIDER_SQL_SQL_LOCAL_LEN;
   DBUG_ENTER("spider_oracle_handler::append_repair_table");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -10425,7 +10430,7 @@ bool spider_oracle_handler::bulk_tmp_table_created()
 
 int spider_oracle_handler::mk_bulk_tmp_table_and_bulk_start()
 {
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   TABLE *table = spider->get_table();
   DBUG_ENTER("spider_oracle_handler::mk_bulk_tmp_table_and_bulk_start");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -10454,7 +10459,8 @@ void spider_oracle_handler::rm_bulk_tmp_table()
   DBUG_PRINT("info",("spider this=%p", this));
   if (upd_tmp_tbl)
   {
-    spider_rm_sys_tmp_table(spider->trx->thd, upd_tmp_tbl, &upd_tmp_tbl_prm);
+    spider_rm_sys_tmp_table(spider->wide_handler->trx->thd, upd_tmp_tbl,
+      &upd_tmp_tbl_prm);
     upd_tmp_tbl = NULL;
   }
   DBUG_VOID_RETURN;
@@ -10551,7 +10557,8 @@ int spider_oracle_handler::append_lock_tables_list(
       DBUG_RETURN(error_num);
     *appended = 1;
   } else {
-    if (tmp_link_for_hash->spider->lock_type < spider->lock_type)
+    if (tmp_link_for_hash->spider->wide_handler->lock_type <
+      spider->wide_handler->lock_type)
     {
 #ifdef HASH_UPDATE_WITH_HASH_VALUE
       my_hash_delete_with_hash_value(
@@ -10591,7 +10598,7 @@ int spider_oracle_handler::append_lock_tables_list(
 int spider_oracle_handler::realloc_sql(
   ulong *realloced
 ) {
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   st_spider_share *share = spider->share;
   int init_sql_alloc_size =
     spider_param_init_sql_alloc_size(thd, share->init_sql_alloc_size);
@@ -11130,7 +11137,8 @@ int spider_oracle_handler::show_table_status(
     conn->need_mon = &spider->need_mons[link_idx];
     conn->mta_conn_mutex_lock_already = TRUE;
     conn->mta_conn_mutex_unlock_later = TRUE;
-    spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+    spider_conn_set_timeout_from_share(conn, link_idx,
+      spider->wide_handler->trx->thd,
       share);
     if (
       (error_num = spider_db_set_names(spider, conn, link_idx)) ||
@@ -11167,7 +11175,8 @@ int spider_oracle_handler::show_table_status(
           pthread_mutex_unlock(&conn->mta_conn_mutex);
           DBUG_RETURN(error_num);
         }
-        spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+        spider_conn_set_timeout_from_share(conn, link_idx,
+          spider->wide_handler->trx->thd,
           share);
         if (spider_db_query(
           conn,
@@ -11189,8 +11198,8 @@ int spider_oracle_handler::show_table_status(
       }
     }
     st_spider_db_request_key request_key;
-    request_key.spider_thread_id = spider->trx->spider_thread_id;
-    request_key.query_id = spider->trx->thd->query_id;
+    request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+    request_key.query_id = spider->wide_handler->trx->thd->query_id;
     request_key.handler = spider;
     request_key.request_id = 1;
     request_key.next = NULL;
@@ -11245,7 +11254,8 @@ int spider_oracle_handler::show_table_status(
     conn->need_mon = &spider->need_mons[link_idx];
     conn->mta_conn_mutex_lock_already = TRUE;
     conn->mta_conn_mutex_unlock_later = TRUE;
-    spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+    spider_conn_set_timeout_from_share(conn, link_idx,
+      spider->wide_handler->trx->thd,
       share);
     if (
       (error_num = spider_db_set_names(spider, conn, link_idx)) ||
@@ -11280,7 +11290,8 @@ int spider_oracle_handler::show_table_status(
           pthread_mutex_unlock(&conn->mta_conn_mutex);
           DBUG_RETURN(error_num);
         }
-        spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+        spider_conn_set_timeout_from_share(conn, link_idx,
+          spider->wide_handler->trx->thd,
           share);
         if (spider_db_query(
           conn,
@@ -11302,8 +11313,8 @@ int spider_oracle_handler::show_table_status(
       }
     }
     st_spider_db_request_key request_key;
-    request_key.spider_thread_id = spider->trx->spider_thread_id;
-    request_key.query_id = spider->trx->thd->query_id;
+    request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+    request_key.query_id = spider->wide_handler->trx->thd->query_id;
     request_key.handler = spider;
     request_key.request_id = 1;
     request_key.next = NULL;
@@ -11369,7 +11380,8 @@ int spider_oracle_handler::show_index(
     conn->need_mon = &spider->need_mons[link_idx];
     conn->mta_conn_mutex_lock_already = TRUE;
     conn->mta_conn_mutex_unlock_later = TRUE;
-    spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+    spider_conn_set_timeout_from_share(conn, link_idx,
+      spider->wide_handler->trx->thd,
       share);
     if (
       (error_num = spider_db_set_names(spider, conn, link_idx)) ||
@@ -11406,7 +11418,8 @@ int spider_oracle_handler::show_index(
           pthread_mutex_unlock(&conn->mta_conn_mutex);
           DBUG_RETURN(error_num);
         }
-        spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+        spider_conn_set_timeout_from_share(conn, link_idx,
+          spider->wide_handler->trx->thd,
           share);
         if (spider_db_query(
           conn,
@@ -11428,8 +11441,8 @@ int spider_oracle_handler::show_index(
       }
     }
     st_spider_db_request_key request_key;
-    request_key.spider_thread_id = spider->trx->spider_thread_id;
-    request_key.query_id = spider->trx->thd->query_id;
+    request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+    request_key.query_id = spider->wide_handler->trx->thd->query_id;
     request_key.handler = spider;
     request_key.request_id = 1;
     request_key.next = NULL;
@@ -11488,7 +11501,8 @@ int spider_oracle_handler::show_index(
     conn->need_mon = &spider->need_mons[link_idx];
     conn->mta_conn_mutex_lock_already = TRUE;
     conn->mta_conn_mutex_unlock_later = TRUE;
-    spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+    spider_conn_set_timeout_from_share(conn, link_idx,
+      spider->wide_handler->trx->thd,
       share);
     if (
       (error_num = spider_db_set_names(spider, conn, link_idx)) ||
@@ -11523,7 +11537,8 @@ int spider_oracle_handler::show_index(
           pthread_mutex_unlock(&conn->mta_conn_mutex);
           DBUG_RETURN(error_num);
         }
-        spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+        spider_conn_set_timeout_from_share(conn, link_idx,
+          spider->wide_handler->trx->thd,
           share);
         if (spider_db_query(
           conn,
@@ -11545,8 +11560,8 @@ int spider_oracle_handler::show_index(
       }
     }
     st_spider_db_request_key request_key;
-    request_key.spider_thread_id = spider->trx->spider_thread_id;
-    request_key.query_id = spider->trx->thd->query_id;
+    request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+    request_key.query_id = spider->wide_handler->trx->thd->query_id;
     request_key.handler = spider;
     request_key.request_id = 1;
     request_key.next = NULL;
@@ -11612,7 +11627,8 @@ int spider_oracle_handler::show_records(
   conn->need_mon = &spider->need_mons[link_idx];
   conn->mta_conn_mutex_lock_already = TRUE;
   conn->mta_conn_mutex_unlock_later = TRUE;
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (
     (error_num = spider_db_set_names(spider, conn, link_idx)) ||
@@ -11649,7 +11665,8 @@ int spider_oracle_handler::show_records(
         DBUG_PRINT("info", ("spider error_num=%d 2", error_num));
         DBUG_RETURN(error_num);
       }
-      spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, link_idx,
+        spider->wide_handler->trx->thd,
         share);
       if (spider_db_query(
         conn,
@@ -11673,8 +11690,8 @@ int spider_oracle_handler::show_records(
     }
   }
   st_spider_db_request_key request_key;
-  request_key.spider_thread_id = spider->trx->spider_thread_id;
-  request_key.query_id = spider->trx->thd->query_id;
+  request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+  request_key.query_id = spider->wide_handler->trx->thd->query_id;
   request_key.handler = spider;
   request_key.request_id = 1;
   request_key.next = NULL;
@@ -11707,7 +11724,7 @@ int spider_oracle_handler::show_records(
     DBUG_PRINT("info", ("spider error_num=%d 7", error_num));
     DBUG_RETURN(error_num);
   }
-  spider->trx->direct_aggregate_count++;
+  spider->wide_handler->trx->direct_aggregate_count++;
   DBUG_RETURN(0);
 }
 
@@ -11729,7 +11746,8 @@ int spider_oracle_handler::show_autoinc(
   conn->need_mon = &spider->need_mons[link_idx];
   conn->mta_conn_mutex_lock_already = TRUE;
   conn->mta_conn_mutex_unlock_later = TRUE;
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (
     (error_num = spider_db_set_names(spider, conn, link_idx)) ||
@@ -11766,7 +11784,8 @@ int spider_oracle_handler::show_autoinc(
         DBUG_PRINT("info", ("spider error_num=%d 2", error_num));
         DBUG_RETURN(error_num);
       }
-      spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, link_idx,
+        spider->wide_handler->trx->thd,
         share);
       if (spider_db_query(
         conn,
@@ -11790,8 +11809,8 @@ int spider_oracle_handler::show_autoinc(
     }
   }
   st_spider_db_request_key request_key;
-  request_key.spider_thread_id = spider->trx->spider_thread_id;
-  request_key.query_id = spider->trx->thd->query_id;
+  request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+  request_key.query_id = spider->wide_handler->trx->thd->query_id;
   request_key.handler = spider;
   request_key.request_id = 1;
   request_key.next = NULL;
@@ -11866,8 +11885,8 @@ int spider_oracle_handler::show_last_insert_id(
     DBUG_RETURN(error_num);
   }
   st_spider_db_request_key request_key;
-  request_key.spider_thread_id = spider->trx->spider_thread_id;
-  request_key.query_id = spider->trx->thd->query_id;
+  request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+  request_key.query_id = spider->wide_handler->trx->thd->query_id;
   request_key.handler = spider;
   request_key.request_id = 1;
   request_key.next = NULL;
@@ -11923,7 +11942,8 @@ ha_rows spider_oracle_handler::explain_select(
   conn->need_mon = &spider->need_mons[link_idx];
   conn->mta_conn_mutex_lock_already = TRUE;
   conn->mta_conn_mutex_unlock_later = TRUE;
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     spider->share);
   if (
     (error_num = spider_db_set_names(spider, conn, link_idx)) ||
@@ -11962,7 +11982,8 @@ ha_rows spider_oracle_handler::explain_select(
         pthread_mutex_unlock(&conn->mta_conn_mutex);
         DBUG_RETURN(HA_POS_ERROR);
       }
-      spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, link_idx,
+        spider->wide_handler->trx->thd,
         spider->share);
       if (spider_db_query(
         conn,
@@ -11991,8 +12012,8 @@ ha_rows spider_oracle_handler::explain_select(
     }
   }
   st_spider_db_request_key request_key;
-  request_key.spider_thread_id = spider->trx->spider_thread_id;
-  request_key.query_id = spider->trx->thd->query_id;
+  request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
+  request_key.query_id = spider->wide_handler->trx->thd->query_id;
   request_key.handler = spider;
   request_key.request_id = 1;
   request_key.next = NULL;
@@ -12062,7 +12083,8 @@ int spider_oracle_handler::lock_tables(
         pthread_mutex_unlock(&conn->mta_conn_mutex);
         DBUG_RETURN(error_num);
       }
-      spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+      spider_conn_set_timeout_from_share(conn, link_idx,
+        spider->wide_handler->trx->thd,
         spider->share);
       if (spider_db_query(
         conn,
@@ -12083,7 +12105,7 @@ int spider_oracle_handler::lock_tables(
     if (!conn->table_locked)
     {
       conn->table_locked = TRUE;
-      spider->trx->locked_connections++;
+      spider->wide_handler->trx->locked_connections++;
     }
   } while (str->length());
   DBUG_RETURN(0);
@@ -12133,7 +12155,8 @@ int spider_oracle_handler::disable_keys(
     pthread_mutex_unlock(&conn->mta_conn_mutex);
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -12182,7 +12205,8 @@ int spider_oracle_handler::enable_keys(
     pthread_mutex_unlock(&conn->mta_conn_mutex);
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -12232,7 +12256,8 @@ int spider_oracle_handler::check_table(
     pthread_mutex_unlock(&conn->mta_conn_mutex);
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -12282,7 +12307,8 @@ int spider_oracle_handler::repair_table(
     pthread_mutex_unlock(&conn->mta_conn_mutex);
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -12331,7 +12357,8 @@ int spider_oracle_handler::analyze_table(
     pthread_mutex_unlock(&conn->mta_conn_mutex);
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -12380,7 +12407,8 @@ int spider_oracle_handler::optimize_table(
     pthread_mutex_unlock(&conn->mta_conn_mutex);
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -12417,7 +12445,8 @@ int spider_oracle_handler::flush_tables(
   {
     DBUG_RETURN(error_num);
   }
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
@@ -12442,7 +12471,8 @@ int spider_oracle_handler::flush_logs(
   SPIDER_SHARE *share = spider->share;
   DBUG_ENTER("spider_oracle_handler::flush_logs");
   DBUG_PRINT("info",("spider this=%p", this));
-  spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
+  spider_conn_set_timeout_from_share(conn, link_idx,
+    spider->wide_handler->trx->thd,
     share);
   if (spider_db_query(
     conn,
diff --git a/storage/spider/spd_group_by_handler.cc b/storage/spider/spd_group_by_handler.cc
index 63f7cc0fdc3..d4ff18d129f 100644
--- a/storage/spider/spd_group_by_handler.cc
+++ b/storage/spider/spd_group_by_handler.cc
@@ -795,7 +795,7 @@ void spider_fields::choose_a_conn(
   SPIDER_CONN_HOLDER *conn_holder;
   longlong balance_total = 0, balance_val;
   double rand_val;
-  THD *thd = table_holder[0].spider->trx->thd;
+  THD *thd = table_holder[0].spider->wide_handler->trx->thd;
   DBUG_ENTER("spider_fields::choose_a_conn");
   DBUG_PRINT("info",("spider this=%p", this));
   for (current_conn_holder = first_conn_holder; current_conn_holder;
@@ -1147,8 +1147,8 @@ int spider_fields::ping_table_mon_from_table(
     if (tmp_share->monitoring_kind[tmp_link_idx])
     {
       error_num_buf = spider_ping_table_mon_from_table(
-          tmp_spider->trx,
-          tmp_spider->trx->thd,
+          tmp_spider->wide_handler->trx,
+          tmp_spider->wide_handler->trx->thd,
           tmp_share,
           tmp_link_idx,
           (uint32) tmp_share->monitoring_sid[tmp_link_idx],
@@ -1181,7 +1181,7 @@ spider_group_by_handler::spider_group_by_handler(
   fields->set_pos_to_first_table_holder();
   SPIDER_TABLE_HOLDER *table_holder = fields->get_next_table_holder();
   spider = table_holder->spider;
-  trx = spider->trx;
+  trx = spider->wide_handler->trx;
   DBUG_VOID_RETURN;
 }
 
@@ -1924,6 +1924,12 @@ group_by_handler *spider_create_group_by_handler(
     delete fields;
     DBUG_RETURN(NULL);
   }
+  if (spider->dml_init())
+  {
+    DBUG_PRINT("info",("spider can not init for dml"));
+    delete fields;
+    DBUG_RETURN(NULL);
+  }
   for (
     roop_count = spider_conn_link_idx_next(share->link_statuses,
       spider->conn_link_idx, -1, share->link_count,
@@ -2006,6 +2012,12 @@ group_by_handler *spider_create_group_by_handler(
     }
     DBUG_PRINT("info",("spider s->db=%s", from->table->s->db.str));
     DBUG_PRINT("info",("spider s->table_name=%s", from->table->s->table_name.str));
+    if (spider->dml_init())
+    {
+      DBUG_PRINT("info",("spider can not init for dml"));
+      delete fields;
+      DBUG_RETURN(NULL);
+    }
     for (
       roop_count = spider_conn_link_idx_next(share->link_statuses,
         spider->conn_link_idx, -1, share->link_count,
diff --git a/storage/spider/spd_include.h b/storage/spider/spd_include.h
index 2249d3e699c..bca4e4014ef 100644
--- a/storage/spider/spd_include.h
+++ b/storage/spider/spd_include.h
@@ -621,26 +621,19 @@ typedef struct st_spider_lgtm_tblhnd_share
 #ifdef WITH_PARTITION_STORAGE_ENGINE
 typedef struct st_spider_patition_handler_share
 {
-  uint               use_count;
-  TABLE              *table;
+  bool               clone_bitmap_init;
 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
   my_hash_value_type table_hash_value;
 #endif
-  void               *creator;
-  void               **handlers;
-  uchar              *searched_bitmap;
-  uchar              *ft_discard_bitmap;
-  uchar              *idx_read_bitmap;
-  uchar              *idx_write_bitmap;
-  uchar              *rnd_read_bitmap;
-  uchar              *rnd_write_bitmap;
-  bool               between_flg;
-  bool               idx_bitmap_is_set;
-  bool               rnd_bitmap_is_set;
   query_id_t         parallel_search_query_id;
+  uint               no_parts;
+  TABLE              *table;
+  ha_spider          *owner;
+  ha_spider          **handlers;
 } SPIDER_PARTITION_HANDLER_SHARE;
+#endif
 
-typedef struct st_spider_patition_share
+typedef struct st_spider_wide_share
 {
   char               *table_name;
   uint               table_name_length;
@@ -648,6 +641,7 @@ typedef struct st_spider_patition_share
   my_hash_value_type table_path_hash_value;
 #endif
   uint               use_count;
+  THR_LOCK           lock;
   pthread_mutex_t    sts_mutex;
   pthread_mutex_t    crd_mutex;
   pthread_mutex_t    pt_handler_mutex;
@@ -664,11 +658,103 @@ typedef struct st_spider_patition_share
   ha_statistics      stat;
 
   longlong           *cardinality;
-/*
-  volatile SPIDER_PARTITION_HANDLER_SHARE *partition_handler_share;
-*/
-} SPIDER_PARTITION_SHARE;
+} SPIDER_WIDE_SHARE;
+
+enum spider_hnd_stage {
+  SPD_HND_STAGE_NONE,
+  SPD_HND_STAGE_STORE_LOCK,
+  SPD_HND_STAGE_EXTERNAL_LOCK,
+  SPD_HND_STAGE_START_STMT,
+  SPD_HND_STAGE_EXTRA,
+  SPD_HND_STAGE_COND_PUSH,
+  SPD_HND_STAGE_COND_POP,
+  SPD_HND_STAGE_INFO_PUSH,
+  SPD_HND_STAGE_SET_TOP_TABLE_AND_FIELDS,
+  SPD_HND_STAGE_CLEAR_TOP_TABLE_FIELDS
+};
+
+typedef struct st_spider_wide_handler
+{
+  spider_hnd_stage   stage;
+  handler            *stage_executor;
+  THR_LOCK_DATA      lock;
+  SPIDER_TRX         *trx;
+  uchar              *searched_bitmap;
+  uchar              *ft_discard_bitmap;
+  uchar              *position_bitmap;
+  uchar              *idx_read_bitmap;
+  uchar              *idx_write_bitmap;
+  uchar              *rnd_read_bitmap;
+  uchar              *rnd_write_bitmap;
+  SPIDER_CONDITION   *condition;
+  void               *owner;
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
+  uint32             *hs_pushed_ret_fields;
 #endif
+#endif
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  SPIDER_PARTITION_HANDLER_SHARE *partition_handler_share;
+#endif
+#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
+  List<Item>         *direct_update_fields;
+  List<Item>         *direct_update_values;
+#endif
+  TABLE              *top_table;
+  Field              **top_table_field;
+  enum thr_lock_type lock_type;
+  uchar              lock_table_type;
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
+  uint32             hs_pushed_strref_num;
+#endif
+#endif
+  int                lock_mode;
+  int                external_lock_type;
+  int                cond_check_error;
+  uint               sql_command;
+  uint               top_table_fields;
+#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
+#ifdef INFO_KIND_FORCE_LIMIT_BEGIN
+  longlong           info_limit;
+#endif
+#endif
+#ifdef HA_CAN_BULK_ACCESS
+  ulonglong          external_lock_cnt;
+#endif
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
+  size_t             hs_pushed_ret_fields_num;
+  size_t             hs_pushed_ret_fields_size;
+  size_t             hs_pushed_lcl_fields_num;
+#endif
+#endif
+  bool               between_flg;
+  bool               idx_bitmap_is_set;
+  bool               rnd_bitmap_is_set;
+  bool               position_bitmap_init;
+  bool               semi_trx_isolation_chk;
+  bool               semi_trx_chk;
+  bool               low_priority;
+  bool               high_priority;
+  bool               insert_delayed;
+  bool               consistent_snapshot;
+  bool               quick_mode;
+  bool               keyread;
+  bool               update_request;
+  bool               ignore_dup_key;
+  bool               write_can_replace;
+  bool               insert_with_update;
+  bool               cond_check;
+  bool               set_top_table_fields;
+#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
+#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
+  bool               hs_increment;
+  bool               hs_decrement;
+#endif
+#endif
+  bool               semi_table_lock;
+} SPIDER_WIDE_HANDLER;
 
 typedef struct st_spider_transaction
 {
@@ -805,7 +891,6 @@ typedef struct st_spider_share
 /*
   pthread_mutex_t    auto_increment_mutex;
 */
-  THR_LOCK           lock;
   TABLE_SHARE        *table_share;
   SPIDER_LGTM_TBLHND_SHARE *lgtm_tblhnd_share;
 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
@@ -1177,9 +1262,7 @@ typedef struct st_spider_share
 #endif
 
   SPIDER_ALTER_TABLE alter_table;
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-  SPIDER_PARTITION_SHARE *partition_share;
-#endif
+  SPIDER_WIDE_SHARE  *wide_share;
 } SPIDER_SHARE;
 
 typedef struct st_spider_link_pack
diff --git a/storage/spider/spd_table.cc b/storage/spider/spd_table.cc
index 98650d10525..ab2375e4770 100644
--- a/storage/spider/spd_table.cc
+++ b/storage/spider/spd_table.cc
@@ -152,7 +152,7 @@ SPIDER_THREAD *spider_table_crd_threads;
 PSI_mutex_key spd_key_mutex_tbl;
 PSI_mutex_key spd_key_mutex_init_error_tbl;
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-PSI_mutex_key spd_key_mutex_pt_share;
+PSI_mutex_key spd_key_mutex_wide_share;
 #endif
 PSI_mutex_key spd_key_mutex_lgtm_tblhnd_share;
 PSI_mutex_key spd_key_mutex_conn;
@@ -182,8 +182,8 @@ PSI_mutex_key spd_key_mutex_share_sts;
 PSI_mutex_key spd_key_mutex_share_crd;
 PSI_mutex_key spd_key_mutex_share_auto_increment;
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-PSI_mutex_key spd_key_mutex_pt_share_sts;
-PSI_mutex_key spd_key_mutex_pt_share_crd;
+PSI_mutex_key spd_key_mutex_wide_share_sts;
+PSI_mutex_key spd_key_mutex_wide_share_crd;
 PSI_mutex_key spd_key_mutex_pt_handler;
 #endif
 PSI_mutex_key spd_key_mutex_udf_table;
@@ -202,7 +202,7 @@ static PSI_mutex_info all_spider_mutexes[]=
   { &spd_key_mutex_tbl, "tbl", PSI_FLAG_GLOBAL},
   { &spd_key_mutex_init_error_tbl, "init_error_tbl", PSI_FLAG_GLOBAL},
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-  { &spd_key_mutex_pt_share, "pt_share", PSI_FLAG_GLOBAL},
+  { &spd_key_mutex_wide_share, "wide_share", PSI_FLAG_GLOBAL},
 #endif
   { &spd_key_mutex_lgtm_tblhnd_share, "lgtm_tblhnd_share", PSI_FLAG_GLOBAL},
   { &spd_key_mutex_conn, "conn", PSI_FLAG_GLOBAL},
@@ -241,8 +241,8 @@ static PSI_mutex_info all_spider_mutexes[]=
   { &spd_key_mutex_share_crd, "share_crd", 0},
   { &spd_key_mutex_share_auto_increment, "share_auto_increment", 0},
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-  { &spd_key_mutex_pt_share_sts, "pt_share_sts", 0},
-  { &spd_key_mutex_pt_share_crd, "pt_share_crd", 0},
+  { &spd_key_mutex_wide_share_sts, "wide_share_sts", 0},
+  { &spd_key_mutex_wide_share_crd, "wide_share_crd", 0},
   { &spd_key_mutex_pt_handler, "pt_handler", 0},
 #endif
   { &spd_key_mutex_udf_table, "udf_table", 0},
@@ -365,12 +365,12 @@ extern pthread_mutex_t spider_conn_id_mutex;
 extern pthread_mutex_t spider_ipport_conn_mutex;
 
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-HASH spider_open_pt_share;
-uint spider_open_pt_share_id;
-const char *spider_open_pt_share_func_name;
-const char *spider_open_pt_share_file_name;
-ulong spider_open_pt_share_line_no;
-pthread_mutex_t spider_pt_share_mutex;
+HASH spider_open_wide_share;
+uint spider_open_wide_share_id;
+const char *spider_open_wide_share_func_name;
+const char *spider_open_wide_share_file_name;
+ulong spider_open_wide_share_line_no;
+pthread_mutex_t spider_wide_share_mutex;
 #endif
 
 HASH spider_lgtm_tblhnd_share_hash;
@@ -415,25 +415,25 @@ uchar *spider_tbl_get_key(
   DBUG_RETURN((uchar*) share->table_name);
 }
 
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-uchar *spider_pt_share_get_key(
-  SPIDER_PARTITION_SHARE *share,
+uchar *spider_wide_share_get_key(
+  SPIDER_WIDE_SHARE *share,
   size_t *length,
   my_bool not_used __attribute__ ((unused))
 ) {
-  DBUG_ENTER("spider_pt_share_get_key");
+  DBUG_ENTER("spider_wide_share_get_key");
   *length = share->table_name_length;
   DBUG_RETURN((uchar*) share->table_name);
 }
 
+#ifdef WITH_PARTITION_STORAGE_ENGINE
 uchar *spider_pt_handler_share_get_key(
   SPIDER_PARTITION_HANDLER_SHARE *share,
   size_t *length,
   my_bool not_used __attribute__ ((unused))
 ) {
   DBUG_ENTER("spider_pt_handler_share_get_key");
-  *length = sizeof(TABLE *);
-  DBUG_RETURN((uchar*) &share->table);
+  *length = sizeof(ha_spider *);
+  DBUG_RETURN((uchar*) share->owner);
 }
 #endif
 
@@ -913,10 +913,8 @@ int spider_free_share_alloc(
     delete [] share->key_hint;
     share->key_hint = NULL;
   }
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-  if (share->partition_share)
-    spider_free_pt_share(share->partition_share);
-#endif
+  if (share->wide_share)
+    spider_free_wide_share(share->wide_share);
   DBUG_RETURN(0);
 }
 
@@ -4517,8 +4515,6 @@ SPIDER_SHARE *spider_create_share(
     goto error_init_crd_mutex;
   }
 
-  thr_lock_init(&share->lock);
-
 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
   if (!(share->lgtm_tblhnd_share =
     spider_get_lgtm_tblhnd_share(tmp_name, length, hash_value, FALSE, TRUE,
@@ -4531,11 +4527,9 @@ SPIDER_SHARE *spider_create_share(
     goto error_get_lgtm_tblhnd_share;
   }
 
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-  if (!(share->partition_share =
-    spider_get_pt_share(share, table_share, error_num)))
-    goto error_get_pt_share;
-#endif
+  if (!(share->wide_share =
+    spider_get_wide_share(share, table_share, error_num)))
+    goto error_get_wide_share;
 
   for (roop_count = 0; roop_count < SPIDER_DBTON_SIZE; roop_count++)
   {
@@ -4583,12 +4577,9 @@ error_init_dbton:
       share->dbton_share[roop_count] = NULL;
     }
   }
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-  spider_free_pt_share(share->partition_share);
-error_get_pt_share:
-#endif
+  spider_free_wide_share(share->wide_share);
+error_get_wide_share:
 error_get_lgtm_tblhnd_share:
-  thr_lock_delete(&share->lock);
   pthread_mutex_destroy(&share->crd_mutex);
 error_init_crd_mutex:
   pthread_mutex_destroy(&share->sts_mutex);
@@ -4810,7 +4801,7 @@ SPIDER_SHARE *spider_get_share(
     else
       first_byte = '0';
 
-    if (!(spider->trx = spider_get_trx(thd, TRUE, error_num)))
+    if (!(spider->wide_handler->trx = spider_get_trx(thd, TRUE, error_num)))
     {
       share->init_error = TRUE;
       share->init_error_time = (time_t) time((time_t*) 0);
@@ -4827,7 +4818,7 @@ SPIDER_SHARE *spider_get_share(
       if (!share->sts_spider_init)
       {
         if ((*error_num = spider_create_spider_object_for_share(
-          spider->trx, share, &share->sts_spider)))
+          spider->wide_handler->trx, share, &share->sts_spider)))
         {
           pthread_mutex_unlock(&share->mutex);
           share->init_error = TRUE;
@@ -4855,7 +4846,7 @@ SPIDER_SHARE *spider_get_share(
       if (!share->crd_spider_init)
       {
         if ((*error_num = spider_create_spider_object_for_share(
-          spider->trx, share, &share->crd_spider)))
+          spider->wide_handler->trx, share, &share->crd_spider)))
         {
           pthread_mutex_unlock(&share->mutex);
           share->init_error = TRUE;
@@ -4883,7 +4874,8 @@ SPIDER_SHARE *spider_get_share(
       sql_command != SQLCOM_DROP_TABLE &&
       sql_command != SQLCOM_ALTER_TABLE &&
       sql_command != SQLCOM_SHOW_CREATE &&
-      (*error_num = spider_create_mon_threads(spider->trx, share))
+      (*error_num = spider_create_mon_threads(spider->wide_handler->trx,
+        share))
     ) {
       share->init_error = TRUE;
       share->init_error_time = (time_t) time((time_t*) 0);
@@ -5054,7 +5046,8 @@ SPIDER_SHARE *spider_get_share(
         if (
           !(spider->conns[roop_count] =
             spider_get_conn(share, roop_count, spider->conn_keys[roop_count],
-              spider->trx, spider, FALSE, TRUE, SPIDER_CONN_KIND_MYSQL,
+              spider->wide_handler->trx, spider, FALSE, TRUE,
+              SPIDER_CONN_KIND_MYSQL,
               error_num))
         ) {
           if (
@@ -5062,8 +5055,8 @@ SPIDER_SHARE *spider_get_share(
             spider->need_mons[roop_count]
           ) {
             *error_num = spider_ping_table_mon_from_table(
-                spider->trx,
-                spider->trx->thd,
+                spider->wide_handler->trx,
+                spider->wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -5162,7 +5155,7 @@ SPIDER_SHARE *spider_get_share(
       pthread_mutex_lock(&share->sts_mutex);
       pthread_mutex_lock(&share->crd_mutex);
       if ((spider_init_error_table =
-        spider_get_init_error_table(spider->trx, share, FALSE)))
+        spider_get_init_error_table(spider->wide_handler->trx, share, FALSE)))
       {
         DBUG_PRINT("info",("spider diff1=%f",
           difftime(tmp_time, spider_init_error_table->init_error_time)));
@@ -5361,7 +5354,7 @@ SPIDER_SHARE *spider_get_share(
       first_byte = '0';
 
     spider->share = share;
-    if (!(spider->trx = spider_get_trx(thd, TRUE, error_num)))
+    if (!(spider->wide_handler->trx = spider_get_trx(thd, TRUE, error_num)))
     {
       spider_free_share(share);
       goto error_but_no_delete;
@@ -5375,7 +5368,7 @@ SPIDER_SHARE *spider_get_share(
       if (!share->sts_spider_init)
       {
         if ((*error_num = spider_create_spider_object_for_share(
-          spider->trx, share, &share->sts_spider)))
+          spider->wide_handler->trx, share, &share->sts_spider)))
         {
           pthread_mutex_unlock(&share->mutex);
           spider_free_share(share);
@@ -5400,7 +5393,7 @@ SPIDER_SHARE *spider_get_share(
       if (!share->crd_spider_init)
       {
         if ((*error_num = spider_create_spider_object_for_share(
-          spider->trx, share, &share->crd_spider)))
+          spider->wide_handler->trx, share, &share->crd_spider)))
         {
           pthread_mutex_unlock(&share->mutex);
           spider_free_share(share);
@@ -5425,7 +5418,8 @@ SPIDER_SHARE *spider_get_share(
       sql_command != SQLCOM_DROP_TABLE &&
       sql_command != SQLCOM_ALTER_TABLE &&
       sql_command != SQLCOM_SHOW_CREATE &&
-      (*error_num = spider_create_mon_threads(spider->trx, share))
+      (*error_num = spider_create_mon_threads(spider->wide_handler->trx,
+        share))
     ) {
       spider_free_share(share);
       goto error_but_no_delete;
@@ -5587,7 +5581,8 @@ SPIDER_SHARE *spider_get_share(
         if (
           !(spider->conns[roop_count] =
             spider_get_conn(share, roop_count, spider->conn_keys[roop_count],
-              spider->trx, spider, FALSE, TRUE, SPIDER_CONN_KIND_MYSQL,
+              spider->wide_handler->trx, spider, FALSE, TRUE,
+              SPIDER_CONN_KIND_MYSQL,
               error_num))
         ) {
           if (
@@ -5595,8 +5590,8 @@ SPIDER_SHARE *spider_get_share(
             spider->need_mons[roop_count]
           ) {
             *error_num = spider_ping_table_mon_from_table(
-                spider->trx,
-                spider->trx->thd,
+                spider->wide_handler->trx,
+                spider->wide_handler->trx->thd,
                 share,
                 roop_count,
                 (uint32) share->monitoring_sid[roop_count],
@@ -5687,7 +5682,8 @@ SPIDER_SHARE *spider_get_share(
 #endif
           time_t tmp_time = (time_t) time((time_t*) 0);
           if ((spider_init_error_table =
-            spider_get_init_error_table(spider->trx, share, FALSE)))
+            spider_get_init_error_table(spider->wide_handler->trx, share,
+              FALSE)))
           {
             DBUG_PRINT("info",("spider diff2=%f",
               difftime(tmp_time, spider_init_error_table->init_error_time)));
@@ -5797,7 +5793,6 @@ void spider_free_share_resource_only(
 ) {
   DBUG_ENTER("spider_free_share_resource_only");
   spider_free_share_alloc(share);
-  thr_lock_delete(&share->lock);
   pthread_mutex_destroy(&share->crd_mutex);
   pthread_mutex_destroy(&share->sts_mutex);
   pthread_mutex_destroy(&share->mutex);
@@ -5877,7 +5872,6 @@ int spider_free_share(
 #else
     my_hash_delete(&spider_open_tables, (uchar*) share);
 #endif
-    thr_lock_delete(&share->lock);
     pthread_mutex_destroy(&share->crd_mutex);
     pthread_mutex_destroy(&share->sts_mutex);
     pthread_mutex_destroy(&share->mutex);
@@ -6049,33 +6043,32 @@ void spider_free_lgtm_tblhnd_share_alloc(
   DBUG_VOID_RETURN;
 }
 
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-SPIDER_PARTITION_SHARE *spider_get_pt_share(
+SPIDER_WIDE_SHARE *spider_get_wide_share(
   SPIDER_SHARE *share,
   TABLE_SHARE *table_share,
   int *error_num
 ) {
-  SPIDER_PARTITION_SHARE *partition_share;
+  SPIDER_WIDE_SHARE *wide_share;
   char *tmp_name;
   longlong *tmp_cardinality;
-  DBUG_ENTER("spider_get_pt_share");
+  DBUG_ENTER("spider_get_wide_share");
 
-  pthread_mutex_lock(&spider_pt_share_mutex);
+  pthread_mutex_lock(&spider_wide_share_mutex);
 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
-  if (!(partition_share = (SPIDER_PARTITION_SHARE*)
+  if (!(wide_share = (SPIDER_WIDE_SHARE*)
     my_hash_search_using_hash_value(
-    &spider_open_pt_share, share->table_path_hash_value,
+    &spider_open_wide_share, share->table_path_hash_value,
     (uchar*) table_share->path.str, table_share->path.length)))
 #else
-  if (!(partition_share = (SPIDER_PARTITION_SHARE*) my_hash_search(
-    &spider_open_pt_share,
+  if (!(wide_share = (SPIDER_WIDE_SHARE*) my_hash_search(
+    &spider_open_wide_share,
     (uchar*) table_share->path.str, table_share->path.length)))
 #endif
   {
-    DBUG_PRINT("info",("spider create new pt share"));
-    if (!(partition_share = (SPIDER_PARTITION_SHARE *)
+    DBUG_PRINT("info",("spider create new wide share"));
+    if (!(wide_share = (SPIDER_WIDE_SHARE *)
       spider_bulk_malloc(spider_current_trx, 51, MYF(MY_WME | MY_ZEROFILL),
-        &partition_share, (uint) (sizeof(*partition_share)),
+        &wide_share, sizeof(SPIDER_WIDE_SHARE),
         &tmp_name, (uint) (table_share->path.length + 1),
         &tmp_cardinality,
           (uint) (sizeof(*tmp_cardinality) * table_share->fields),
@@ -6085,24 +6078,24 @@ SPIDER_PARTITION_SHARE *spider_get_pt_share(
       goto error_alloc_share;
     }
 
-    partition_share->use_count = 0;
-    partition_share->table_name_length = table_share->path.length;
-    partition_share->table_name = tmp_name;
-    memcpy(partition_share->table_name, table_share->path.str,
-      partition_share->table_name_length);
+    wide_share->use_count = 0;
+    wide_share->table_name_length = table_share->path.length;
+    wide_share->table_name = tmp_name;
+    memcpy(wide_share->table_name, table_share->path.str,
+      wide_share->table_name_length);
 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
-    partition_share->table_path_hash_value = share->table_path_hash_value;
+    wide_share->table_path_hash_value = share->table_path_hash_value;
 #endif
-    partition_share->cardinality = tmp_cardinality;
+    wide_share->cardinality = tmp_cardinality;
 
-    partition_share->crd_get_time = partition_share->sts_get_time =
+    wide_share->crd_get_time = wide_share->sts_get_time =
       share->crd_get_time;
 
 #if MYSQL_VERSION_ID < 50500
-    if (pthread_mutex_init(&partition_share->sts_mutex, MY_MUTEX_INIT_FAST))
+    if (pthread_mutex_init(&wide_share->sts_mutex, MY_MUTEX_INIT_FAST))
 #else
-    if (mysql_mutex_init(spd_key_mutex_pt_share_sts,
-      &partition_share->sts_mutex, MY_MUTEX_INIT_FAST))
+    if (mysql_mutex_init(spd_key_mutex_wide_share_sts,
+      &wide_share->sts_mutex, MY_MUTEX_INIT_FAST))
 #endif
     {
       *error_num = HA_ERR_OUT_OF_MEM;
@@ -6110,10 +6103,10 @@ SPIDER_PARTITION_SHARE *spider_get_pt_share(
     }
 
 #if MYSQL_VERSION_ID < 50500
-    if (pthread_mutex_init(&partition_share->crd_mutex, MY_MUTEX_INIT_FAST))
+    if (pthread_mutex_init(&wide_share->crd_mutex, MY_MUTEX_INIT_FAST))
 #else
-    if (mysql_mutex_init(spd_key_mutex_pt_share_crd,
-      &partition_share->crd_mutex, MY_MUTEX_INIT_FAST))
+    if (mysql_mutex_init(spd_key_mutex_wide_share_crd,
+      &wide_share->crd_mutex, MY_MUTEX_INIT_FAST))
 #endif
     {
       *error_num = HA_ERR_OUT_OF_MEM;
@@ -6121,11 +6114,11 @@ SPIDER_PARTITION_SHARE *spider_get_pt_share(
     }
 
 #if MYSQL_VERSION_ID < 50500
-    if (pthread_mutex_init(&partition_share->pt_handler_mutex,
+    if (pthread_mutex_init(&wide_share->pt_handler_mutex,
       MY_MUTEX_INIT_FAST))
 #else
     if (mysql_mutex_init(spd_key_mutex_pt_handler,
-      &partition_share->pt_handler_mutex, MY_MUTEX_INIT_FAST))
+      &wide_share->pt_handler_mutex, MY_MUTEX_INIT_FAST))
 #endif
     {
       *error_num = HA_ERR_OUT_OF_MEM;
@@ -6133,130 +6126,133 @@ SPIDER_PARTITION_SHARE *spider_get_pt_share(
     }
 
     if(
-      my_hash_init(PSI_INSTRUMENT_ME, &partition_share->pt_handler_hash, spd_charset_utf8mb3_bin,
+      my_hash_init(PSI_INSTRUMENT_ME, &wide_share->pt_handler_hash, spd_charset_utf8mb3_bin,
         32, 0, 0, (my_hash_get_key) spider_pt_handler_share_get_key, 0, 0)
     ) {
       *error_num = HA_ERR_OUT_OF_MEM;
       goto error_init_pt_handler_hash;
     }
-    spider_alloc_calc_mem_init(partition_share->pt_handler_hash, 142);
+
+    thr_lock_init(&wide_share->lock);
+
+    spider_alloc_calc_mem_init(wide_share->pt_handler_hash, 142);
     spider_alloc_calc_mem(spider_current_trx,
-      partition_share->pt_handler_hash,
-      partition_share->pt_handler_hash.array.max_element *
-      partition_share->pt_handler_hash.array.size_of_element);
+      wide_share->pt_handler_hash,
+      wide_share->pt_handler_hash.array.max_element *
+      wide_share->pt_handler_hash.array.size_of_element);
 
-    uint old_elements = spider_open_pt_share.array.max_element;
+    uint old_elements = spider_open_wide_share.array.max_element;
 #ifdef HASH_UPDATE_WITH_HASH_VALUE
-    if (my_hash_insert_with_hash_value(&spider_open_pt_share,
+    if (my_hash_insert_with_hash_value(&spider_open_wide_share,
       share->table_path_hash_value,
-      (uchar*) partition_share))
+      (uchar*) wide_share))
 #else
-    if (my_hash_insert(&spider_open_pt_share, (uchar*) partition_share))
+    if (my_hash_insert(&spider_open_wide_share, (uchar*) wide_share))
 #endif
     {
       *error_num = HA_ERR_OUT_OF_MEM;
       goto error_hash_insert;
     }
-    if (spider_open_pt_share.array.max_element > old_elements)
+    if (spider_open_wide_share.array.max_element > old_elements)
     {
       spider_alloc_calc_mem(spider_current_trx,
-        spider_open_pt_share,
-        (spider_open_pt_share.array.max_element - old_elements) *
-        spider_open_pt_share.array.size_of_element);
+        spider_open_wide_share,
+        (spider_open_wide_share.array.max_element - old_elements) *
+        spider_open_wide_share.array.size_of_element);
     }
   }
-  partition_share->use_count++;
-  pthread_mutex_unlock(&spider_pt_share_mutex);
+  wide_share->use_count++;
+  pthread_mutex_unlock(&spider_wide_share_mutex);
 
-  DBUG_PRINT("info",("spider partition_share=%p", partition_share));
-  DBUG_RETURN(partition_share);
+  DBUG_PRINT("info",("spider wide_share=%p", wide_share));
+  DBUG_RETURN(wide_share);
 
 error_hash_insert:
   spider_free_mem_calc(spider_current_trx,
-    partition_share->pt_handler_hash_id,
-    partition_share->pt_handler_hash.array.max_element *
-    partition_share->pt_handler_hash.array.size_of_element);
-  my_hash_free(&partition_share->pt_handler_hash);
+    wide_share->pt_handler_hash_id,
+    wide_share->pt_handler_hash.array.max_element *
+    wide_share->pt_handler_hash.array.size_of_element);
+  my_hash_free(&wide_share->pt_handler_hash);
 error_init_pt_handler_hash:
-  pthread_mutex_destroy(&partition_share->pt_handler_mutex);
+  pthread_mutex_destroy(&wide_share->pt_handler_mutex);
 error_init_pt_handler_mutex:
-  pthread_mutex_destroy(&partition_share->crd_mutex);
+  pthread_mutex_destroy(&wide_share->crd_mutex);
 error_init_crd_mutex:
-  pthread_mutex_destroy(&partition_share->sts_mutex);
+  pthread_mutex_destroy(&wide_share->sts_mutex);
 error_init_sts_mutex:
-  spider_free(spider_current_trx, partition_share, MYF(0));
+  spider_free(spider_current_trx, wide_share, MYF(0));
 error_alloc_share:
-  pthread_mutex_unlock(&spider_pt_share_mutex);
+  pthread_mutex_unlock(&spider_wide_share_mutex);
   DBUG_RETURN(NULL);
 }
 
-int spider_free_pt_share(
-  SPIDER_PARTITION_SHARE *partition_share
+int spider_free_wide_share(
+  SPIDER_WIDE_SHARE *wide_share
 ) {
-  DBUG_ENTER("spider_free_pt_share");
-  pthread_mutex_lock(&spider_pt_share_mutex);
-  if (!--partition_share->use_count)
+  DBUG_ENTER("spider_free_wide_share");
+  pthread_mutex_lock(&spider_wide_share_mutex);
+  if (!--wide_share->use_count)
   {
+    thr_lock_delete(&wide_share->lock);
 #ifdef HASH_UPDATE_WITH_HASH_VALUE
-    my_hash_delete_with_hash_value(&spider_open_pt_share,
-      partition_share->table_path_hash_value, (uchar*) partition_share);
+    my_hash_delete_with_hash_value(&spider_open_wide_share,
+      wide_share->table_path_hash_value, (uchar*) wide_share);
 #else
-    my_hash_delete(&spider_open_pt_share, (uchar*) partition_share);
+    my_hash_delete(&spider_open_wide_share, (uchar*) wide_share);
 #endif
     spider_free_mem_calc(spider_current_trx,
-      partition_share->pt_handler_hash_id,
-      partition_share->pt_handler_hash.array.max_element *
-      partition_share->pt_handler_hash.array.size_of_element);
-    my_hash_free(&partition_share->pt_handler_hash);
-    pthread_mutex_destroy(&partition_share->pt_handler_mutex);
-    pthread_mutex_destroy(&partition_share->crd_mutex);
-    pthread_mutex_destroy(&partition_share->sts_mutex);
-    spider_free(spider_current_trx, partition_share, MYF(0));
-  }
-  pthread_mutex_unlock(&spider_pt_share_mutex);
+      wide_share->pt_handler_hash_id,
+      wide_share->pt_handler_hash.array.max_element *
+      wide_share->pt_handler_hash.array.size_of_element);
+    my_hash_free(&wide_share->pt_handler_hash);
+    pthread_mutex_destroy(&wide_share->pt_handler_mutex);
+    pthread_mutex_destroy(&wide_share->crd_mutex);
+    pthread_mutex_destroy(&wide_share->sts_mutex);
+    spider_free(spider_current_trx, wide_share, MYF(0));
+  }
+  pthread_mutex_unlock(&spider_wide_share_mutex);
   DBUG_RETURN(0);
 }
 
-void spider_copy_sts_to_pt_share(
-  SPIDER_PARTITION_SHARE *partition_share,
+void spider_copy_sts_to_wide_share(
+  SPIDER_WIDE_SHARE *wide_share,
   SPIDER_SHARE *share
 ) {
   DBUG_ENTER("spider_copy_sts_to_pt_share");
-  partition_share->stat = share->stat;
+  wide_share->stat = share->stat;
   DBUG_VOID_RETURN;
 }
 
 void spider_copy_sts_to_share(
   SPIDER_SHARE *share,
-  SPIDER_PARTITION_SHARE *partition_share
+  SPIDER_WIDE_SHARE *wide_share
 ) {
   DBUG_ENTER("spider_copy_sts_to_share");
-  share->stat = partition_share->stat;
+  share->stat = wide_share->stat;
   DBUG_VOID_RETURN;
 }
 
-void spider_copy_crd_to_pt_share(
-  SPIDER_PARTITION_SHARE *partition_share,
+void spider_copy_crd_to_wide_share(
+  SPIDER_WIDE_SHARE *wide_share,
   SPIDER_SHARE *share,
   int fields
 ) {
-  DBUG_ENTER("spider_copy_crd_to_pt_share");
-  memcpy(partition_share->cardinality, share->cardinality,
+  DBUG_ENTER("spider_copy_crd_to_wide_share");
+  memcpy(wide_share->cardinality, share->cardinality,
     sizeof(longlong) * fields);
   DBUG_VOID_RETURN;
 }
 
 void spider_copy_crd_to_share(
   SPIDER_SHARE *share,
-  SPIDER_PARTITION_SHARE *partition_share,
+  SPIDER_WIDE_SHARE *wide_share,
   int fields
 ) {
   DBUG_ENTER("spider_copy_crd_to_share");
-  memcpy(share->cardinality, partition_share->cardinality,
+  memcpy(share->cardinality, wide_share->cardinality,
     sizeof(longlong) * fields);
   DBUG_VOID_RETURN;
 }
-#endif
 
 int spider_open_all_tables(
   SPIDER_TRX *trx,
@@ -6420,7 +6416,7 @@ int spider_open_all_tables(
         free_root(&mem_root, MYF(0));
         DBUG_RETURN(HA_ERR_OUT_OF_MEM);
       }
-      spider->lock_type = TL_READ_NO_INSERT;
+      spider->wide_handler->lock_type = TL_READ_NO_INSERT;
 
       if (!(share = (SPIDER_SHARE *)
         spider_bulk_malloc(spider_current_trx, 52, MYF(MY_WME | MY_ZEROFILL),
@@ -6458,7 +6454,7 @@ int spider_open_all_tables(
       memcpy(longlong_info, &tmp_longlong, sizeof(longlong) *
         SPIDER_TMP_SHARE_LONGLONG_COUNT);
       spider->share = share;
-      spider->trx = trx;
+      spider->wide_handler->trx = trx;
       spider->conns = conns;
       spider->need_mons = need_mon;
       spider->conn_link_idx[0] = 0;
@@ -6831,10 +6827,10 @@ int spider_db_done(
   my_hash_free(&spider_lgtm_tblhnd_share_hash);
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   spider_free_mem_calc(spider_current_trx,
-    spider_open_pt_share_id,
-    spider_open_pt_share.array.max_element *
-    spider_open_pt_share.array.size_of_element);
-  my_hash_free(&spider_open_pt_share);
+    spider_open_wide_share_id,
+    spider_open_wide_share.array.max_element *
+    spider_open_wide_share.array.size_of_element);
+  my_hash_free(&spider_open_wide_share);
 #endif
   pthread_mutex_lock(&spider_init_error_tbl_mutex);
   while ((spider_init_error_table = (SPIDER_INIT_ERROR_TABLE*)
@@ -6872,7 +6868,7 @@ int spider_db_done(
   pthread_mutex_destroy(&spider_conn_mutex);
   pthread_mutex_destroy(&spider_lgtm_tblhnd_share_mutex);
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-  pthread_mutex_destroy(&spider_pt_share_mutex);
+  pthread_mutex_destroy(&spider_wide_share_mutex);
 #endif
   pthread_mutex_destroy(&spider_init_error_tbl_mutex);
   pthread_mutex_destroy(&spider_conn_id_mutex);
@@ -7048,12 +7044,12 @@ int spider_db_init(
 
 #ifdef WITH_PARTITION_STORAGE_ENGINE
 #if MYSQL_VERSION_ID < 50500
-  if (pthread_mutex_init(&spider_pt_share_mutex, MY_MUTEX_INIT_FAST))
+  if (pthread_mutex_init(&spider_wide_share_mutex, MY_MUTEX_INIT_FAST))
 #else
-  if (mysql_mutex_init(spd_key_mutex_pt_share,
-    &spider_pt_share_mutex, MY_MUTEX_INIT_FAST))
+  if (mysql_mutex_init(spd_key_mutex_wide_share,
+    &spider_wide_share_mutex, MY_MUTEX_INIT_FAST))
 #endif
-    goto error_pt_share_mutex_init;
+    goto error_wide_share_mutex_init;
 
 #endif
 #if MYSQL_VERSION_ID < 50500
@@ -7141,15 +7137,17 @@ int spider_db_init(
     spider_init_error_tables.array.max_element *
     spider_init_error_tables.array.size_of_element);
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-  if (my_hash_init(PSI_INSTRUMENT_ME, &spider_open_pt_share, spd_charset_utf8mb3_bin, 32, 0, 0,
-                   (my_hash_get_key) spider_pt_share_get_key, 0, 0))
-    goto error_open_pt_share_hash_init;
+  if(
+    my_hash_init(PSI_INSTRUMENT_ME, &spider_open_wide_share, spd_charset_utf8mb3_bin, 32, 0, 0,
+                   (my_hash_get_key) spider_wide_share_get_key, 0, 0)
+  )
+    goto error_open_wide_share_hash_init;
 
-  spider_alloc_calc_mem_init(spider_open_pt_share, 145);
+  spider_alloc_calc_mem_init(spider_open_wide_share, 145);
   spider_alloc_calc_mem(NULL,
-    spider_open_pt_share,
-    spider_open_pt_share.array.max_element *
-    spider_open_pt_share.array.size_of_element);
+    spider_open_wide_share,
+    spider_open_wide_share.array.max_element *
+    spider_open_wide_share.array.size_of_element);
 #endif
   if (my_hash_init(PSI_INSTRUMENT_ME, &spider_lgtm_tblhnd_share_hash,
                    spd_charset_utf8mb3_bin, 32, 0, 0,
@@ -7417,11 +7415,11 @@ error_open_connections_hash_init:
 error_lgtm_tblhnd_share_hash_init:
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   spider_free_mem_calc(NULL,
-    spider_open_pt_share_id,
-    spider_open_pt_share.array.max_element *
-    spider_open_pt_share.array.size_of_element);
-  my_hash_free(&spider_open_pt_share);
-error_open_pt_share_hash_init:
+    spider_open_wide_share_id,
+    spider_open_wide_share.array.max_element *
+    spider_open_wide_share.array.size_of_element);
+  my_hash_free(&spider_open_wide_share);
+error_open_wide_share_hash_init:
 #endif
   spider_free_mem_calc(NULL,
     spider_init_error_tables_id,
@@ -7454,8 +7452,8 @@ error_conn_mutex_init:
   pthread_mutex_destroy(&spider_lgtm_tblhnd_share_mutex);
 error_lgtm_tblhnd_share_mutex_init:
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-  pthread_mutex_destroy(&spider_pt_share_mutex);
-error_pt_share_mutex_init:
+  pthread_mutex_destroy(&spider_wide_share_mutex);
+error_wide_share_mutex_init:
 #endif
   pthread_mutex_destroy(&spider_init_error_tbl_mutex);
 error_init_error_tbl_mutex_init:
@@ -7633,26 +7631,26 @@ int spider_get_sts(
     /* get */
     get_type = 1;
   } else if (
-    !share->partition_share->sts_init
+    !share->wide_share->sts_init
   ) {
-    pthread_mutex_lock(&share->partition_share->sts_mutex);
-    if (!share->partition_share->sts_init)
+    pthread_mutex_lock(&share->wide_share->sts_mutex);
+    if (!share->wide_share->sts_init)
     {
       /* get after mutex_lock */
       get_type = 2;
     } else {
-      pthread_mutex_unlock(&share->partition_share->sts_mutex);
+      pthread_mutex_unlock(&share->wide_share->sts_mutex);
       /* copy */
       get_type = 0;
     }
   } else if (
-    difftime(share->sts_get_time, share->partition_share->sts_get_time) <
+    difftime(share->sts_get_time, share->wide_share->sts_get_time) <
       sts_interval
   ) {
     /* copy */
     get_type = 0;
   } else if (
-    !pthread_mutex_trylock(&share->partition_share->sts_mutex)
+    !pthread_mutex_trylock(&share->wide_share->sts_mutex)
   ) {
     /* get after mutex_trylock */
     get_type = 3;
@@ -7684,7 +7682,7 @@ int spider_get_sts(
   {
 #ifdef WITH_PARTITION_STORAGE_ENGINE
     if (get_type == 0)
-      spider_copy_sts_to_share(share, share->partition_share);
+      spider_copy_sts_to_share(share, share->wide_share);
     else {
 #endif
       error_num = spider_db_show_table_status(spider, link_idx, sts_mode, flag);
@@ -7694,7 +7692,7 @@ int spider_get_sts(
   }
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   if (get_type >= 2)
-    pthread_mutex_unlock(&share->partition_share->sts_mutex);
+    pthread_mutex_unlock(&share->wide_share->sts_mutex);
 #endif
   if (error_num)
   {
@@ -7702,7 +7700,7 @@ int spider_get_sts(
     SPIDER_PARTITION_HANDLER_SHARE *partition_handler_share =
       spider->partition_handler_share;
     if (
-      !share->partition_share->sts_init &&
+      !share->wide_share->sts_init &&
       sts_sync >= sts_sync_level &&
       get_type > 1 &&
       partition_handler_share &&
@@ -7715,9 +7713,9 @@ int spider_get_sts(
       double tmp_sts_interval;
       int tmp_sts_mode;
       int tmp_sts_sync;
-      THD *thd = spider->trx->thd;
+      THD *thd = spider->wide_handler->trx->thd;
       for (roop_count = 1;
-        roop_count < (int) partition_handler_share->use_count;
+        roop_count < (int) partition_handler_share->no_parts;
         roop_count++)
       {
         tmp_spider =
@@ -7729,12 +7727,12 @@ int spider_get_sts(
         spider_get_sts(tmp_share, tmp_spider->search_link_idx,
           tmp_time, tmp_spider, tmp_sts_interval, tmp_sts_mode, tmp_sts_sync,
           1, flag);
-        if (share->partition_share->sts_init)
+        if (share->wide_share->sts_init)
         {
           error_num = 0;
           thd->clear_error();
           get_type = 0;
-          spider_copy_sts_to_share(share, share->partition_share);
+          spider_copy_sts_to_share(share, share->wide_share);
           break;
         }
       }
@@ -7746,9 +7744,9 @@ int spider_get_sts(
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   if (sts_sync >= sts_sync_level && get_type > 0)
   {
-    spider_copy_sts_to_pt_share(share->partition_share, share);
-    share->partition_share->sts_get_time = tmp_time;
-    share->partition_share->sts_init = TRUE;
+    spider_copy_sts_to_wide_share(share->wide_share, share);
+    share->wide_share->sts_get_time = tmp_time;
+    share->wide_share->sts_init = TRUE;
   }
 #endif
   share->sts_get_time = tmp_time;
@@ -7781,26 +7779,26 @@ int spider_get_crd(
     /* get */
     get_type = 1;
   } else if (
-    !share->partition_share->crd_init
+    !share->wide_share->crd_init
   ) {
-    pthread_mutex_lock(&share->partition_share->crd_mutex);
-    if (!share->partition_share->crd_init)
+    pthread_mutex_lock(&share->wide_share->crd_mutex);
+    if (!share->wide_share->crd_init)
     {
       /* get after mutex_lock */
       get_type = 2;
     } else {
-      pthread_mutex_unlock(&share->partition_share->crd_mutex);
+      pthread_mutex_unlock(&share->wide_share->crd_mutex);
       /* copy */
       get_type = 0;
     }
   } else if (
-    difftime(share->crd_get_time, share->partition_share->crd_get_time) <
+    difftime(share->crd_get_time, share->wide_share->crd_get_time) <
       crd_interval
   ) {
     /* copy */
     get_type = 0;
   } else if (
-    !pthread_mutex_trylock(&share->partition_share->crd_mutex)
+    !pthread_mutex_trylock(&share->wide_share->crd_mutex)
   ) {
     /* get after mutex_trylock */
     get_type = 3;
@@ -7832,7 +7830,7 @@ int spider_get_crd(
   {
 #ifdef WITH_PARTITION_STORAGE_ENGINE
     if (get_type == 0)
-      spider_copy_crd_to_share(share, share->partition_share,
+      spider_copy_crd_to_share(share, share->wide_share,
         table->s->fields);
     else {
 #endif
@@ -7843,7 +7841,7 @@ int spider_get_crd(
   }
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   if (get_type >= 2)
-    pthread_mutex_unlock(&share->partition_share->crd_mutex);
+    pthread_mutex_unlock(&share->wide_share->crd_mutex);
 #endif
   if (error_num)
   {
@@ -7851,7 +7849,7 @@ int spider_get_crd(
     SPIDER_PARTITION_HANDLER_SHARE *partition_handler_share =
       spider->partition_handler_share;
     if (
-      !share->partition_share->crd_init &&
+      !share->wide_share->crd_init &&
       crd_sync >= crd_sync_level &&
       get_type > 1 &&
       partition_handler_share &&
@@ -7864,9 +7862,9 @@ int spider_get_crd(
       double tmp_crd_interval;
       int tmp_crd_mode;
       int tmp_crd_sync;
-      THD *thd = spider->trx->thd;
+      THD *thd = spider->wide_handler->trx->thd;
       for (roop_count = 1;
-        roop_count < (int) partition_handler_share->use_count;
+        roop_count < (int) partition_handler_share->no_parts;
         roop_count++)
       {
         tmp_spider =
@@ -7878,12 +7876,12 @@ int spider_get_crd(
         spider_get_crd(tmp_share, tmp_spider->search_link_idx,
           tmp_time, tmp_spider, table, tmp_crd_interval, tmp_crd_mode,
           tmp_crd_sync, 1);
-        if (share->partition_share->crd_init)
+        if (share->wide_share->crd_init)
         {
           error_num = 0;
           thd->clear_error();
           get_type = 0;
-          spider_copy_crd_to_share(share, share->partition_share,
+          spider_copy_crd_to_share(share, share->wide_share,
             table->s->fields);
           break;
         }
@@ -7896,10 +7894,10 @@ int spider_get_crd(
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   if (crd_sync >= crd_sync_level && get_type > 0)
   {
-    spider_copy_crd_to_pt_share(share->partition_share, share,
+    spider_copy_crd_to_wide_share(share->wide_share, share,
       table->s->fields);
-    share->partition_share->crd_get_time = tmp_time;
-    share->partition_share->crd_init = TRUE;
+    share->wide_share->crd_get_time = tmp_time;
+    share->wide_share->crd_init = TRUE;
   }
 #endif
   share->crd_get_time = tmp_time;
@@ -7912,14 +7910,14 @@ void spider_set_result_list_param(
 ) {
   SPIDER_RESULT_LIST *result_list = &spider->result_list;
   SPIDER_SHARE *share = spider->share;
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   DBUG_ENTER("spider_set_result_list_param");
   result_list->internal_offset =
     spider_param_internal_offset(thd, share->internal_offset);
   result_list->internal_limit =
 #ifdef INFO_KIND_FORCE_LIMIT_BEGIN
-    spider->info_limit < 9223372036854775807LL ?
-    spider->info_limit :
+    spider->wide_handler->info_limit < 9223372036854775807LL ?
+    spider->wide_handler->info_limit :
 #endif
     spider_param_internal_limit(thd, share->internal_limit);
   result_list->split_read = spider_split_read_param(spider);
@@ -8465,7 +8463,7 @@ longlong spider_split_read_param(
 ) {
   SPIDER_SHARE *share = spider->share;
   SPIDER_RESULT_LIST *result_list = &spider->result_list;
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   st_select_lex *select_lex;
   longlong select_limit;
   longlong offset_limit;
@@ -8474,10 +8472,11 @@ longlong spider_split_read_param(
   DBUG_ENTER("spider_split_read_param");
   result_list->set_split_read_count = 1;
 #ifdef INFO_KIND_FORCE_LIMIT_BEGIN
-  if (spider->info_limit < 9223372036854775807LL)
+  if (spider->wide_handler->info_limit < 9223372036854775807LL)
   {
-    DBUG_PRINT("info",("spider info_limit=%lld", spider->info_limit));
-    longlong info_limit = spider->info_limit;
+    DBUG_PRINT("info",("spider info_limit=%lld",
+      spider->wide_handler->info_limit));
+    longlong info_limit = spider->wide_handler->info_limit;
     result_list->split_read_base = info_limit;
     result_list->semi_split_read = 0;
     result_list->first_read = info_limit;
@@ -8497,7 +8496,8 @@ longlong spider_split_read_param(
   {
     int bulk_update_mode = spider_param_bulk_update_mode(thd,
       share->bulk_update_mode);
-    DBUG_PRINT("info",("spider sql_command=%u", spider->sql_command));
+    DBUG_PRINT("info",("spider sql_command=%u",
+      spider->wide_handler->sql_command));
     DBUG_PRINT("info",("spider bulk_update_mode=%d", bulk_update_mode));
     DBUG_PRINT("info",("spider support_bulk_update_sql=%s",
       spider->support_bulk_update_sql() ? "TRUE" : "FALSE"));
@@ -8505,32 +8505,32 @@ longlong spider_split_read_param(
     bool inserting =
       (
 #ifdef HS_HAS_SQLCOM
-        spider->sql_command == SQLCOM_HS_INSERT ||
+        spider->wide_handler->sql_command == SQLCOM_HS_INSERT ||
 #endif
-        spider->sql_command == SQLCOM_INSERT ||
-        spider->sql_command == SQLCOM_INSERT_SELECT
+        spider->wide_handler->sql_command == SQLCOM_INSERT ||
+        spider->wide_handler->sql_command == SQLCOM_INSERT_SELECT
       );
 #endif
     bool updating =
       (
 #ifdef HS_HAS_SQLCOM
-        spider->sql_command == SQLCOM_HS_UPDATE ||
+        spider->wide_handler->sql_command == SQLCOM_HS_UPDATE ||
 #endif
-        spider->sql_command == SQLCOM_UPDATE ||
-        spider->sql_command == SQLCOM_UPDATE_MULTI
+        spider->wide_handler->sql_command == SQLCOM_UPDATE ||
+        spider->wide_handler->sql_command == SQLCOM_UPDATE_MULTI
       );
     bool deleting =
       (
 #ifdef HS_HAS_SQLCOM
-        spider->sql_command == SQLCOM_HS_DELETE ||
+        spider->wide_handler->sql_command == SQLCOM_HS_DELETE ||
 #endif
-        spider->sql_command == SQLCOM_DELETE ||
-        spider->sql_command == SQLCOM_DELETE_MULTI
+        spider->wide_handler->sql_command == SQLCOM_DELETE ||
+        spider->wide_handler->sql_command == SQLCOM_DELETE_MULTI
       );
     bool replacing =
       (
-        spider->sql_command == SQLCOM_REPLACE ||
-        spider->sql_command == SQLCOM_REPLACE_SELECT
+        spider->wide_handler->sql_command == SQLCOM_REPLACE ||
+        spider->wide_handler->sql_command == SQLCOM_REPLACE_SELECT
       );
     DBUG_PRINT("info",("spider updating=%s", updating ? "TRUE" : "FALSE"));
     DBUG_PRINT("info",("spider deleting=%s", deleting ? "TRUE" : "FALSE"));
@@ -8716,7 +8716,7 @@ void spider_next_split_read_param(
 bool spider_check_direct_order_limit(
   ha_spider *spider
 ) {
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
   SPIDER_SHARE *share = spider->share;
   st_select_lex *select_lex;
   longlong select_limit;
@@ -8729,7 +8729,7 @@ bool spider_check_direct_order_limit(
     spider->use_index_merge = TRUE;
   }
   DBUG_PRINT("info",("spider SQLCOM_HA_READ=%s",
-    (spider->sql_command == SQLCOM_HA_READ) ? "TRUE" : "FALSE"));
+    (spider->wide_handler->sql_command == SQLCOM_HA_READ) ? "TRUE" : "FALSE"));
   DBUG_PRINT("info",("spider sql_kinds with SPIDER_SQL_KIND_HANDLER=%s",
     (spider->sql_kinds & SPIDER_SQL_KIND_HANDLER) ? "TRUE" : "FALSE"));
   DBUG_PRINT("info",("spider use_index_merge=%s",
@@ -8741,7 +8741,7 @@ bool spider_check_direct_order_limit(
     spider->is_bulk_access_clone ? "TRUE" : "FALSE"));
 #endif
   if (
-    spider->sql_command != SQLCOM_HA_READ &&
+    spider->wide_handler->sql_command != SQLCOM_HA_READ &&
     !spider->use_index_merge &&
 #ifdef HA_CAN_BULK_ACCESS
     (!spider->is_clone || spider->is_bulk_access_clone)
@@ -8899,7 +8899,7 @@ bool spider_check_direct_order_limit(
       DBUG_PRINT("info",("spider TRUE"));
       spider->result_list.internal_limit = select_limit + offset_limit;
       spider->result_list.split_read = select_limit + offset_limit;
-      spider->trx->direct_order_limit_count++;
+      spider->wide_handler->trx->direct_order_limit_count++;
       DBUG_RETURN(TRUE);
     }
   }
@@ -9003,7 +9003,7 @@ int spider_set_direct_limit_offset(
   ha_spider *spider
 ) {
 #ifndef SPIDER_ENGINE_CONDITION_PUSHDOWN_IS_ALWAYS_ON
-  THD *thd = spider->trx->thd;
+  THD *thd = spider->wide_handler->trx->thd;
 #endif
   st_select_lex *select_lex;
   longlong select_limit;
@@ -9015,10 +9015,11 @@ int spider_set_direct_limit_offset(
     DBUG_RETURN(TRUE);
 
   if (
-    spider->pt_handler_share_creator &&
-    spider->pt_handler_share_creator != spider
+    spider->partition_handler_share &&
+    !spider->pt_handler_share_owner
   ) {
-    if (spider->pt_handler_share_creator->result_list.direct_limit_offset == TRUE)
+    if (spider->partition_handler_share->owner->
+      result_list.direct_limit_offset == TRUE)
     {
       spider->result_list.direct_limit_offset = TRUE;
       DBUG_RETURN(TRUE);
@@ -9028,7 +9029,7 @@ int spider_set_direct_limit_offset(
   }
 
   if (
-    spider->sql_command != SQLCOM_SELECT ||
+    spider->wide_handler->sql_command != SQLCOM_SELECT ||
 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
     spider->result_list.direct_aggregate ||
 #endif
@@ -9071,7 +9072,8 @@ int spider_set_direct_limit_offset(
       OPTIMIZER_SWITCH_ENGINE_CONDITION_PUSHDOWN) ||
 #endif
 #endif
-    spider->condition   // conditions is null may be no where condition in rand_init
+    // conditions is null may be no where condition in rand_init
+    spider->wide_handler->condition
   )
     DBUG_RETURN(FALSE);
 
@@ -9626,6 +9628,7 @@ int spider_create_spider_object_for_share(
   char **hs_w_conn_keys;
 #endif
   spider_db_handler **dbton_hdl;
+  SPIDER_WIDE_HANDLER *wide_handler;
   DBUG_ENTER("spider_create_spider_object_for_share");
   DBUG_PRINT("info",("spider trx=%p", trx));
   DBUG_PRINT("info",("spider share=%p", share));
@@ -9655,6 +9658,7 @@ int spider_create_spider_object_for_share(
       &hs_r_conn_keys, (uint) (sizeof(char *) * share->link_count),
       &hs_w_conn_keys, (uint) (sizeof(char *) * share->link_count),
       &dbton_hdl, (uint) (sizeof(spider_db_handler *) * SPIDER_DBTON_SIZE),
+      &wide_handler, (uint) sizeof(SPIDER_WIDE_HANDLER),
       NullS))
   )
 #else
@@ -9666,6 +9670,7 @@ int spider_create_spider_object_for_share(
       &conn_can_fo, (uint) (sizeof(uchar) * share->link_bitmap_size),
       &conn_keys, (uint) (sizeof(char *) * share->link_count),
       &dbton_hdl, (uint) (sizeof(spider_db_handler *) * SPIDER_DBTON_SIZE),
+      &wide_handler, (uint) sizeof(SPIDER_WIDE_HANDLER),
       NullS))
   )
 #endif
@@ -9674,7 +9679,8 @@ int spider_create_spider_object_for_share(
     goto error_need_mons_alloc;
   }
   DBUG_PRINT("info",("spider need_mons=%p", need_mons));
-  (*spider)->trx = trx;
+  (*spider)->wide_handler = wide_handler;
+  wide_handler->trx = trx;
   (*spider)->change_table_ptr(&share->table, share->table_share);
   (*spider)->share = share;
   (*spider)->conns = conns;
@@ -10052,7 +10058,7 @@ void *spider_table_bg_sts_action(
     conns = spider->conns;
     if (spider->search_link_idx < 0)
     {
-      spider->trx = trx;
+      spider->wide_handler->trx = trx;
       spider_trx_set_link_idx_for_all(spider);
       spider->search_link_idx = spider_conn_first_link_idx(thd,
         share->link_statuses, share->access_balances, spider->conn_link_idx,
@@ -10205,7 +10211,7 @@ void *spider_table_bg_crd_action(
     conns = spider->conns;
     if (spider->search_link_idx < 0)
     {
-      spider->trx = trx;
+      spider->wide_handler->trx = trx;
       spider_trx_set_link_idx_for_all(spider);
       spider->search_link_idx = spider_conn_first_link_idx(thd,
         share->link_statuses, share->access_balances, spider->conn_link_idx,
diff --git a/storage/spider/spd_table.h b/storage/spider/spd_table.h
index baeec2a9a3b..c4e3de32372 100644
--- a/storage/spider/spd_table.h
+++ b/storage/spider/spd_table.h
@@ -224,13 +224,13 @@ uchar *spider_tbl_get_key(
   my_bool not_used __attribute__ ((unused))
 );
 
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-uchar *spider_pt_share_get_key(
-  SPIDER_PARTITION_SHARE *share,
+uchar *spider_wide_share_get_key(
+  SPIDER_WIDE_SHARE *share,
   size_t *length,
   my_bool not_used __attribute__ ((unused))
 );
 
+#ifdef WITH_PARTITION_STORAGE_ENGINE
 uchar *spider_pt_handler_share_get_key(
   SPIDER_PARTITION_HANDLER_SHARE *share,
   size_t *length,
@@ -420,39 +420,37 @@ void spider_update_link_status_for_share(
   long link_status
 );
 
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-SPIDER_PARTITION_SHARE *spider_get_pt_share(
+SPIDER_WIDE_SHARE *spider_get_wide_share(
   SPIDER_SHARE *share,
   TABLE_SHARE *table_share,
   int *error_num
 );
 
-int spider_free_pt_share(
-  SPIDER_PARTITION_SHARE *partition_share
+int spider_free_wide_share(
+  SPIDER_WIDE_SHARE *wide_share
 );
 
-void spider_copy_sts_to_pt_share(
-  SPIDER_PARTITION_SHARE *partition_share,
+void spider_copy_sts_to_wide_share(
+  SPIDER_WIDE_SHARE *wide_share,
   SPIDER_SHARE *share
 );
 
 void spider_copy_sts_to_share(
   SPIDER_SHARE *share,
-  SPIDER_PARTITION_SHARE *partition_share
+  SPIDER_WIDE_SHARE *wide_share
 );
 
-void spider_copy_crd_to_pt_share(
-  SPIDER_PARTITION_SHARE *partition_share,
+void spider_copy_crd_to_wide_share(
+  SPIDER_WIDE_SHARE *wide_share,
   SPIDER_SHARE *share,
   int fields
 );
 
 void spider_copy_crd_to_share(
   SPIDER_SHARE *share,
-  SPIDER_PARTITION_SHARE *partition_share,
+  SPIDER_WIDE_SHARE *wide_share,
   int fields
 );
-#endif
 
 int spider_open_all_tables(
   SPIDER_TRX *trx,
diff --git a/storage/spider/spd_trx.cc b/storage/spider/spd_trx.cc
index 0e6d81e28f1..a339b5bebcb 100644
--- a/storage/spider/spd_trx.cc
+++ b/storage/spider/spd_trx.cc
@@ -247,6 +247,7 @@ int spider_trx_another_lock_tables(
   SPIDER_CONN *conn;
   ha_spider tmp_spider;
   SPIDER_SHARE tmp_share;
+  SPIDER_WIDE_HANDLER tmp_wide_handler;
   char sql_buf[MAX_FIELD_WIDTH];
   spider_string sql_str(sql_buf, sizeof(sql_buf), system_charset_info);
   DBUG_ENTER("spider_trx_another_lock_tables");
@@ -255,13 +256,11 @@ int spider_trx_another_lock_tables(
   sql_str.length(0);
   memset((void*)&tmp_spider, 0, sizeof(ha_spider));
   memset((void*)&tmp_share, 0, sizeof(SPIDER_SHARE));
+  memset((void*)&tmp_wide_handler, 0, sizeof(SPIDER_WIDE_HANDLER));
   tmp_spider.share = &tmp_share;
-  tmp_spider.trx = trx;
+  tmp_spider.wide_handler = &tmp_wide_handler;
+  tmp_wide_handler.trx = trx;
   tmp_share.access_charset = system_charset_info;
-/*
-  if ((error_num = spider_db_append_set_names(&tmp_share)))
-    DBUG_RETURN(error_num);
-*/
   tmp_spider.conns = &conn;
   tmp_spider.result_list.sqls = &sql_str;
   tmp_spider.need_mons = &need_mon;
@@ -273,17 +272,11 @@ int spider_trx_another_lock_tables(
       SPIDER_CONN_RESTORE_DASTATUS_AND_RESET_ERROR_NUM;
       if (error_num)
       {
-/*
-        spider_db_free_set_names(&tmp_share);
-*/
         DBUG_RETURN(error_num);
       }
     }
     roop_count++;
   }
-/*
-  spider_db_free_set_names(&tmp_share);
-*/
   DBUG_RETURN(0);
 }
 
@@ -387,10 +380,13 @@ int spider_trx_all_start_trx(
   THD *thd = trx->thd;
   SPIDER_CONN *conn;
   ha_spider tmp_spider;
+  SPIDER_WIDE_HANDLER tmp_wide_handler;
   DBUG_ENTER("spider_trx_all_start_trx");
   SPIDER_BACKUP_DASTATUS;
   memset((void*)&tmp_spider, 0, sizeof(ha_spider));
-  tmp_spider.trx = trx;
+  memset(&tmp_wide_handler, 0, sizeof(SPIDER_WIDE_HANDLER));
+  tmp_spider.wide_handler = &tmp_wide_handler;
+  tmp_wide_handler.trx = trx;
   tmp_spider.need_mons = &need_mon;
   while ((conn = (SPIDER_CONN*) my_hash_element(&trx->trx_conn_hash,
     roop_count)))
@@ -398,7 +394,8 @@ int spider_trx_all_start_trx(
     if (
       (spider_param_sync_trx_isolation(trx->thd) &&
         (error_num = spider_check_and_set_trx_isolation(conn, &need_mon))) ||
-      (error_num = spider_internal_start_trx(&tmp_spider, conn, 0))
+      (error_num = spider_internal_start_trx_for_connection(&tmp_spider,
+        conn, 0))
     ) {
       SPIDER_CONN_RESTORE_DASTATUS_AND_RESET_ERROR_NUM;
       if (error_num)
@@ -418,6 +415,7 @@ int spider_trx_all_flush_logs(
   SPIDER_CONN *conn;
   ha_spider tmp_spider;
   SPIDER_SHARE tmp_share;
+  SPIDER_WIDE_HANDLER tmp_wide_handler;
   long tmp_link_statuses = SPIDER_LINK_STATUS_OK;
   uint conn_link_idx = 0;
   long net_read_timeout = 600;
@@ -425,6 +423,7 @@ int spider_trx_all_flush_logs(
   DBUG_ENTER("spider_trx_all_flush_logs");
   SPIDER_BACKUP_DASTATUS;
   memset((void*)&tmp_spider, 0, sizeof(ha_spider));
+  memset(&tmp_wide_handler, 0, sizeof(SPIDER_WIDE_HANDLER));
   tmp_share.link_count = 1;
   tmp_share.all_link_count = 1;
   tmp_share.link_statuses = &tmp_link_statuses;
@@ -437,7 +436,8 @@ int spider_trx_all_flush_logs(
   tmp_spider.conns = &conn;
   tmp_spider.need_mons = &need_mon;
   tmp_spider.conn_link_idx = &conn_link_idx;
-  tmp_spider.trx = trx;
+  tmp_spider.wide_handler = &tmp_wide_handler;
+  tmp_wide_handler.trx = trx;
   while ((conn = (SPIDER_CONN*) my_hash_element(&trx->trx_conn_hash,
     roop_count)))
   {
@@ -1200,6 +1200,7 @@ SPIDER_TRX *spider_get_trx(
   int roop_count = 0, roop_count2;
   SPIDER_TRX *trx;
   SPIDER_SHARE *tmp_share;
+  SPIDER_WIDE_HANDLER *tmp_wide_handler;
   pthread_mutex_t *udf_table_mutexes;
   DBUG_ENTER("spider_get_trx");
 
@@ -1212,6 +1213,7 @@ SPIDER_TRX *spider_get_trx(
       spider_bulk_malloc(NULL, 56, MYF(MY_WME | MY_ZEROFILL),
         &trx, (uint) (sizeof(*trx)),
         &tmp_share, (uint) (sizeof(SPIDER_SHARE)),
+        &tmp_wide_handler, (uint) sizeof(SPIDER_WIDE_HANDLER),
         &udf_table_mutexes, (uint) (sizeof(pthread_mutex_t) *
           spider_param_udf_table_lock_mutex_count()),
         NullS))
@@ -1387,7 +1389,8 @@ SPIDER_TRX *spider_get_trx(
       }
       trx->tmp_spider->need_mons = &trx->tmp_need_mon;
       trx->tmp_spider->share = trx->tmp_share;
-      trx->tmp_spider->trx = trx;
+      trx->tmp_spider->wide_handler = tmp_wide_handler;
+      tmp_wide_handler->trx = trx;
       trx->tmp_spider->dbton_handler = trx->tmp_dbton_handler;
       if (!(trx->tmp_spider->result_list.sqls =
         new spider_string[trx->tmp_share->link_count]))
@@ -1875,27 +1878,14 @@ int spider_start_internal_consistent_snapshot(
 }
 
 int spider_internal_start_trx(
-  ha_spider *spider,
-  SPIDER_CONN *conn,
-  int link_idx
+  ha_spider *spider
 ) {
   int error_num;
-  SPIDER_TRX *trx = spider->trx;
+  SPIDER_TRX *trx = spider->wide_handler->trx;
   THD *thd = trx->thd;
-  bool sync_autocommit = spider_param_sync_autocommit(thd);
-  double ping_interval_at_trx_start =
-    spider_param_ping_interval_at_trx_start(thd);
   bool xa_lock = FALSE;
-  time_t tmp_time = (time_t) time((time_t*) 0);
   DBUG_ENTER("spider_internal_start_trx");
 
-  if (
-    conn->server_lost ||
-    difftime(tmp_time, conn->ping_time) >= ping_interval_at_trx_start
-  ) {
-    spider_conn_queue_ping(spider, conn, link_idx);
-  }
-  conn->disable_reconnect = TRUE;
   if (!trx->trx_start)
   {
     if (!trx->trx_consistent_snapshot)
@@ -1906,19 +1896,7 @@ int spider_internal_start_trx(
       trx->internal_xa_snapshot = spider_param_internal_xa_snapshot(thd);
     }
   }
-  if (
-    (error_num = spider_check_and_set_sql_log_off(thd, conn,
-      &spider->need_mons[link_idx])) ||
-    (error_num = spider_check_and_set_wait_timeout(thd, conn,
-      &spider->need_mons[link_idx])) ||
-    (spider_param_sync_sql_mode(thd) &&
-      (error_num = spider_check_and_set_sql_mode(thd, conn,
-        &spider->need_mons[link_idx]))) ||
-    (sync_autocommit &&
-      (error_num = spider_check_and_set_autocommit(thd, conn,
-        &spider->need_mons[link_idx])))
-  )
-    goto error;
+  spider->wide_handler->consistent_snapshot = FALSE;
   if (trx->trx_consistent_snapshot)
   {
     if (trx->internal_xa && trx->internal_xa_snapshot < 2)
@@ -1929,9 +1907,7 @@ int spider_internal_start_trx(
       goto error;
     } else if (!trx->internal_xa || trx->internal_xa_snapshot == 2)
     {
-      if ((error_num = spider_start_internal_consistent_snapshot(trx, conn,
-        &spider->need_mons[link_idx])))
-        goto error;
+      spider->wide_handler->consistent_snapshot = TRUE;
     }
   }
   DBUG_PRINT("info",("spider trx->trx_start= %s",
@@ -1950,7 +1926,7 @@ int spider_internal_start_trx(
       !trx->trx_xa &&
       trx->internal_xa &&
       (!trx->trx_consistent_snapshot || trx->internal_xa_snapshot == 3) &&
-      spider->sql_command != SQLCOM_LOCK_TABLES
+      spider->wide_handler->sql_command != SQLCOM_LOCK_TABLES
     ) {
       trx->trx_xa = TRUE;
       trx->xid.formatID = 1;
@@ -2003,6 +1979,54 @@ int spider_internal_start_trx(
     trx->updated_in_this_trx = FALSE;
     DBUG_PRINT("info",("spider trx->updated_in_this_trx=FALSE"));
   }
+  DBUG_RETURN(0);
+
+error:
+  if (xa_lock)
+    spider_xa_unlock(&trx->internal_xid_state);
+  DBUG_RETURN(error_num);
+}
+
+int spider_internal_start_trx_for_connection(
+  ha_spider *spider,
+  SPIDER_CONN *conn,
+  int link_idx
+) {
+  int error_num;
+  SPIDER_TRX *trx = spider->wide_handler->trx;
+  THD *thd = trx->thd;
+  bool sync_autocommit = spider_param_sync_autocommit(thd);
+  double ping_interval_at_trx_start =
+    spider_param_ping_interval_at_trx_start(thd);
+  time_t tmp_time = (time_t) time((time_t*) 0);
+  DBUG_ENTER("spider_internal_start_trx_for_connection");
+  if (
+    conn->server_lost ||
+    difftime(tmp_time, conn->ping_time) >= ping_interval_at_trx_start
+  ) {
+    spider_conn_queue_ping(spider, conn, link_idx);
+  }
+  conn->disable_reconnect = TRUE;
+  if (
+    (error_num = spider_check_and_set_sql_log_off(thd, conn,
+      &spider->need_mons[link_idx])) ||
+    (error_num = spider_check_and_set_wait_timeout(thd, conn,
+      &spider->need_mons[link_idx])) ||
+    (spider_param_sync_sql_mode(thd) &&
+      (error_num = spider_check_and_set_sql_mode(thd, conn,
+        &spider->need_mons[link_idx]))) ||
+    (sync_autocommit &&
+      (error_num = spider_check_and_set_autocommit(thd, conn,
+        &spider->need_mons[link_idx])))
+  )
+    goto error;
+
+  if (spider->wide_handler->consistent_snapshot)
+  {
+    if ((error_num = spider_start_internal_consistent_snapshot(trx, conn,
+      &spider->need_mons[link_idx])))
+      goto error;
+  }
 
   DBUG_PRINT("info",("spider sync_autocommit = %d", sync_autocommit));
   DBUG_PRINT("info",("spider conn->semi_trx_chk = %d", conn->semi_trx_chk));
@@ -2068,8 +2092,6 @@ int spider_internal_start_trx(
   DBUG_RETURN(0);
 
 error:
-  if (xa_lock)
-    spider_xa_unlock(&trx->internal_xid_state);
   DBUG_RETURN(error_num);
 }
 
@@ -3750,11 +3772,11 @@ int spider_check_trx_and_get_conn(
     DBUG_PRINT("info",("spider get trx error"));
     DBUG_RETURN(error_num);
   }
-  spider->trx = trx;
+  spider->wide_handler->trx = trx;
   spider->set_error_mode();
   if (
-    spider->sql_command != SQLCOM_DROP_TABLE &&
-    spider->sql_command != SQLCOM_ALTER_TABLE
+    spider->wide_handler->sql_command != SQLCOM_DROP_TABLE &&
+    spider->wide_handler->sql_command != SQLCOM_ALTER_TABLE
   ) {
     SPIDER_TRX_HA *trx_ha = spider_check_trx_ha(trx, spider);
     if (!trx_ha || trx_ha->wait_for_reusing)
@@ -3810,9 +3832,9 @@ int spider_check_trx_and_get_conn(
         SPIDER_LINK_STATUS_NG
     ) {
       DBUG_PRINT("info",(first_byte != *spider->conn_keys[0] ?
-        "spider change conn type" : trx != spider->trx ? "spider change thd" :
-        "spider next trx"));
-      spider->trx = trx;
+        "spider change conn type" : trx != spider->wide_handler->trx ?
+        "spider change thd" : "spider next trx"));
+      spider->wide_handler->trx = trx;
       spider->trx_conn_adjustment = trx->trx_conn_adjustment;
 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
       if (use_conn_kind)
diff --git a/storage/spider/spd_trx.h b/storage/spider/spd_trx.h
index ca46bae20cc..3bf93aada1a 100644
--- a/storage/spider/spd_trx.h
+++ b/storage/spider/spd_trx.h
@@ -126,6 +126,10 @@ int spider_start_internal_consistent_snapshot(
 );
 
 int spider_internal_start_trx(
+  ha_spider *spider
+);
+
+int spider_internal_start_trx_for_connection(
   ha_spider *spider,
   SPIDER_CONN *conn,
   int link_idx