diff --git a/client/mysql_plugin.c b/client/mysql_plugin.c
index 6c205d78c3b..00870fa72e0 100644
--- a/client/mysql_plugin.c
+++ b/client/mysql_plugin.c
@@ -735,8 +735,8 @@ static int check_options(int argc, char **argv, char *operation)
 {
   int i= 0;                    /* loop counter */
   int num_found= 0;            /* number of options found (shortcut loop) */
-  char config_file[FN_REFLEN]; /* configuration file name */
-  char plugin_name[FN_REFLEN]; /* plugin name */
+  char config_file[FN_REFLEN+1]; /* configuration file name */
+  char plugin_name[FN_REFLEN+1]; /* plugin name */
 
   /* Form prefix strings for the options. */
   const char *basedir_prefix = "--basedir=";
@@ -784,8 +784,8 @@ static int check_options(int argc, char **argv, char *operation)
     /* read the plugin config file and check for match against argument */
     else
     {
-      if (safe_strcpy_truncated(plugin_name, sizeof plugin_name, argv[i]) ||
-          safe_strcpy_truncated(config_file, sizeof config_file, argv[i]) ||
+      if (safe_strcpy_truncated(plugin_name, sizeof(plugin_name)-1, argv[i]) ||
+          safe_strcpy_truncated(config_file, sizeof(config_file)-1, argv[i]) ||
           safe_strcat(config_file, sizeof(config_file), ".ini"))
       {
         fprintf(stderr, "ERROR: argument is too long.\n");
diff --git a/cmake/os/FreeBSD.cmake b/cmake/os/FreeBSD.cmake
new file mode 100644
index 00000000000..4bcd844929f
--- /dev/null
+++ b/cmake/os/FreeBSD.cmake
@@ -0,0 +1,19 @@
+# Copyright (C) 2024 MariaDB Foundation
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1335  USA 
+
+# This file includes FreeBSD specific options and quirks, related to system checks
+
+# For all userspace dependencies
+LINK_DIRECTORIES(/usr/local/lib)
diff --git a/extra/mariabackup/backup_copy.cc b/extra/mariabackup/backup_copy.cc
index a328f5e0ec7..ec92791c3b9 100644
--- a/extra/mariabackup/backup_copy.cc
+++ b/extra/mariabackup/backup_copy.cc
@@ -1353,9 +1353,6 @@ out:
 	return(ret);
 }
 
-lsn_t server_lsn_after_lock;
-extern void backup_wait_for_lsn(lsn_t lsn);
-
 /** Release resources after backup_files() */
 void backup_release()
 {
diff --git a/extra/mariabackup/xtrabackup.cc b/extra/mariabackup/xtrabackup.cc
index 68cc1edf571..873b3ee6eef 100644
--- a/extra/mariabackup/xtrabackup.cc
+++ b/extra/mariabackup/xtrabackup.cc
@@ -3503,35 +3503,70 @@ static bool xtrabackup_copy_logfile()
   return false;
 }
 
-/**
-Wait until redo log copying thread processes given lsn
-*/
-void backup_wait_for_lsn(lsn_t lsn)
+static bool backup_wait_timeout(lsn_t lsn, lsn_t last_lsn)
 {
-  mysql_mutex_lock(&recv_sys.mutex);
-  for (lsn_t last_lsn{recv_sys.lsn}; last_lsn < lsn; )
+  if (last_lsn >= lsn)
+    return true;
+  msg("Was only able to copy log from " LSN_PF " to " LSN_PF
+      ", not " LSN_PF "; try increasing innodb_log_file_size",
+      log_sys.next_checkpoint_lsn, last_lsn, lsn);
+  return false;
+}
+
+/**
+Wait for enough log to be copied.
+@param lsn  log sequence number target
+@return the reached log sequence number (may be less or more than lsn)
+*/
+static lsn_t backup_wait_for_lsn_low(lsn_t lsn)
+{
+  mysql_mutex_assert_owner(&recv_sys.mutex);
+
+  lsn_t last_lsn{recv_sys.lsn};
+
+  if (last_lsn >= lsn)
+    return last_lsn;
+
+  msg("Waiting for log copy thread to read lsn " LSN_PF, lsn);
+
+  while (log_copying_running && last_lsn < lsn)
   {
     timespec abstime;
     set_timespec(abstime, 5);
     if (my_cond_timedwait(&scanned_lsn_cond, &recv_sys.mutex.m_mutex,
                           &abstime) &&
         last_lsn == recv_sys.lsn)
-      die("Was only able to copy log from " LSN_PF " to " LSN_PF
-          ", not " LSN_PF "; try increasing innodb_log_file_size",
-          log_sys.next_checkpoint_lsn, last_lsn, lsn);
+      break;
     last_lsn= recv_sys.lsn;
   }
-  mysql_mutex_unlock(&recv_sys.mutex);
+
+  return last_lsn;
+}
+
+/**
+Wait for enough log to be copied after BACKUP STAGE BLOCK_DDL.
+@param lsn  log sequence number target
+@return whether log_copying_thread() copied everything until the target lsn
+*/
+static bool backup_wait_for_lsn(lsn_t lsn)
+{
+  if (!lsn)
+    return true;
+  mysql_mutex_lock(&recv_sys.mutex);
+  ut_ad(!metadata_to_lsn);
+  ut_ad(!metadata_last_lsn);
+  lsn_t last_lsn{backup_wait_for_lsn_low(lsn)};
+  mysql_mutex_unlock(&recv_sys.mutex);
+  return backup_wait_timeout(lsn, last_lsn);
 }
 
-extern lsn_t server_lsn_after_lock;
 
 static void log_copying_thread()
 {
   my_thread_init();
   mysql_mutex_lock(&recv_sys.mutex);
   while (!xtrabackup_copy_logfile() &&
-         (!metadata_to_lsn || metadata_to_lsn > recv_sys.lsn))
+         (!metadata_last_lsn || metadata_last_lsn > recv_sys.lsn))
   {
     timespec abstime;
     set_timespec_nsec(abstime, 1000000ULL * xtrabackup_log_copy_interval);
@@ -3555,7 +3590,7 @@ static void io_watching_thread()
   mysql_mutex_lock(&recv_sys.mutex);
   ut_ad(have_io_watching_thread);
 
-  while (log_copying_running && !metadata_to_lsn)
+  while (log_copying_running && !metadata_last_lsn)
   {
     timespec abstime;
     set_timespec(abstime, 1);
@@ -4706,6 +4741,7 @@ end:
 
 static void stop_backup_threads()
 {
+  ut_ad(metadata_last_lsn);
   mysql_cond_broadcast(&log_copying_stop);
 
   if (log_copying_running || have_io_watching_thread)
@@ -4729,38 +4765,58 @@ static void stop_backup_threads()
   mysql_cond_destroy(&log_copying_stop);
 }
 
+/**
+Wait for enough log to be copied.
+@return whether log_copying_thread() copied everything until the target lsn
+*/
+static bool backup_wait_for_commit_lsn()
+{
+  lsn_t lsn= get_current_lsn(mysql_connection);
+  mysql_mutex_lock(&recv_sys.mutex);
+  ut_ad(!metadata_to_lsn);
+  ut_ad(!metadata_last_lsn);
+
+  lsn_t last_lsn= recv_sys.lsn;
+
+  /* read the latest checkpoint lsn */
+  if (recv_sys.find_checkpoint() == DB_SUCCESS && log_sys.is_latest())
+  {
+    if (log_sys.next_checkpoint_lsn > lsn)
+      lsn= log_sys.next_checkpoint_lsn;
+    metadata_to_lsn= log_sys.next_checkpoint_lsn;
+    msg("mariabackup: The latest check point (for incremental): '"
+        LSN_PF "'", metadata_to_lsn);
+  }
+  else
+  {
+    msg("Error: recv_sys.find_checkpoint() failed.");
+    metadata_last_lsn= 1;
+    stop_backup_threads();
+    mysql_mutex_unlock(&recv_sys.mutex);
+    return false;
+  }
+
+  recv_sys.lsn= last_lsn;
+  ut_ad(metadata_to_lsn);
+  metadata_last_lsn= lsn;
+
+  last_lsn= backup_wait_for_lsn_low(LSN_MAX);
+
+  metadata_last_lsn= last_lsn;
+  stop_backup_threads();
+  mysql_mutex_unlock(&recv_sys.mutex);
+  return backup_wait_timeout(lsn, last_lsn);
+}
+
 /** Implement the core of --backup
 @return	whether the operation succeeded */
 bool Backup_datasinks::backup_low()
 {
-	mysql_mutex_lock(&recv_sys.mutex);
-	ut_ad(!metadata_to_lsn);
-
-	/* read the latest checkpoint lsn */
-	{
-		const lsn_t lsn = recv_sys.lsn;
-		if (recv_sys.find_checkpoint() == DB_SUCCESS
-		    && log_sys.is_latest()) {
-			metadata_to_lsn = log_sys.next_checkpoint_lsn;
-			msg("mariabackup: The latest check point"
-			    " (for incremental): '" LSN_PF "'",
-			    metadata_to_lsn);
-		} else {
-			msg("Error: recv_sys.find_checkpoint() failed.");
-		}
-
-		recv_sys.lsn = lsn;
-		stop_backup_threads();
-	}
-
-	if (metadata_to_lsn && xtrabackup_copy_logfile()) {
-		mysql_mutex_unlock(&recv_sys.mutex);
-		ds_close(dst_log_file);
-		dst_log_file = NULL;
-		return false;
-	}
-
-	mysql_mutex_unlock(&recv_sys.mutex);
+	ut_d(mysql_mutex_lock(&recv_sys.mutex));
+	ut_ad(metadata_last_lsn);
+	ut_ad(metadata_to_lsn);
+	ut_ad(!log_copying_running);
+	ut_d(mysql_mutex_unlock(&recv_sys.mutex));
 
 	if (ds_close(dst_log_file) || !metadata_to_lsn) {
 		dst_log_file = NULL;
@@ -4777,7 +4833,7 @@ bool Backup_datasinks::backup_low()
 
 	for (uint32_t id : failed_ids) {
 		msg("mariabackup: Failed to read undo log "
-		    "tablespace space id %d and there is no undo "
+		    "tablespace space id " UINT32PF " and there is no undo "
 		    "tablespace truncation redo record.",
 		    id);
 	}
@@ -4864,17 +4920,17 @@ private:
 		// TODO: this came from the old code, where it was not thread-safe
 		// too, use separate mysql connection per thread here
 		DBUG_MARIABACKUP_EVENT("before_copy", node->space->name());
-                DBUG_EXECUTE_FOR_KEY("wait_innodb_redo_before_copy",
-                        node->space->name(),
-                        backup_wait_for_lsn(
-                                get_current_lsn(mysql_connection)););
+		DBUG_EXECUTE_FOR_KEY("wait_innodb_redo_before_copy",
+			node->space->name(),
+			backup_wait_for_lsn(
+				get_current_lsn(mysql_connection)););
 		/* copy the datafile */
 		if(xtrabackup_copy_datafile(m_backup_datasinks.m_data,
-		                            m_backup_datasinks.m_meta,
-		                            node, thread_num, NULL,
-                        xtrabackup_incremental
-                                ? wf_incremental : wf_write_through,
-                        m_corrupted_pages))
+					    m_backup_datasinks.m_meta,
+					    node, thread_num, NULL,
+			xtrabackup_incremental
+				? wf_incremental : wf_write_through,
+			m_corrupted_pages))
 			die("mariabackup: Error: failed to copy datafile.");
 		// TODO: this came from the old code, where it was not thread-safe
 		// too, use separate mysql connection per thread here
@@ -4882,8 +4938,8 @@ private:
 		m_tasks.finish_task(1);
 	}
 
-        Backup_datasinks &m_backup_datasinks;
-        CorruptedPages &m_corrupted_pages;
+	Backup_datasinks &m_backup_datasinks;
+	CorruptedPages &m_corrupted_pages;
 	TasksGroup m_tasks;
 };
 
@@ -5084,9 +5140,9 @@ class BackupStages {
 				return false;
 			}
 
-			msg("Waiting for log copy thread to read lsn %llu",
-				server_lsn_after_lock);
-			backup_wait_for_lsn(server_lsn_after_lock);
+			if (!backup_wait_for_lsn(server_lsn_after_lock)) {
+				return false;
+			}
 			corrupted_pages.backup_fix_ddl(backup_datasinks.m_data,
 			                               backup_datasinks.m_meta);
 
@@ -5122,11 +5178,28 @@ class BackupStages {
 			}
 
 			// Copy log tables tail
-			if (!m_common_backup.copy_log_tables(true)) {
+			if (!m_common_backup.copy_log_tables(true) ||
+			    !m_common_backup.close_log_tables()) {
 				msg("Error on copy log tables");
 				return false;
 			}
 
+			// Copy just enough log to cover the latest commit.
+			// Meanwhile, there could be some active transactions
+			// that are modifying the database and writing more
+			// log. Not copying log for them will save busy work
+			// and avoid some rollback of the incomplete
+			// transactions after the backup has been restored.
+			//
+			// We find the current InnoDB LSN by executing
+			// SHOW ENGINE INNODB STATUS, which in the case of
+			// general_log=1, log_output='TABLES'
+			// would be written to the table mysql.general_log
+			// that we just finished copying above.
+			if (!backup_wait_for_commit_lsn()) {
+				return false;
+			}
+
 			// Copy stats tables
 			if (!m_common_backup.copy_stats_tables()) {
 				msg("Error on copy stats tables");
@@ -5144,11 +5217,6 @@ class BackupStages {
 				return false;
 			}
 
-			if (!m_common_backup.close_log_tables()) {
-				msg("Error on close log tables");
-				return false;
-			}
-
                         if (!backup_files_from_datadir(backup_datasinks.m_data,
                                                        fil_path_to_mysql_datadir,
                                                        "aws-kms-key")) {
@@ -5290,13 +5358,14 @@ static bool xtrabackup_backup_func()
 	undo_space_trunc = backup_undo_trunc;
 	first_page_init = backup_first_page_op;
 	metadata_to_lsn = 0;
+	metadata_last_lsn = 0;
 
 	/* initialize components */
         if(innodb_init_param()) {
 fail:
 		if (log_copying_running) {
 			mysql_mutex_lock(&recv_sys.mutex);
-			metadata_to_lsn = 1;
+			metadata_last_lsn = 1;
 			stop_backup_threads();
 			mysql_mutex_unlock(&recv_sys.mutex);
 		}
@@ -5481,14 +5550,9 @@ fail:
 
 	xb_data_files_close();
 
-	/* Make sure that the latest checkpoint was included */
-	if (metadata_to_lsn > recv_sys.lsn) {
-		msg("Error: failed to copy enough redo log ("
-		    "LSN=" LSN_PF "; checkpoint LSN=" LSN_PF ").",
-		    recv_sys.lsn, metadata_to_lsn);
-		goto fail;
-	}
-
+	ut_ad(!log_copying_running);
+	ut_ad(metadata_to_lsn <= recv_sys.lsn);
+	ut_ad(metadata_last_lsn == recv_sys.lsn);
 	innodb_shutdown();
 	log_file_op = NULL;
 	undo_space_trunc = NULL;
diff --git a/include/my_cpu.h b/include/my_cpu.h
index e536ff285f9..003087dd94d 100644
--- a/include/my_cpu.h
+++ b/include/my_cpu.h
@@ -24,6 +24,7 @@
 */
 
 #ifdef _ARCH_PWR8
+#ifdef __GLIBC__
 #include <sys/platform/ppc.h>
 /* Very low priority */
 #define HMT_very_low() __ppc_set_ppr_very_low()
@@ -37,6 +38,18 @@
 #define HMT_medium_high() __ppc_set_ppr_med_high()
 /* High priority */
 #define HMT_high() asm volatile("or 3,3,3")
+#else /* GLIBC */
+#if defined(__FreeBSD__)
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#endif
+#define HMT_very_low() __asm__ volatile ("or 31,31,31")
+#define HMT_low() __asm__ volatile ("or 1,1,1")
+#define HMT_medium_low() __asm__ volatile ("or 6,6,6")
+#define HMT_medium() __asm__ volatile ("or 2,2,2")
+#define HMT_medium_high() __asm__ volatile ("or 5,5,5")
+#define HMT_high() asm volatile("or 3,3,3")
+#endif /* GLIBC */
 #else
 #define HMT_very_low()
 #define HMT_low()
@@ -81,7 +94,13 @@ static inline void MY_RELAX_CPU(void)
   __asm__ __volatile__ ("pause");
 #endif
 #elif defined(_ARCH_PWR8)
-  __ppc_get_timebase();
+#ifdef __FreeBSD__
+  uint64_t __tb;
+  __asm__ volatile ("mfspr %0, 268" : "=r" (__tb));
+#else
+  /* Changed from __ppc_get_timebase for musl compatibility */
+  __builtin_ppc_get_timebase();
+#endif
 #elif defined __GNUC__ && (defined __arm__ || defined __aarch64__)
   /* Mainly, prevent the compiler from optimizing away delay loops */
   __asm__ __volatile__ ("":::"memory");
diff --git a/mysql-test/include/optimizer_trace_no_costs.inc b/mysql-test/include/optimizer_trace_no_costs.inc
new file mode 100644
index 00000000000..540ce06e685
--- /dev/null
+++ b/mysql-test/include/optimizer_trace_no_costs.inc
@@ -0,0 +1,11 @@
+# Mask the cost value from any field that looks like
+#  "xxx_cost" : double_number
+# Print the
+#  "xxx_cost" : "REPLACED"
+# instead
+--replace_regex /(_cost": )[0-9.e-]+/\1"REPLACED"/
+#--replace_regex /(_cost": )[0-9.e-]+/"REPLACED"/
+#--replace_regex /[0-9]+/BBB/
+
+#--replace_regex /("r_engine_stats":) {[^}]*}/\1 REPLACED/
+
diff --git a/mysql-test/main/join.result b/mysql-test/main/join.result
index b1d7e155621..71144786f83 100644
--- a/mysql-test/main/join.result
+++ b/mysql-test/main/join.result
@@ -3508,6 +3508,74 @@ SET OPTIMIZER_USE_CONDITION_SELECTIVITY=@tmp;
 DROP TABLE t1,t2;
 # End of 10.6 tests
 #
+# MDEV-34894: Poor query plan, because range estimates are not reused for ref(const)
+#
+create table t0 (
+a int,
+b int,
+dummy int
+);
+insert into t0 select seq,seq,seq from seq_1_to_10;
+create table t1 (
+pk1 int,
+pk2 int,
+pk3 int,
+key1 int,
+key(key1),
+filler char(100),
+primary key(pk1,pk2,pk3)
+);
+insert into t1
+select
+seq, seq, seq,
+FLOOR(seq/2),
+'filler-data'
+from seq_1_to_10000;
+analyze table t1;
+Table	Op	Msg_type	Msg_text
+test.t1	analyze	status	Engine-independent statistics collected
+test.t1	analyze	status	OK
+update t1 set pk1=1 where pk1 between 1 and 200;
+explain select * from t1 where pk1=1;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	ref	PRIMARY	PRIMARY	4	const	231	
+explain select * from t0,t1 where t1.pk1=t0.a;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t0	ALL	NULL	NULL	NULL	NULL	10	Using where
+1	SIMPLE	t1	ref	PRIMARY	PRIMARY	4	test.t0.a	1	
+create table t2 (
+col int
+);
+insert into t2 select seq from seq_1_to_10000;
+# This must use this good query plan:
+#  t0 - ALL
+#  t1 - ref, key=key1, not PRIMARY as pk1=1 is true for 20% of all rows
+#  t2 - ALL
+explain select * from t0, t1, t2
+where
+t1.pk1=1 and t1.pk2=t2.col and t1.pk3=t0.dummy and
+t1.key1=t0.b;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t0	ALL	NULL	NULL	NULL	NULL	10	Using where
+1	SIMPLE	t1	ref	PRIMARY,key1	key1	5	test.t0.b	1	Using where
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	10000	Using where; Using join buffer (flat, BNL join)
+drop table t0,t1,t2;
+CREATE OR REPLACE TABLE t1 (a INT NOT NULL, b INT NOT NULL, c INT, key(a,b,c)) ENGINE=Aria;
+INSERT INTO t1 select seq/10,mod(seq,2),seq from seq_1_to_1000;
+update t1 set a=10 WHERE c < 100;
+update t1 set a=12 WHERE a=11;
+insert into t1 values (11,1,11), (11,2,11);
+create or replace table t2 select seq from seq_1_to_10;
+explain select count(*) from t1, t2 as seq where a=10 and b=seq.seq;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	seq	ALL	NULL	NULL	NULL	NULL	10	
+1	SIMPLE	t1	ref	a	a	8	const,test.seq.seq	5	Using where; Using index
+explain select count(*) from t1, t2 as seq where a=11 and b=seq.seq;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	ref	a	a	4	const	2	Using index
+1	SIMPLE	seq	ALL	NULL	NULL	NULL	NULL	10	Using where; Using join buffer (flat, BNL join)
+drop table t1,t2;
+#
 # MDEV-30256 Wrong result (missing rows) upon join with empty table
 #
 CREATE TABLE t1 (a INT);
diff --git a/mysql-test/main/join.test b/mysql-test/main/join.test
index 7a8c6a09732..cbec4614da8 100644
--- a/mysql-test/main/join.test
+++ b/mysql-test/main/join.test
@@ -1909,6 +1909,70 @@ SET OPTIMIZER_USE_CONDITION_SELECTIVITY=@tmp;
 DROP TABLE t1,t2;
 --echo # End of 10.6 tests
 
+--source include/have_sequence.inc
+
+--echo #
+--echo # MDEV-34894: Poor query plan, because range estimates are not reused for ref(const)
+--echo #
+create table t0 (
+  a int,
+  b int,
+  dummy int
+);
+insert into t0 select seq,seq,seq from seq_1_to_10;
+
+create table t1 (
+  pk1 int,
+  pk2 int,
+  pk3 int,
+  key1 int,
+  key(key1),
+  filler char(100),
+  primary key(pk1,pk2,pk3)
+);
+
+insert into t1
+select
+  seq, seq, seq,
+  FLOOR(seq/2),
+  'filler-data'
+from seq_1_to_10000;
+analyze table t1;
+
+update t1 set pk1=1 where pk1 between 1 and 200;
+
+explain select * from t1 where pk1=1;
+
+explain select * from t0,t1 where t1.pk1=t0.a;
+
+create table t2 (
+ col int
+);
+insert into t2 select seq from seq_1_to_10000;
+
+--echo # This must use this good query plan:
+--echo #  t0 - ALL
+--echo #  t1 - ref, key=key1, not PRIMARY as pk1=1 is true for 20% of all rows
+--echo #  t2 - ALL
+explain select * from t0, t1, t2
+where
+  t1.pk1=1 and t1.pk2=t2.col and t1.pk3=t0.dummy and
+  t1.key1=t0.b;
+
+drop table t0,t1,t2;
+
+CREATE OR REPLACE TABLE t1 (a INT NOT NULL, b INT NOT NULL, c INT, key(a,b,c)) ENGINE=Aria;
+INSERT INTO t1 select seq/10,mod(seq,2),seq from seq_1_to_1000;
+update t1 set a=10 WHERE c < 100;
+update t1 set a=12 WHERE a=11;
+insert into t1 values (11,1,11), (11,2,11);
+create or replace table t2 select seq from seq_1_to_10;
+
+explain select count(*) from t1, t2 as seq where a=10 and b=seq.seq;
+# This will execute code in ReuseRangeEstimateForRef-4
+explain select count(*) from t1, t2 as seq where a=11 and b=seq.seq;
+drop table t1,t2;
+
 --echo #
 --echo # MDEV-30256 Wrong result (missing rows) upon join with empty table
 --echo #
diff --git a/mysql-test/main/join_outer_innodb.result b/mysql-test/main/join_outer_innodb.result
index dbbbe89944b..7f54d2a3677 100644
--- a/mysql-test/main/join_outer_innodb.result
+++ b/mysql-test/main/join_outer_innodb.result
@@ -447,9 +447,9 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t12	eq_ref	PRIMARY	PRIMARY	4	test.t11.k3	1	Using where
 1	SIMPLE	l2	eq_ref	PRIMARY	PRIMARY	4	test.t11.k4	1	Using where
 1	SIMPLE	t9	ref	PRIMARY	PRIMARY	1	test.t1.a4	1	
-1	SIMPLE	t13	ref	PRIMARY,m3	m3	8	const,test.t1.a1	3	Using index
+1	SIMPLE	t13	ref	PRIMARY,m3	m3	8	const,test.t1.a1	1	Using index
 1	SIMPLE	l4	eq_ref	PRIMARY	PRIMARY	4	test.t13.m2	1	Using where
-1	SIMPLE	m2	ref	PRIMARY,m3	m3	8	const,test.t1.a1	3	Using index
+1	SIMPLE	m2	ref	PRIMARY,m3	m3	8	const,test.t1.a1	1	Using index
 1	SIMPLE	l3	eq_ref	PRIMARY	PRIMARY	4	test.m2.m2	1	Using where
 1	SIMPLE	t14	eq_ref	PRIMARY	PRIMARY	2	test.t1.a8	1	Using where
 1	SIMPLE	t15	eq_ref	PRIMARY	PRIMARY	2	test.t1.a9	1	Using where
@@ -469,9 +469,9 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t12	eq_ref	PRIMARY	PRIMARY	4	test.t11.k3	1	Using where
 1	SIMPLE	l2	eq_ref	PRIMARY	PRIMARY	4	test.t11.k4	1	Using where
 1	SIMPLE	t9	ref	PRIMARY	PRIMARY	1	test.t1.a4	1	
-1	SIMPLE	t13	ref	PRIMARY,m3	m3	8	const,test.t1.a1	3	Using index
+1	SIMPLE	t13	ref	PRIMARY,m3	m3	8	const,test.t1.a1	1	Using index
 1	SIMPLE	l4	eq_ref	PRIMARY	PRIMARY	4	test.t13.m2	1	Using where
-1	SIMPLE	m2	ref	PRIMARY,m3	m3	8	const,test.t1.a1	3	Using index
+1	SIMPLE	m2	ref	PRIMARY,m3	m3	8	const,test.t1.a1	1	Using index
 1	SIMPLE	l3	eq_ref	PRIMARY	PRIMARY	4	test.m2.m2	1	Using where
 1	SIMPLE	t14	eq_ref	PRIMARY	PRIMARY	2	test.t1.a8	1	Using where
 1	SIMPLE	t15	eq_ref	PRIMARY	PRIMARY	2	test.t1.a9	1	Using where
diff --git a/mysql-test/main/order_by_limit_join.result b/mysql-test/main/order_by_limit_join.result
index bdfce0915b2..ed3f20e87f7 100644
--- a/mysql-test/main/order_by_limit_join.result
+++ b/mysql-test/main/order_by_limit_join.result
@@ -81,8 +81,8 @@ JS
                     "clause": "ORDER BY",
                     "table": "t1",
                     "rows_estimation": 10000,
-                    "filesort_cost": 0.205030632,
-                    "read_cost": 1.791376632,
+                    "filesort_cost": "REPLACED",
+                    "read_cost": "REPLACED",
                     "filesort_type": "priority_queue with row lookup",
                     "fanout": 1,
                     "possible_keys": 
@@ -103,7 +103,7 @@ JS
                             "direction": 1,
                             "rows_to_examine": 10,
                             "range_scan": false,
-                            "scan_cost": 0.013129232,
+                            "scan_cost": "REPLACED",
                             "chosen": true
                         }
                     ]
@@ -111,9 +111,9 @@ JS
             }
         ],
         "can_skip_filesort": true,
-        "full_join_cost": 37.9789756,
+        "full_join_cost": "REPLACED",
         "risk_ratio": 10,
-        "shortcut_join_cost": 0.049201862,
+        "shortcut_join_cost": "REPLACED",
         "shortcut_cost_with_risk": 0.492018616,
         "use_shortcut_cost": true
     }
@@ -163,9 +163,9 @@ JS
         "test_if_skip_sort_order_early": 
         [],
         "can_skip_filesort": false,
-        "full_join_cost": 37.9789756,
+        "full_join_cost": "REPLACED",
         "risk_ratio": 10,
-        "shortcut_join_cost": 1.94241863,
+        "shortcut_join_cost": "REPLACED",
         "shortcut_cost_with_risk": 19.4241863,
         "use_shortcut_cost": true
     }
@@ -220,8 +220,8 @@ JS
                     "clause": "ORDER BY",
                     "table": "t1",
                     "rows_estimation": 10000,
-                    "filesort_cost": 1.070467741,
-                    "read_cost": 2.656813741,
+                    "filesort_cost": "REPLACED",
+                    "read_cost": "REPLACED",
                     "filesort_type": "merge_sort with addon fields",
                     "fanout": 1,
                     "possible_keys": 
@@ -242,7 +242,7 @@ JS
                             "direction": 1,
                             "rows_to_examine": 5000,
                             "range_scan": false,
-                            "scan_cost": 6.174703142,
+                            "scan_cost": "REPLACED",
                             "usable": false,
                             "cause": "cost"
                         }
@@ -251,9 +251,9 @@ JS
             }
         ],
         "can_skip_filesort": false,
-        "full_join_cost": 37.9789756,
+        "full_join_cost": "REPLACED",
         "risk_ratio": 10,
-        "shortcut_join_cost": 19.9426608,
+        "shortcut_join_cost": "REPLACED",
         "shortcut_cost_with_risk": 199.426608,
         "use_shortcut_cost": false
     }
@@ -342,8 +342,8 @@ JS
                     "clause": "ORDER BY",
                     "table": "t1",
                     "rows_estimation": 10000,
-                    "filesort_cost": 0.205030632,
-                    "read_cost": 1.791376632,
+                    "filesort_cost": "REPLACED",
+                    "read_cost": "REPLACED",
                     "filesort_type": "priority_queue with row lookup",
                     "fanout": 1,
                     "possible_keys": 
@@ -364,7 +364,7 @@ JS
                             "direction": 1,
                             "rows_to_examine": 10,
                             "range_scan": false,
-                            "scan_cost": 0.013129232,
+                            "scan_cost": "REPLACED",
                             "chosen": true
                         }
                     ]
@@ -372,9 +372,9 @@ JS
             }
         ],
         "can_skip_filesort": true,
-        "full_join_cost": 42.02203018,
+        "full_join_cost": "REPLACED",
         "risk_ratio": 10,
-        "shortcut_join_cost": 0.053244916,
+        "shortcut_join_cost": "REPLACED",
         "shortcut_cost_with_risk": 0.532449162,
         "use_shortcut_cost": true
     }
@@ -430,8 +430,8 @@ JS
                     "clause": "ORDER BY",
                     "table": "t1",
                     "rows_estimation": 10000,
-                    "filesort_cost": 0.205030632,
-                    "read_cost": 1.791376632,
+                    "filesort_cost": "REPLACED",
+                    "read_cost": "REPLACED",
                     "filesort_type": "priority_queue with row lookup",
                     "fanout": 1,
                     "possible_keys": 
@@ -452,7 +452,7 @@ JS
                             "direction": 1,
                             "rows_to_examine": 10,
                             "range_scan": false,
-                            "scan_cost": 0.013129232,
+                            "scan_cost": "REPLACED",
                             "chosen": true
                         }
                     ]
@@ -460,9 +460,9 @@ JS
             }
         ],
         "can_skip_filesort": true,
-        "full_join_cost": 37.9789756,
+        "full_join_cost": "REPLACED",
         "risk_ratio": 10,
-        "shortcut_join_cost": 0.049201862,
+        "shortcut_join_cost": "REPLACED",
         "shortcut_cost_with_risk": 0.492018616,
         "use_shortcut_cost": true
     }
diff --git a/mysql-test/main/order_by_limit_join.test b/mysql-test/main/order_by_limit_join.test
index 6e695ecb58a..f6fbb8d2ad4 100644
--- a/mysql-test/main/order_by_limit_join.test
+++ b/mysql-test/main/order_by_limit_join.test
@@ -68,6 +68,7 @@ set optimizer_join_limit_pref_ratio=10;
 eval $query;
 
 set @trace=(select trace from information_schema.optimizer_trace);
+--source include/optimizer_trace_no_costs.inc
 select json_detailed(json_extract(@trace, '$**.join_limit_shortcut_choice')) as JS;
 
 --echo #
@@ -95,6 +96,7 @@ set optimizer_join_limit_pref_ratio=10;
 eval $query;
 
 set @trace=(select trace from information_schema.optimizer_trace);
+--source include/optimizer_trace_no_costs.inc
 select json_detailed(json_extract(@trace, '$**.join_limit_shortcut_choice')) as JS;
 
 --echo #
@@ -121,6 +123,7 @@ set optimizer_join_limit_pref_ratio=10;
 eval $query;
 
 set @trace=(select trace from information_schema.optimizer_trace);
+--source include/optimizer_trace_no_costs.inc
 select json_detailed(json_extract(@trace, '$**.join_limit_shortcut_choice')) as JS;
 
 --echo #
@@ -140,6 +143,7 @@ limit 10;
 set @trace=(select trace from information_schema.optimizer_trace);
 --echo # This will show nothing as limit shortcut code figures that
 --echo #   it's not possible to use t1 to construct shortcuts:
+--source include/optimizer_trace_no_costs.inc
 select json_detailed(json_extract(@trace, '$**.join_limit_shortcut_choice')) as JS;
 
 --echo #
@@ -169,6 +173,7 @@ set optimizer_join_limit_pref_ratio=10;
 eval $query;
 
 set @trace=(select trace from information_schema.optimizer_trace);
+--source include/optimizer_trace_no_costs.inc
 select json_detailed(json_extract(@trace, '$**.join_limit_shortcut_choice')) as JS;
 
 --echo #
@@ -197,6 +202,7 @@ set optimizer_join_limit_pref_ratio=10;
 eval $query;
 
 set @trace=(select trace from information_schema.optimizer_trace);
+--source include/optimizer_trace_no_costs.inc
 select json_detailed(json_extract(@trace, '$**.join_limit_shortcut_choice')) as JS;
 
 
diff --git a/mysql-test/main/ps_mem_leaks.result b/mysql-test/main/ps_mem_leaks.result
index 95a1f317ae0..0e867ef0ea8 100644
--- a/mysql-test/main/ps_mem_leaks.result
+++ b/mysql-test/main/ps_mem_leaks.result
@@ -90,6 +90,243 @@ DEALLOCATE PREPARE stmt;
 DROP TABLE t1;
 # End of 10.4 tests
 #
+# MDEV-34447: Memory leakage is detected on running the test main.ps against the server 11.1
+#
+CREATE TABLE t1 (id INT, value INT);
+CREATE TABLE t2 (id INT);
+PREPARE stmt FROM 'UPDATE t1 SET value = (SELECT 1 FROM t2 WHERE id = t1.id)';
+EXECUTE stmt;
+INSERT INTO t1 VALUES (1,10),(2,10),(3,10);
+INSERT INTO t2 VALUES (1),(2);
+EXECUTE stmt;
+SELECT * FROM t1;
+id	value
+1	1
+2	1
+3	NULL
+DEALLOCATE PREPARE stmt;
+DROP TABLE t1, t2;
+# Memory leak also could take place on running the DELETE statement
+# with the LIMIT clause. Check it.
+CREATE TABLE t1 (c1 INT);
+INSERT INTO t1 (c1) VALUES (1), (2), (3);
+CREATE PROCEDURE p1(p1 INT)
+DELETE FROM t1 LIMIT p1;
+CALL p1(0);
+CALL p1(1);
+CALL p1(2);
+# Clean up
+DROP TABLE t1;
+DROP PROCEDURE p1;
+#
+# MDEV-34757: assertion of (mem_root->flags & 4) == 0 fails in 2nd ps execution with partition pruning
+#
+CREATE TABLE t1 (id INT, value INT);
+CREATE TABLE t2 (id INT);
+PREPARE stmt FROM 'EXPLAIN UPDATE t1 SET value = (SELECT 1 FROM t2 WHERE id = t1.id)';
+EXECUTE stmt;
+INSERT INTO t1 VALUES (1,10),(2,10),(3,10);
+INSERT INTO t2 VALUES (1),(2);
+EXECUTE stmt;
+SELECT * FROM t1;
+id	value
+1	10
+2	10
+3	10
+DEALLOCATE PREPARE stmt;
+DROP TABLE t1, t2;
+set @var1=5;
+set @var2=4;
+create table t1 (a int) partition by list(a) (
+partition p0 values in (null,1,2),
+partition p1 values in (3,4)
+);
+create table t2 (a int);
+insert into t1 values (1),(2),(3),(4);
+insert into t2 values (4);
+PREPARE stmt FROM 'UPDATE t1 t1 SET a = (SELECT 1 FROM t2 WHERE a = t1.a) where a = ?';
+execute stmt using @var1;
+select * from t1;
+a
+1
+2
+3
+4
+execute stmt using @var2;
+select * from t1;
+a
+1
+2
+1
+3
+deallocate prepare stmt;
+drop table t1, t2;
+set @var1=5;
+set @var2=4;
+create table t1 (a int) partition by list(a) (
+partition p0 values in (null,1,2),
+partition p1 values in (3,4)
+);
+create table t2 (a int);
+insert into t1 values (1),(2),(3),(4);
+insert into t2 values (4);
+PREPARE stmt FROM 'EXPLAIN UPDATE t1 t1 SET a = (SELECT 1 FROM t2 WHERE a = t1.a) where a = ?';
+execute stmt using @var1;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	NULL	NULL	NULL	NULL	NULL	NULL	NULL	No matching rows after partition pruning
+select * from t1;
+a
+1
+2
+3
+4
+execute stmt using @var2;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	PRIMARY	t1	ALL	NULL	NULL	NULL	NULL	2	Using where; Using buffer
+2	DEPENDENT SUBQUERY	t2	system	NULL	NULL	NULL	NULL	1	
+select * from t1;
+a
+1
+2
+3
+4
+deallocate prepare stmt;
+drop table t1, t2;
+set @var1=1;
+set @var2=2;
+CREATE TABLE t1 ( id INT(10), value INT(10) );
+CREATE TABLE t2 ( id INT(10) );
+insert into t1 values (1,10),(2,10),(3,10);
+insert into t2 values (1),(2);
+PREPARE stmt FROM 'UPDATE t1 t1 SET value = (SELECT 1 FROM t2 WHERE id = t1.id) WHERE  ?=?';
+execute stmt using @var1, @var2;
+execute stmt using @var1, @var1;
+deallocate prepare stmt;
+DROP TABLE t1,t2;
+set @var1=1;
+set @var2=2;
+CREATE TABLE t1 ( id INT(10), value INT(10) );
+CREATE TABLE t2 ( id INT(10) );
+insert into t1 values (1,10),(2,10),(3,10);
+insert into t2 values (1),(2);
+PREPARE stmt FROM 'EXPLAIN UPDATE t1 t1 SET value = (SELECT 1 FROM t2 WHERE id = t1.id) WHERE  ?=?';
+execute stmt using @var1, @var2;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible WHERE
+execute stmt using @var1, @var1;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	PRIMARY	t1	ALL	NULL	NULL	NULL	NULL	3	
+2	DEPENDENT SUBQUERY	t2	ALL	NULL	NULL	NULL	NULL	2	Using where
+deallocate prepare stmt;
+DROP TABLE t1,t2;
+CREATE TABLE t1 (c1 INT);
+INSERT INTO t1 (c1) VALUES (1), (2), (3);
+CREATE PROCEDURE p1(p1 INT)
+EXPLAIN DELETE FROM t1 LIMIT p1;
+CALL p1(0);
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible WHERE
+CALL p1(1);
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	ALL	NULL	NULL	NULL	NULL	3	
+CALL p1(2);
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	ALL	NULL	NULL	NULL	NULL	3	
+# Clean up
+DROP TABLE t1;
+DROP PROCEDURE p1;
+set @var1=5;
+set @var2=4;
+create table t1 (a int) partition by list(a) (
+partition p0 values in (1,2),
+partition p1 values in (3,4)
+);
+create table t2 (a int);
+insert into t1 values (1),(2),(3),(4);
+insert into t2 values (4);
+PREPARE stmt FROM 'DELETE FROM t1 where a = ?';
+execute stmt using @var1;
+select * from t1;
+a
+1
+2
+3
+4
+execute stmt using @var2;
+select * from t1;
+a
+1
+2
+3
+deallocate prepare stmt;
+drop table t1, t2;
+set @var1=5;
+set @var2=4;
+create table t1 (a int) partition by list(a) (
+partition p0 values in (1,2),
+partition p1 values in (3,4)
+);
+create table t2 (a int);
+insert into t1 values (1),(2),(3),(4);
+insert into t2 values (4);
+PREPARE stmt FROM 'EXPLAIN DELETE FROM t1 where a = ?';
+execute stmt using @var1;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	NULL	NULL	NULL	NULL	NULL	NULL	NULL	No matching rows after partition pruning
+select * from t1;
+a
+1
+2
+3
+4
+execute stmt using @var2;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	ALL	NULL	NULL	NULL	NULL	2	Using where
+select * from t1;
+a
+1
+2
+3
+4
+deallocate prepare stmt;
+drop table t1, t2;
+set @var1=1;
+set @var2=2;
+CREATE TABLE t1 ( id INT(10), value INT(10) );
+CREATE TABLE t2 ( id INT(10) );
+insert into t1 values (1,10),(2,10),(3,10);
+insert into t2 values (1),(2);
+PREPARE stmt FROM 'DELETE FROM t1 WHERE  ?=?';
+execute stmt using @var1, @var2;
+execute stmt using @var1, @var1;
+deallocate prepare stmt;
+DROP TABLE t1,t2;
+set @var1=1;
+set @var2=2;
+CREATE TABLE t1 ( id INT(10), value INT(10) );
+CREATE TABLE t2 ( id INT(10) );
+insert into t1 values (1,10),(2,10),(3,10);
+insert into t2 values (1),(2);
+PREPARE stmt FROM 'EXPLAIN DELETE FROM t1 WHERE  ?=?';
+execute stmt using @var1, @var2;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible WHERE
+execute stmt using @var1, @var1;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	NULL	NULL	NULL	NULL	NULL	NULL	3	Deleting all rows
+deallocate prepare stmt;
+DROP TABLE t1,t2;
+#
+# MDEV-33858: Assertion `(mem_root->flags & 4) == 0' fails on 2nd execution of PS with -DWITH_PROTECT_STATEMENT_MEMROOT=ON
+#
+CREATE TABLE t (a INT);
+INSERT INTO t VALUES (1),(2);
+PREPARE stmt FROM "UPDATE t SET a = 0 LIMIT ?";
+EXECUTE stmt USING 0;
+EXECUTE stmt USING 1;
+DROP TABLE t;
+# End of 10.5 tests
+#
 # MDEV-33769: Memory leak found in the test main.rownum run with --ps-protocol against a server built with the option -DWITH_PROTECT_STATEMENT_MEMROOT
 #
 CREATE OR REPLACE TABLE t1(a INT);
diff --git a/mysql-test/main/ps_mem_leaks.test b/mysql-test/main/ps_mem_leaks.test
index 951bc7e337a..bedd4e2d939 100644
--- a/mysql-test/main/ps_mem_leaks.test
+++ b/mysql-test/main/ps_mem_leaks.test
@@ -5,6 +5,7 @@
 # The cmake  option -DWITH_PROTECT_STATEMENT_MEMROOT is used only
 # for debug build
 --source include/have_debug.inc
+--source include/have_partition.inc
 
 --echo #
 --echo # MDEV-32369: Memory leak when executing PS for query with IN subquery
@@ -111,6 +112,219 @@ DROP TABLE t1;
 
 --echo # End of 10.4 tests
 
+--echo #
+--echo # MDEV-34447: Memory leakage is detected on running the test main.ps against the server 11.1
+--echo #
+CREATE TABLE t1 (id INT, value INT);
+CREATE TABLE t2 (id INT);
+
+PREPARE stmt FROM 'UPDATE t1 SET value = (SELECT 1 FROM t2 WHERE id = t1.id)';
+EXECUTE stmt;
+INSERT INTO t1 VALUES (1,10),(2,10),(3,10);
+INSERT INTO t2 VALUES (1),(2);
+EXECUTE stmt;
+SELECT * FROM t1;
+DEALLOCATE PREPARE stmt;
+DROP TABLE t1, t2;
+
+--echo # Memory leak also could take place on running the DELETE statement
+--echo # with the LIMIT clause. Check it.
+CREATE TABLE t1 (c1 INT);
+INSERT INTO t1 (c1) VALUES (1), (2), (3);
+
+CREATE PROCEDURE p1(p1 INT)
+  DELETE FROM t1 LIMIT p1;
+
+CALL p1(0);
+CALL p1(1);
+CALL p1(2);
+
+--echo # Clean up
+DROP TABLE t1;
+DROP PROCEDURE p1;
+
+--echo #
+--echo # MDEV-34757: assertion of (mem_root->flags & 4) == 0 fails in 2nd ps execution with partition pruning
+--echo #
+# same as the first MDEV-34444 testcase but with explain
+CREATE TABLE t1 (id INT, value INT);
+CREATE TABLE t2 (id INT);
+
+PREPARE stmt FROM 'EXPLAIN UPDATE t1 SET value = (SELECT 1 FROM t2 WHERE id = t1.id)';
+# we are testing 2nd ps assertion failure, not explain output, which
+# may vary from version to version
+--disable_result_log
+EXECUTE stmt;
+--enable_result_log
+INSERT INTO t1 VALUES (1,10),(2,10),(3,10);
+INSERT INTO t2 VALUES (1),(2);
+--disable_result_log
+EXECUTE stmt;
+--enable_result_log
+SELECT * FROM t1;
+DEALLOCATE PREPARE stmt;
+DROP TABLE t1, t2;
+
+# 2nd ps mem leak; partition pruning
+set @var1=5;
+set @var2=4;
+create table t1 (a int) partition by list(a) (
+  partition p0 values in (null,1,2),
+  partition p1 values in (3,4)
+);
+create table t2 (a int);
+insert into t1 values (1),(2),(3),(4);
+insert into t2 values (4);
+PREPARE stmt FROM 'UPDATE t1 t1 SET a = (SELECT 1 FROM t2 WHERE a = t1.a) where a = ?';
+execute stmt using @var1;
+select * from t1;
+execute stmt using @var2;
+select * from t1;
+deallocate prepare stmt;
+drop table t1, t2;
+
+# same but with explain
+set @var1=5;
+set @var2=4;
+create table t1 (a int) partition by list(a) (
+  partition p0 values in (null,1,2),
+  partition p1 values in (3,4)
+);
+create table t2 (a int);
+insert into t1 values (1),(2),(3),(4);
+insert into t2 values (4);
+PREPARE stmt FROM 'EXPLAIN UPDATE t1 t1 SET a = (SELECT 1 FROM t2 WHERE a = t1.a) where a = ?';
+execute stmt using @var1;
+select * from t1;
+execute stmt using @var2;
+select * from t1;
+deallocate prepare stmt;
+drop table t1, t2;
+
+# top level impossible where
+set @var1=1;
+set @var2=2;
+CREATE TABLE t1 ( id INT(10), value INT(10) );
+CREATE TABLE t2 ( id INT(10) );
+insert into t1 values (1,10),(2,10),(3,10);
+insert into t2 values (1),(2);
+
+PREPARE stmt FROM 'UPDATE t1 t1 SET value = (SELECT 1 FROM t2 WHERE id = t1.id) WHERE  ?=?';
+execute stmt using @var1, @var2;
+execute stmt using @var1, @var1;
+deallocate prepare stmt;
+DROP TABLE t1,t2;
+
+# top level impossible where, with explain
+set @var1=1;
+set @var2=2;
+CREATE TABLE t1 ( id INT(10), value INT(10) );
+CREATE TABLE t2 ( id INT(10) );
+insert into t1 values (1,10),(2,10),(3,10);
+insert into t2 values (1),(2);
+
+PREPARE stmt FROM 'EXPLAIN UPDATE t1 t1 SET value = (SELECT 1 FROM t2 WHERE id = t1.id) WHERE  ?=?';
+execute stmt using @var1, @var2;
+execute stmt using @var1, @var1;
+deallocate prepare stmt;
+DROP TABLE t1,t2;
+
+# Now we do delete instead of update
+
+# same as the second MDEV-34447 testcase but with explain
+CREATE TABLE t1 (c1 INT);
+INSERT INTO t1 (c1) VALUES (1), (2), (3);
+
+CREATE PROCEDURE p1(p1 INT)
+  EXPLAIN DELETE FROM t1 LIMIT p1;
+
+CALL p1(0);
+CALL p1(1);
+CALL p1(2);
+
+--echo # Clean up
+DROP TABLE t1;
+DROP PROCEDURE p1;
+
+# partition pruning
+set @var1=5;
+set @var2=4;
+create table t1 (a int) partition by list(a) (
+  partition p0 values in (1,2),
+  partition p1 values in (3,4)
+);
+create table t2 (a int);
+insert into t1 values (1),(2),(3),(4);
+insert into t2 values (4);
+PREPARE stmt FROM 'DELETE FROM t1 where a = ?';
+execute stmt using @var1;
+select * from t1;
+execute stmt using @var2;
+select * from t1;
+deallocate prepare stmt;
+drop table t1, t2;
+
+# same but with explain
+set @var1=5;
+set @var2=4;
+create table t1 (a int) partition by list(a) (
+  partition p0 values in (1,2),
+  partition p1 values in (3,4)
+);
+create table t2 (a int);
+insert into t1 values (1),(2),(3),(4);
+insert into t2 values (4);
+PREPARE stmt FROM 'EXPLAIN DELETE FROM t1 where a = ?';
+execute stmt using @var1;
+select * from t1;
+execute stmt using @var2;
+select * from t1;
+deallocate prepare stmt;
+drop table t1, t2;
+
+# top level impossible where
+set @var1=1;
+set @var2=2;
+CREATE TABLE t1 ( id INT(10), value INT(10) );
+CREATE TABLE t2 ( id INT(10) );
+insert into t1 values (1,10),(2,10),(3,10);
+insert into t2 values (1),(2);
+
+PREPARE stmt FROM 'DELETE FROM t1 WHERE  ?=?';
+execute stmt using @var1, @var2;
+execute stmt using @var1, @var1;
+deallocate prepare stmt;
+DROP TABLE t1,t2;
+
+# top level impossible where, with explain
+set @var1=1;
+set @var2=2;
+CREATE TABLE t1 ( id INT(10), value INT(10) );
+CREATE TABLE t2 ( id INT(10) );
+insert into t1 values (1,10),(2,10),(3,10);
+insert into t2 values (1),(2);
+
+PREPARE stmt FROM 'EXPLAIN DELETE FROM t1 WHERE  ?=?';
+execute stmt using @var1, @var2;
+execute stmt using @var1, @var1;
+deallocate prepare stmt;
+DROP TABLE t1,t2;
+
+--echo #
+--echo # MDEV-33858: Assertion `(mem_root->flags & 4) == 0' fails on 2nd execution of PS with -DWITH_PROTECT_STATEMENT_MEMROOT=ON
+--echo #
+
+CREATE TABLE t (a INT);
+INSERT INTO t VALUES (1),(2); # Optional, fails either way
+PREPARE stmt FROM "UPDATE t SET a = 0 LIMIT ?";
+EXECUTE stmt USING 0;
+EXECUTE stmt USING 1;
+
+# CLeanup
+DROP TABLE t;
+
+--echo # End of 10.5 tests
+
 --echo #
 --echo # MDEV-33769: Memory leak found in the test main.rownum run with --ps-protocol against a server built with the option -DWITH_PROTECT_STATEMENT_MEMROOT
 --echo #
diff --git a/mysql-test/main/show_check.result b/mysql-test/main/show_check.result
index 30637e12ca0..9cbf1d19716 100644
--- a/mysql-test/main/show_check.result
+++ b/mysql-test/main/show_check.result
@@ -66,7 +66,7 @@ Catalog	Database	Table	Table_alias	Column	Column_alias	Type	Length	Max length	Is
 def	information_schema	STATISTICS	STATISTICS	TABLE_NAME	Table	253	64	2	N	4097	0	8
 def	information_schema	STATISTICS	STATISTICS	NON_UNIQUE	Non_unique	8	1	1	N	36865	0	63
 def	information_schema	STATISTICS	STATISTICS	INDEX_NAME	Key_name	253	64	7	N	4097	0	8
-def	information_schema	STATISTICS	STATISTICS	SEQ_IN_INDEX	Seq_in_index	8	2	1	N	36865	0	63
+def	information_schema	STATISTICS	STATISTICS	SEQ_IN_INDEX	Seq_in_index	3	2	1	N	36897	0	63
 def	information_schema	STATISTICS	STATISTICS	COLUMN_NAME	Column_name	253	64	1	N	4097	0	8
 def	information_schema	STATISTICS	STATISTICS	COLLATION	Collation	253	1	1	Y	4096	0	8
 def	information_schema	STATISTICS	STATISTICS	CARDINALITY	Cardinality	8	21	1	Y	36864	0	63
@@ -652,7 +652,7 @@ Catalog	Database	Table	Table_alias	Column	Column_alias	Type	Length	Max length	Is
 def	information_schema	STATISTICS	STATISTICS	TABLE_NAME	Table	253	64	2	N	4097	0	63
 def	information_schema	STATISTICS	STATISTICS	NON_UNIQUE	Non_unique	8	1	1	N	36865	0	63
 def	information_schema	STATISTICS	STATISTICS	INDEX_NAME	Key_name	253	64	7	N	4097	0	63
-def	information_schema	STATISTICS	STATISTICS	SEQ_IN_INDEX	Seq_in_index	8	2	1	N	36865	0	63
+def	information_schema	STATISTICS	STATISTICS	SEQ_IN_INDEX	Seq_in_index	3	2	1	N	36897	0	63
 def	information_schema	STATISTICS	STATISTICS	COLUMN_NAME	Column_name	253	64	6	N	4097	0	63
 def	information_schema	STATISTICS	STATISTICS	COLLATION	Collation	253	1	1	Y	4096	0	63
 def	information_schema	STATISTICS	STATISTICS	CARDINALITY	Cardinality	8	21	1	Y	36864	0	63
@@ -923,7 +923,7 @@ Catalog	Database	Table	Table_alias	Column	Column_alias	Type	Length	Max length	Is
 def	information_schema	STATISTICS	STATISTICS	TABLE_NAME	Table	253	192	2	N	4097	0	33
 def	information_schema	STATISTICS	STATISTICS	NON_UNIQUE	Non_unique	8	1	1	N	36865	0	63
 def	information_schema	STATISTICS	STATISTICS	INDEX_NAME	Key_name	253	192	7	N	4097	0	33
-def	information_schema	STATISTICS	STATISTICS	SEQ_IN_INDEX	Seq_in_index	8	2	1	N	36865	0	63
+def	information_schema	STATISTICS	STATISTICS	SEQ_IN_INDEX	Seq_in_index	3	2	1	N	36897	0	63
 def	information_schema	STATISTICS	STATISTICS	COLUMN_NAME	Column_name	253	192	1	N	4097	0	33
 def	information_schema	STATISTICS	STATISTICS	COLLATION	Collation	253	3	1	Y	4096	0	33
 def	information_schema	STATISTICS	STATISTICS	CARDINALITY	Cardinality	8	21	1	Y	36864	0	63
diff --git a/mysql-test/suite/funcs_1/r/is_columns_is.result b/mysql-test/suite/funcs_1/r/is_columns_is.result
index 1b97125b16f..d1e4093751f 100644
--- a/mysql-test/suite/funcs_1/r/is_columns_is.result
+++ b/mysql-test/suite/funcs_1/r/is_columns_is.result
@@ -389,7 +389,7 @@ def	information_schema	STATISTICS	INDEX_TYPE	14	NULL	NO	varchar	16	48	NULL	NULL
 def	information_schema	STATISTICS	NON_UNIQUE	4	NULL	NO	bigint	NULL	NULL	19	0	NULL	NULL	NULL	bigint(1)			select		NEVER	NULL	NO	NO
 def	information_schema	STATISTICS	NULLABLE	13	NULL	NO	varchar	3	9	NULL	NULL	NULL	utf8mb3	utf8mb3_general_ci	varchar(3)			select		NEVER	NULL	NO	NO
 def	information_schema	STATISTICS	PACKED	12	NULL	YES	varchar	10	30	NULL	NULL	NULL	utf8mb3	utf8mb3_general_ci	varchar(10)			select		NEVER	NULL	NO	NO
-def	information_schema	STATISTICS	SEQ_IN_INDEX	7	NULL	NO	bigint	NULL	NULL	19	0	NULL	NULL	NULL	bigint(2)			select		NEVER	NULL	NO	NO
+def	information_schema	STATISTICS	SEQ_IN_INDEX	7	NULL	NO	int	NULL	NULL	10	0	NULL	NULL	NULL	int(2) unsigned			select		NEVER	NULL	NO	NO
 def	information_schema	STATISTICS	SUB_PART	11	NULL	YES	bigint	NULL	NULL	19	0	NULL	NULL	NULL	bigint(3)			select		NEVER	NULL	NO	NO
 def	information_schema	STATISTICS	TABLE_CATALOG	1	NULL	NO	varchar	512	1536	NULL	NULL	NULL	utf8mb3	utf8mb3_general_ci	varchar(512)			select		NEVER	NULL	NO	NO
 def	information_schema	STATISTICS	TABLE_NAME	3	NULL	NO	varchar	64	192	NULL	NULL	NULL	utf8mb3	utf8mb3_general_ci	varchar(64)			select		NEVER	NULL	NO	NO
@@ -963,7 +963,7 @@ NULL	information_schema	SPATIAL_REF_SYS	AUTH_SRID	int	NULL	NULL	NULL	NULL	int(5)
 NULL	information_schema	STATISTICS	NON_UNIQUE	bigint	NULL	NULL	NULL	NULL	bigint(1)
 3.0000	information_schema	STATISTICS	INDEX_SCHEMA	varchar	64	192	utf8mb3	utf8mb3_general_ci	varchar(64)
 3.0000	information_schema	STATISTICS	INDEX_NAME	varchar	64	192	utf8mb3	utf8mb3_general_ci	varchar(64)
-NULL	information_schema	STATISTICS	SEQ_IN_INDEX	bigint	NULL	NULL	NULL	NULL	bigint(2)
+NULL	information_schema	STATISTICS	SEQ_IN_INDEX	int	NULL	NULL	NULL	NULL	int(2) unsigned
 3.0000	information_schema	STATISTICS	COLUMN_NAME	varchar	64	192	utf8mb3	utf8mb3_general_ci	varchar(64)
 3.0000	information_schema	STATISTICS	COLLATION	varchar	1	3	utf8mb3	utf8mb3_general_ci	varchar(1)
 NULL	information_schema	STATISTICS	CARDINALITY	bigint	NULL	NULL	NULL	NULL	bigint(21)
diff --git a/mysql-test/suite/funcs_1/r/is_columns_is_embedded.result b/mysql-test/suite/funcs_1/r/is_columns_is_embedded.result
index 686853d860c..dc6f7f7fef3 100644
--- a/mysql-test/suite/funcs_1/r/is_columns_is_embedded.result
+++ b/mysql-test/suite/funcs_1/r/is_columns_is_embedded.result
@@ -389,7 +389,7 @@ def	information_schema	STATISTICS	INDEX_TYPE	14	NULL	NO	varchar	16	48	NULL	NULL
 def	information_schema	STATISTICS	NON_UNIQUE	4	NULL	NO	bigint	NULL	NULL	19	0	NULL	NULL	NULL	bigint(1)					NEVER	NULL	NO	NO
 def	information_schema	STATISTICS	NULLABLE	13	NULL	NO	varchar	3	9	NULL	NULL	NULL	utf8mb3	utf8mb3_general_ci	varchar(3)					NEVER	NULL	NO	NO
 def	information_schema	STATISTICS	PACKED	12	NULL	YES	varchar	10	30	NULL	NULL	NULL	utf8mb3	utf8mb3_general_ci	varchar(10)					NEVER	NULL	NO	NO
-def	information_schema	STATISTICS	SEQ_IN_INDEX	7	NULL	NO	bigint	NULL	NULL	19	0	NULL	NULL	NULL	bigint(2)					NEVER	NULL	NO	NO
+def	information_schema	STATISTICS	SEQ_IN_INDEX	7	NULL	NO	int	NULL	NULL	10	0	NULL	NULL	NULL	int(2) unsigned					NEVER	NULL	NO	NO
 def	information_schema	STATISTICS	SUB_PART	11	NULL	YES	bigint	NULL	NULL	19	0	NULL	NULL	NULL	bigint(3)					NEVER	NULL	NO	NO
 def	information_schema	STATISTICS	TABLE_CATALOG	1	NULL	NO	varchar	512	1536	NULL	NULL	NULL	utf8mb3	utf8mb3_general_ci	varchar(512)					NEVER	NULL	NO	NO
 def	information_schema	STATISTICS	TABLE_NAME	3	NULL	NO	varchar	64	192	NULL	NULL	NULL	utf8mb3	utf8mb3_general_ci	varchar(64)					NEVER	NULL	NO	NO
@@ -963,7 +963,7 @@ NULL	information_schema	SPATIAL_REF_SYS	AUTH_SRID	int	NULL	NULL	NULL	NULL	int(5)
 NULL	information_schema	STATISTICS	NON_UNIQUE	bigint	NULL	NULL	NULL	NULL	bigint(1)
 3.0000	information_schema	STATISTICS	INDEX_SCHEMA	varchar	64	192	utf8mb3	utf8mb3_general_ci	varchar(64)
 3.0000	information_schema	STATISTICS	INDEX_NAME	varchar	64	192	utf8mb3	utf8mb3_general_ci	varchar(64)
-NULL	information_schema	STATISTICS	SEQ_IN_INDEX	bigint	NULL	NULL	NULL	NULL	bigint(2)
+NULL	information_schema	STATISTICS	SEQ_IN_INDEX	int	NULL	NULL	NULL	NULL	int(2) unsigned
 3.0000	information_schema	STATISTICS	COLUMN_NAME	varchar	64	192	utf8mb3	utf8mb3_general_ci	varchar(64)
 3.0000	information_schema	STATISTICS	COLLATION	varchar	1	3	utf8mb3	utf8mb3_general_ci	varchar(1)
 NULL	information_schema	STATISTICS	CARDINALITY	bigint	NULL	NULL	NULL	NULL	bigint(21)
diff --git a/mysql-test/suite/funcs_1/r/is_statistics.result b/mysql-test/suite/funcs_1/r/is_statistics.result
index 809c287d8d6..f271913d329 100644
--- a/mysql-test/suite/funcs_1/r/is_statistics.result
+++ b/mysql-test/suite/funcs_1/r/is_statistics.result
@@ -34,7 +34,7 @@ TABLE_NAME	varchar(64)	NO		NULL
 NON_UNIQUE	bigint(1)	NO		NULL	
 INDEX_SCHEMA	varchar(64)	NO		NULL	
 INDEX_NAME	varchar(64)	NO		NULL	
-SEQ_IN_INDEX	bigint(2)	NO		NULL	
+SEQ_IN_INDEX	int(2) unsigned	NO		NULL	
 COLUMN_NAME	varchar(64)	NO		NULL	
 COLLATION	varchar(1)	YES		NULL	
 CARDINALITY	bigint(21)	YES		NULL	
@@ -54,7 +54,7 @@ STATISTICS	CREATE TEMPORARY TABLE `STATISTICS` (
   `NON_UNIQUE` bigint(1) NOT NULL,
   `INDEX_SCHEMA` varchar(64) NOT NULL,
   `INDEX_NAME` varchar(64) NOT NULL,
-  `SEQ_IN_INDEX` bigint(2) NOT NULL,
+  `SEQ_IN_INDEX` int(2) unsigned NOT NULL,
   `COLUMN_NAME` varchar(64) NOT NULL,
   `COLLATION` varchar(1),
   `CARDINALITY` bigint(21),
@@ -74,7 +74,7 @@ TABLE_NAME	varchar(64)	NO		NULL
 NON_UNIQUE	bigint(1)	NO		NULL	
 INDEX_SCHEMA	varchar(64)	NO		NULL	
 INDEX_NAME	varchar(64)	NO		NULL	
-SEQ_IN_INDEX	bigint(2)	NO		NULL	
+SEQ_IN_INDEX	int(2) unsigned	NO		NULL	
 COLUMN_NAME	varchar(64)	NO		NULL	
 COLLATION	varchar(1)	YES		NULL	
 CARDINALITY	bigint(21)	YES		NULL	
diff --git a/mysql-test/suite/galera/t/galera_ist_mariabackup_verify_ca.cnf b/mysql-test/suite/galera/t/galera_ist_mariabackup_verify_ca.cnf
index ffd2306bfb3..d1d3b4eb9cd 100644
--- a/mysql-test/suite/galera/t/galera_ist_mariabackup_verify_ca.cnf
+++ b/mysql-test/suite/galera/t/galera_ist_mariabackup_verify_ca.cnf
@@ -10,11 +10,11 @@ ssl-ca=@ENV.MYSQL_TEST_DIR/std_data/cacert.pem
 
 [mysqld.1]
 wsrep_provider_options='base_port=@mysqld.1.#galera_port;pc.ignore_sb=true'
-innodb-log-file-buffering
+loose-innodb-log-file-buffering
 
 [mysqld.2]
 wsrep_provider_options='base_port=@mysqld.2.#galera_port;pc.ignore_sb=true'
-innodb-log-file-buffering
+loose-innodb-log-file-buffering
 
 [sst]
 ssl-mode=VERIFY_CA
diff --git a/mysql-test/suite/innodb/r/innodb-fk-warnings.result b/mysql-test/suite/innodb/r/innodb-fk-warnings.result
index c85dcf22c06..b58d21b0914 100644
--- a/mysql-test/suite/innodb/r/innodb-fk-warnings.result
+++ b/mysql-test/suite/innodb/r/innodb-fk-warnings.result
@@ -16,7 +16,7 @@ CONSTRAINT test FOREIGN KEY (b) REFERENCES t2 (id)
 ERROR HY000: Can't create table `test`.`t2` (errno: 121 "Duplicate key on write or update")
 show warnings;
 Level	Code	Message
-Warning	121	Create or Alter table `test`.`t2` with foreign key constraint failed. Foreign key constraint `test`.`test` already exists on data dictionary. Foreign key constraint names need to be unique in database. Error in foreign key definition: CONSTRAINT `test` FOREIGN KEY (`b`) REFERENCES `test`.`t2` (`id`).
+Warning	121	CREATE or ALTER TABLE `test`.`t2` failed: duplicate name, CONSTRAINT `test` FOREIGN KEY (`b`) REFERENCES `t2` (`id`)
 Error	1005	Can't create table `test`.`t2` (errno: 121 "Duplicate key on write or update")
 Warning	1022	Can't write; duplicate key in table 't2'
 drop table t1;
diff --git a/mysql-test/suite/mariabackup/log_tables.result b/mysql-test/suite/mariabackup/log_tables.result
index 840efc718e9..2528691f1b4 100644
--- a/mysql-test/suite/mariabackup/log_tables.result
+++ b/mysql-test/suite/mariabackup/log_tables.result
@@ -1,5 +1,7 @@
 CREATE TABLE t(i INT)
 ENGINE ARIA TRANSACTIONAL=1 ROW_FORMAT=PAGE PAGE_CHECKSUM=1;
+SET GLOBAL general_log = 0;
+TRUNCATE mysql.general_log;
 SET GLOBAL general_log = 1;
 SET GLOBAL log_output = 'TABLE';
 INSERT INTO t VALUES (1);
diff --git a/mysql-test/suite/mariabackup/log_tables.test b/mysql-test/suite/mariabackup/log_tables.test
index fe540a1ca91..707057a80e6 100644
--- a/mysql-test/suite/mariabackup/log_tables.test
+++ b/mysql-test/suite/mariabackup/log_tables.test
@@ -7,9 +7,9 @@
 CREATE TABLE t(i INT)
   ENGINE ARIA TRANSACTIONAL=1 ROW_FORMAT=PAGE PAGE_CHECKSUM=1;
 
---let $general_log_old = `SELECT @@global.general_log`
---let $log_output_old = `SELECT @@global.log_output`
-
+# Truncate the log in order to make the test ./mtr --repeat proof
+SET GLOBAL general_log = 0;
+TRUNCATE mysql.general_log;
 SET GLOBAL general_log = 1;
 SET GLOBAL log_output = 'TABLE';
 
@@ -43,7 +43,3 @@ SELECT * FROM mysql.general_log
 
 --rmdir $targetdir
 DROP TABLE t;
---disable_query_log
---eval SET GLOBAL general_log = $general_log_old
---eval SET GLOBAL log_output = $log_output_old
---enable_query_log
diff --git a/mysql-test/suite/s3/basic.result b/mysql-test/suite/s3/basic.result
index 790806ee43c..47c35d8cfbe 100644
--- a/mysql-test/suite/s3/basic.result
+++ b/mysql-test/suite/s3/basic.result
@@ -130,16 +130,19 @@ s3_block_size	X
 s3_bucket	X
 s3_debug	X
 s3_host_name	X
+s3_no_content_type	X
 s3_pagecache_age_threshold	X
 s3_pagecache_buffer_size	X
 s3_pagecache_division_limit	X
 s3_pagecache_file_hash_size	X
 s3_port	X
 s3_protocol_version	X
+s3_provider	X
 s3_region	X
 s3_replicate_alter_as_create_select	X
 s3_secret_key	X
 s3_slave_ignore_updates	X
+s3_ssl_no_verify	X
 s3_use_http	X
 show variables like "s3_slave%";
 Variable_name	Value
diff --git a/mysql-test/suite/s3/my.cnf b/mysql-test/suite/s3/my.cnf
index 818b2a881d6..c98514fb19d 100644
--- a/mysql-test/suite/s3/my.cnf
+++ b/mysql-test/suite/s3/my.cnf
@@ -11,6 +11,8 @@ s3-secret-key=@ENV.S3_SECRET_KEY
 s3-region=@ENV.S3_REGION
 s3-port=@ENV.S3_PORT
 s3-use-http=@ENV.S3_USE_HTTP
+s3-ssl-no-verify=@ENV.S3_SSL_NO_VERIFY
+s3-provider=@ENV.S3_PROVIDER
 
 #s3-host-name=s3.amazonaws.com
 #s3-protocol-version=Amazon
diff --git a/mysql-test/suite/s3/slave.cnf b/mysql-test/suite/s3/slave.cnf
index 4f4d3d39ac7..729a48c49eb 100644
--- a/mysql-test/suite/s3/slave.cnf
+++ b/mysql-test/suite/s3/slave.cnf
@@ -10,6 +10,8 @@ s3-secret-key=@ENV.S3_SECRET_KEY
 s3-region=@ENV.S3_REGION
 s3-port=@ENV.S3_PORT
 s3-use-http=@ENV.S3_USE_HTTP
+s3-ssl-no-verify=@ENV.S3_SSL_NO_VERIFY
+s3-provider=@ENV.S3_PROVIDER
 
 # You can change the following when running the tests against
 # your own S3 setup
diff --git a/mysql-test/suite/s3/suite.pm b/mysql-test/suite/s3/suite.pm
index cdefbc5e323..383bf4f7798 100644
--- a/mysql-test/suite/s3/suite.pm
+++ b/mysql-test/suite/s3/suite.pm
@@ -20,6 +20,8 @@ if(connect(SOCK, $paddr))
   $ENV{'S3_REGION'} = "";
   $ENV{'S3_PROTOCOL_VERSION'} = "Auto";
   $ENV{'S3_USE_HTTP'} = "ON";
+  $ENV{'S3_SSL_NO_VERIFY'} = "OFF";
+  $ENV{'S3_PROVIDER'} = "Default";
 }
 else
 {
@@ -62,6 +64,17 @@ else
   {
     $ENV{'S3_USE_HTTP'} = "OFF";
   }
+
+  if (!$ENV{'S3_SSL_NO_VERIFY'})
+  {
+    $ENV{'S3_SSL_NO_VERIFY'} = "OFF";
+  }
+
+  if (!$ENV{'S3_PROVIDER'})
+  {
+    $ENV{'S3_PROVIDER'} = "Default";
+  }
+
 }
 bless { };
 
diff --git a/mysys/crc32/crc32c.cc b/mysys/crc32/crc32c.cc
index 6de7af70db7..0d65d0027d4 100644
--- a/mysys/crc32/crc32c.cc
+++ b/mysys/crc32/crc32c.cc
@@ -455,7 +455,7 @@ static int arch_ppc_probe(void) {
 
   return arch_ppc_crc32;
 }
-# elif defined __FreeBSD_version && __FreeBSD_version >= 1200000
+# elif defined __FreeBSD__
 #  include <machine/cpu.h>
 #  include <sys/auxv.h>
 #  include <sys/elf_common.h>
diff --git a/sql/item.cc b/sql/item.cc
index eebea82f60d..ff034678f20 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -1293,7 +1293,7 @@ Item *Item::multiple_equality_transformer(THD *thd, uchar *arg)
       This flag will be removed at the end of the pushdown optimization by
       remove_immutable_flag_processor processor.
     */
-    int new_flag= MARKER_IMMUTABLE;
+    int16 new_flag= MARKER_IMMUTABLE;
     this->walk(&Item::set_extraction_flag_processor, false,
                (void*)&new_flag);
   }
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 6a08f13e004..71687974908 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -209,7 +209,7 @@ typedef fp_except fp_except_t;
 
 inline void setup_fpu()
 {
-#if defined(__FreeBSD__) && defined(HAVE_IEEEFP_H) && !defined(HAVE_FEDISABLEEXCEPT)
+#if defined(__FreeBSD__) && defined(HAVE_IEEEFP_H) && !defined(HAVE_FEDISABLEEXCEPT) && defined(FP_X_INV)
   /* We can't handle floating point exceptions with threads, so disable
      this on freebsd
      Don't fall for overflow, underflow,divide-by-zero or loss of precision.
@@ -222,7 +222,7 @@ inline void setup_fpu()
   fpsetmask(~(FP_X_INV |             FP_X_OFL | FP_X_UFL | FP_X_DZ |
               FP_X_IMP));
 #endif /* FP_X_DNML */
-#endif /* __FreeBSD__ && HAVE_IEEEFP_H && !HAVE_FEDISABLEEXCEPT */
+#endif /* __FreeBSD__ && HAVE_IEEEFP_H && !HAVE_FEDISABLEEXCEPT && FP_X_INV */
 
 #ifdef HAVE_FEDISABLEEXCEPT
   fedisableexcept(FE_ALL_EXCEPT);
diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc
index 92581840f71..085e8bf7aa4 100644
--- a/sql/sql_delete.cc
+++ b/sql/sql_delete.cc
@@ -500,6 +500,12 @@ bool Sql_cmd_delete::delete_from_single_table(THD *thd)
     if (thd->binlog_for_noop_dml(transactional_table))
       DBUG_RETURN(1);
 
+    if (!thd->lex->current_select->leaf_tables_saved)
+    {
+      thd->lex->current_select->save_leaf_tables(thd);
+      thd->lex->current_select->leaf_tables_saved= true;
+    }
+
     my_ok(thd, 0);
     DBUG_RETURN(0);
   }
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 638afcf8c7e..5c8634a5882 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -7172,12 +7172,13 @@ Item_equal::add_key_fields(JOIN *join, KEY_FIELD **key_fields,
 }
 
 
-static uint
+static inline uint
 max_part_bit(key_part_map bits)
 {
-  uint found;
-  for (found=0; bits & 1 ; found++,bits>>=1) ;
-  return found;
+  if (bits == 0)
+    return 0;
+  /* find first zero bit by reverting all bits and find first bit */
+  return my_find_first_bit(~(ulonglong) bits);
 }
 
 
@@ -8606,6 +8607,7 @@ best_access_path(JOIN      *join,
   if (s->keyuse)
   {                                            /* Use key if possible */
     KEYUSE *keyuse, *start_key= 0;
+    const char *cause= NULL;
     uint max_key_part=0;
     enum join_type type= JT_UNKNOWN;
     double cur_cost, copy_cost, cached_prev_record_reads= 0.0;
@@ -8616,7 +8618,6 @@ best_access_path(JOIN      *join,
     for (keyuse=s->keyuse ; keyuse->table == table ;)
     {
       KEY *keyinfo;
-      const char *cause= NULL;
       ulong key_flags;
       uint key_parts;
       key_part_map found_part= 0;
@@ -8624,6 +8625,7 @@ best_access_path(JOIN      *join,
       key_part_map notnull_part=0;
       table_map found_ref= 0;
       uint key= keyuse->key;
+      uint max_const_parts;
       bool ft_key=  (keyuse->keypart == FT_KEYPART);
       /* Bitmap of keyparts where the ref access is over 'keypart=const': */
       key_part_map const_part= 0;
@@ -8750,6 +8752,8 @@ best_access_path(JOIN      *join,
         rec= MATCHING_ROWS_IN_OTHER_TABLE;      // Fix for small tables
 
       Json_writer_object trace_access_idx(thd);
+      max_const_parts= max_part_bit(const_part);
+
       /*
         full text keys require special treatment
       */
@@ -8896,9 +8900,7 @@ best_access_path(JOIN      *join,
                 in ReuseRangeEstimateForRef-3.
               */
               if (table->opt_range_keys.is_set(key) &&
-                  (const_part &
-                   (((key_part_map)1 << table->opt_range[key].key_parts)-1)) ==
-                  (((key_part_map)1 << table->opt_range[key].key_parts)-1) &&
+                  table->opt_range[key].key_parts <= max_const_parts &&
                   table->opt_range[key].ranges == 1 &&
                   records > (double) table->opt_range[key].rows)
               {
@@ -8946,6 +8948,8 @@ best_access_path(JOIN      *join,
             double extra_cost= 0;
 
             max_key_part= max_part_bit(found_part);
+            bool all_used_equalities_are_const= (max_key_part ==
+                                                 max_const_parts);
             /*
               ReuseRangeEstimateForRef-3:
               We're now considering a ref[or_null] access via
@@ -8960,7 +8964,7 @@ best_access_path(JOIN      *join,
               create quick select over another index), so we can't compare
               them to (**). We'll make indirect judgements instead.
               The sufficient conditions for re-use are:
-              (C1) All e_i in (**) are constants, i.e. found_ref==FALSE. (if
+              (C1) All e_i in (**) are constants (if
                    this is not satisfied we have no way to know which ranges
                    will be actually scanned by 'ref' until we execute the 
                    join)
@@ -8985,7 +8989,8 @@ best_access_path(JOIN      *join,
 
               (C3) "range optimizer used (have ref_or_null?2:1) intervals"
             */
-            if (table->opt_range_keys.is_set(key) && !found_ref &&      //(C1)
+            if (table->opt_range_keys.is_set(key) &&
+                all_used_equalities_are_const && // (C1)
                 table->opt_range[key].key_parts == max_key_part &&      //(C2)
                 (table->opt_range[key].ranges ==
                  1 + MY_TEST(ref_or_null_part))) //(C3)
@@ -9031,7 +9036,7 @@ best_access_path(JOIN      *join,
                       This is the case when we have only one const range
                       and it consist of more parts than what we used for REF.
                     */
-                    if (!found_ref &&
+                    if (all_used_equalities_are_const &&
                         table->opt_range[key].key_parts > max_key_part &&
                         table->opt_range[key].ranges <=
                         (uint) (1 + MY_TEST(ref_or_null_part)))
@@ -9043,7 +9048,7 @@ best_access_path(JOIN      *join,
                     }
                   }
                   rows= (double) table->opt_range[key].rows;
-                  if (!found_ref &&                                  // (1)
+                  if (all_used_equalities_are_const &&               // (1)
                       records < rows)                                // (3)
                   {
                     trace_access_idx.add("used_range_estimates",
@@ -9111,16 +9116,17 @@ best_access_path(JOIN      *join,
                 applied to first table->quick_key_parts[key] key parts.
               */
               if (table->opt_range_keys.is_set(key) &&
-                  table->opt_range[key].key_parts <= max_key_part &&
-                  const_part &
-                  ((key_part_map)1 << table->opt_range[key].key_parts) &&
+                  table->opt_range[key].key_parts <= max_const_parts &&
                   table->opt_range[key].ranges == (1 +
                                                    MY_TEST(ref_or_null_part &
                                                            const_part)) &&
                   records > (double) table->opt_range[key].rows)
               {
-                trace_access_idx.add("used_range_estimates", true);
-                records= (double) table->opt_range[key].rows;
+                // psergey-merge-sept: remove: if (table->opt_range[key].key_parts <= max_const_parts)
+                {
+                  trace_access_idx.add("used_range_estimates", true);
+                  records= (double) table->opt_range[key].rows;
+                }
               }
             }
 
@@ -9249,6 +9255,7 @@ best_access_path(JOIN      *join,
           add("cost", cur_cost);
       }
 
+
       /*
         The COST_EPS is here to ensure we use the first key if there are
         two 'identical keys' that could be used.
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 759f479ea52..a8ab2718abc 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -9810,7 +9810,7 @@ ST_FIELD_INFO stat_fields_info[]=
   Column("NON_UNIQUE",    SLonglong(1),NOT_NULL, "Non_unique",  OPEN_FRM_ONLY),
   Column("INDEX_SCHEMA",  Name(),      NOT_NULL,                OPEN_FRM_ONLY),
   Column("INDEX_NAME",    Name(),      NOT_NULL, "Key_name",    OPEN_FRM_ONLY),
-  Column("SEQ_IN_INDEX",  SLonglong(2),NOT_NULL, "Seq_in_index",OPEN_FRM_ONLY),
+  Column("SEQ_IN_INDEX",  ULong(2),    NOT_NULL, "Seq_in_index",OPEN_FRM_ONLY),
   Column("COLUMN_NAME",   Name(),      NOT_NULL, "Column_name", OPEN_FRM_ONLY),
   Column("COLLATION",     Varchar(1),  NULLABLE, "Collation",   OPEN_FULL_TABLE),
   Column("CARDINALITY",   SLonglong(), NULLABLE, "Cardinality", OPEN_FULL_TABLE),
diff --git a/sql/sql_update.cc b/sql/sql_update.cc
index 00aa18ba98c..1d5c6438493 100644
--- a/sql/sql_update.cc
+++ b/sql/sql_update.cc
@@ -469,6 +469,12 @@ bool Sql_cmd_update::update_single_table(THD *thd)
     if (thd->binlog_for_noop_dml(transactional_table))
       DBUG_RETURN(1);
 
+    if (!thd->lex->current_select->leaf_tables_saved)
+    {
+      thd->lex->current_select->save_leaf_tables(thd);
+      thd->lex->current_select->leaf_tables_saved= true;
+    }
+
     my_ok(thd);				// No matching records
     DBUG_RETURN(0);
   }
diff --git a/storage/columnstore/CMakeLists.txt b/storage/columnstore/CMakeLists.txt
index 4e831489b71..93065847c5c 100644
--- a/storage/columnstore/CMakeLists.txt
+++ b/storage/columnstore/CMakeLists.txt
@@ -47,6 +47,7 @@ SET_PROPERTY(DIRECTORY PROPERTY INCLUDE_DIRECTORIES "${dirs}")
 IF(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64" OR
 CMAKE_SYSTEM_PROCESSOR STREQUAL "amd64" OR
 CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64")
+    SET(PCRE_INCLUDES "${PCRE_INCLUDE_DIRS}")
     add_subdirectory(columnstore)
 
     IF(TARGET columnstore)
diff --git a/storage/innobase/btr/btr0btr.cc b/storage/innobase/btr/btr0btr.cc
index 45207d9d02d..76b7f249674 100644
--- a/storage/innobase/btr/btr0btr.cc
+++ b/storage/innobase/btr/btr0btr.cc
@@ -195,15 +195,13 @@ bool btr_root_fseg_validate(ulint offset, const buf_block_t &block,
   return false;
 }
 
-/** Report a decryption failure. */
-ATTRIBUTE_COLD void btr_decryption_failed(const dict_index_t &index)
+/** Report a read failure if it is a decryption failure.
+@param err   error code
+@param index the index that is being accessed */
+ATTRIBUTE_COLD void btr_read_failed(dberr_t err, const dict_index_t &index)
 {
-  ib_push_warning(static_cast<void*>(nullptr), DB_DECRYPTION_FAILED,
-                  "Table %s is encrypted but encryption service or"
-                  " used key_id is not available. "
-                  " Can't continue reading table.",
-                  index.table->name.m_name);
-  index.table->file_unreadable= true;
+  if (err == DB_DECRYPTION_FAILED)
+    innodb_decryption_failed(nullptr, index.table);
 }
 
 /** Get an index page and declare its latching order level.
@@ -242,8 +240,8 @@ buf_block_t *btr_block_get(const dict_index_t &index,
     else if (!buf_page_make_young_if_needed(&block->page) && first)
       *first= true;
   }
-  else if (*err == DB_DECRYPTION_FAILED)
-    btr_decryption_failed(index);
+  else
+    btr_read_failed(*err, index);
 
   return block;
 }
@@ -304,8 +302,8 @@ btr_root_block_get(
     else
       buf_page_make_young_if_needed(&block->page);
   }
-  else if (*err == DB_DECRYPTION_FAILED)
-    btr_decryption_failed(*index);
+  else
+    btr_read_failed(*err, *index);
 
   return block;
 }
diff --git a/storage/innobase/btr/btr0cur.cc b/storage/innobase/btr/btr0cur.cc
index 033e3f80754..4284b84c22b 100644
--- a/storage/innobase/btr/btr0cur.cc
+++ b/storage/innobase/btr/btr0cur.cc
@@ -1196,8 +1196,8 @@ dberr_t btr_cur_t::search_leaf(const dtuple_t *tuple, page_cur_mode_t mode,
     buf_page_get_gen(page_id, zip_size, rw_latch, guess, BUF_GET, mtr, &err);
   if (!block)
   {
-    if (err == DB_DECRYPTION_FAILED)
-      btr_decryption_failed(*index());
+    if (err != DB_SUCCESS)
+      btr_read_failed(err, *index());
     goto func_exit;
   }
 
@@ -1669,8 +1669,7 @@ dberr_t btr_cur_t::pessimistic_search_leaf(const dtuple_t *tuple,
 
   if (!block)
   {
-    if (err == DB_DECRYPTION_FAILED)
-      btr_decryption_failed(*index());
+    btr_read_failed(err, *index());
     goto func_exit;
   }
 
@@ -1778,8 +1777,7 @@ search_loop:
   else if (!(block= buf_page_get_gen(page_id, zip_size, rw_latch,
                                      block, BUF_GET, mtr, &err)))
   {
-    if (err == DB_DECRYPTION_FAILED)
-      btr_decryption_failed(*index);
+    btr_read_failed(err, *index);
     goto func_exit;
   }
   else
diff --git a/storage/innobase/dict/dict0crea.cc b/storage/innobase/dict/dict0crea.cc
index dd858287f46..1d47c46d583 100644
--- a/storage/innobase/dict/dict0crea.cc
+++ b/storage/innobase/dict/dict0crea.cc
@@ -1597,104 +1597,6 @@ dict_create_add_foreign_field_to_dictionary(
 		       table_name, foreign->id, trx));
 }
 
-/********************************************************************//**
-Construct foreign key constraint defintion from data dictionary information.
-*/
-static
-char*
-dict_foreign_def_get(
-/*=================*/
-	dict_foreign_t*	foreign,/*!< in: foreign */
-	trx_t*		trx)	/*!< in: trx */
-{
-	char* fk_def = (char *)mem_heap_alloc(foreign->heap, 4*1024);
-	const char* tbname;
-	char tablebuf[MAX_TABLE_NAME_LEN + 1] = "";
-	unsigned i;
-	char* bufend;
-
-	tbname = dict_remove_db_name(foreign->id);
-	bufend = innobase_convert_name(tablebuf, MAX_TABLE_NAME_LEN,
-				tbname, strlen(tbname), trx->mysql_thd);
-	tablebuf[bufend - tablebuf] = '\0';
-
-	sprintf(fk_def,
-		(char *)"CONSTRAINT %s FOREIGN KEY (", (char *)tablebuf);
-
-	for(i = 0; i < foreign->n_fields; i++) {
-		char	buf[MAX_TABLE_NAME_LEN + 1] = "";
-		innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
-				foreign->foreign_col_names[i],
-				strlen(foreign->foreign_col_names[i]),
-				trx->mysql_thd);
-		strcat(fk_def, buf);
-		if (i < static_cast<unsigned>(foreign->n_fields-1)) {
-			strcat(fk_def, (char *)",");
-		}
-	}
-
-	strcat(fk_def,(char *)") REFERENCES ");
-
-	bufend = innobase_convert_name(tablebuf, MAX_TABLE_NAME_LEN,
-	        	        foreign->referenced_table_name,
-			        strlen(foreign->referenced_table_name),
-			        trx->mysql_thd);
-	tablebuf[bufend - tablebuf] = '\0';
-
-	strcat(fk_def, tablebuf);
-	strcat(fk_def, " (");
-
-	for(i = 0; i < foreign->n_fields; i++) {
-		char	buf[MAX_TABLE_NAME_LEN + 1] = "";
-		bufend = innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
-				foreign->referenced_col_names[i],
-				strlen(foreign->referenced_col_names[i]),
-				trx->mysql_thd);
-		buf[bufend - buf] = '\0';
-		strcat(fk_def, buf);
-		if (i < (uint)foreign->n_fields-1) {
-			strcat(fk_def, (char *)",");
-		}
-	}
-	strcat(fk_def, (char *)")");
-
-	return fk_def;
-}
-
-/********************************************************************//**
-Convert foreign key column names from data dictionary to SQL-layer.
-*/
-static
-void
-dict_foreign_def_get_fields(
-/*========================*/
-	dict_foreign_t*	foreign,/*!< in: foreign */
-	trx_t*		trx,	/*!< in: trx */
-	char**		field,  /*!< out: foreign column */
-	char**		field2, /*!< out: referenced column */
-	ulint		col_no) /*!< in: column number */
-{
-	char* bufend;
-	char* fieldbuf = (char *)mem_heap_alloc(foreign->heap, MAX_TABLE_NAME_LEN+1);
-	char* fieldbuf2 = (char *)mem_heap_alloc(foreign->heap, MAX_TABLE_NAME_LEN+1);
-
-	bufend = innobase_convert_name(fieldbuf, MAX_TABLE_NAME_LEN,
-			foreign->foreign_col_names[col_no],
-			strlen(foreign->foreign_col_names[col_no]),
-			trx->mysql_thd);
-
-	fieldbuf[bufend - fieldbuf] = '\0';
-
-	bufend = innobase_convert_name(fieldbuf2, MAX_TABLE_NAME_LEN,
-			foreign->referenced_col_names[col_no],
-			strlen(foreign->referenced_col_names[col_no]),
-			trx->mysql_thd);
-
-	fieldbuf2[bufend - fieldbuf2] = '\0';
-	*field = fieldbuf;
-	*field2 = fieldbuf2;
-}
-
 /********************************************************************//**
 Add a foreign key definition to the data dictionary tables.
 @return error code or DB_SUCCESS */
@@ -1736,29 +1638,8 @@ dict_create_add_foreign_to_dictionary(
 				      , name, foreign->id, trx);
 
 	if (error != DB_SUCCESS) {
-
-		if (error == DB_DUPLICATE_KEY) {
-			char	buf[MAX_TABLE_NAME_LEN + 1] = "";
-			char	tablename[MAX_TABLE_NAME_LEN + 1] = "";
-			char*	fk_def;
-
-			innobase_convert_name(tablename, MAX_TABLE_NAME_LEN,
-				name, strlen(name), trx->mysql_thd);
-
-			innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
-				foreign->id, strlen(foreign->id), trx->mysql_thd);
-
-			fk_def = dict_foreign_def_get((dict_foreign_t*)foreign, trx);
-
-			ib_push_warning(trx, error,
-				"Create or Alter table %s with foreign key constraint"
-				" failed. Foreign key constraint %s"
-				" already exists on data dictionary."
-				" Foreign key constraint names need to be unique in database."
-				" Error in foreign key definition: %s.",
-				tablename, buf, fk_def);
-		}
-
+err_exit:
+		innodb_fk_error(trx, error, name, *foreign);
 		DBUG_RETURN(error);
 	}
 
@@ -1767,27 +1648,7 @@ dict_create_add_foreign_to_dictionary(
 			i, name, foreign, trx);
 
 		if (error != DB_SUCCESS) {
-			char	buf[MAX_TABLE_NAME_LEN + 1] = "";
-			char	tablename[MAX_TABLE_NAME_LEN + 1] = "";
-			char*	field=NULL;
-			char*	field2=NULL;
-			char*	fk_def;
-
-			innobase_convert_name(tablename, MAX_TABLE_NAME_LEN,
-				name, strlen(name), trx->mysql_thd);
-			innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
-				foreign->id, strlen(foreign->id), trx->mysql_thd);
-			fk_def = dict_foreign_def_get((dict_foreign_t*)foreign, trx);
-			dict_foreign_def_get_fields((dict_foreign_t*)foreign, trx, &field, &field2, i);
-
-			ib_push_warning(trx, error,
-				"Create or Alter table %s with foreign key constraint"
-				" failed. Error adding foreign  key constraint name %s"
-				" fields %s or %s to the dictionary."
-				" Error in foreign key definition: %s.",
-				tablename, buf, i+1, fk_def);
-
-			DBUG_RETURN(error);
+			goto err_exit;
 		}
 	}
 
diff --git a/storage/innobase/dict/dict0dict.cc b/storage/innobase/dict/dict0dict.cc
index e33f86e9b55..215ab2867c4 100644
--- a/storage/innobase/dict/dict0dict.cc
+++ b/storage/innobase/dict/dict0dict.cc
@@ -195,21 +195,6 @@ dict_tables_have_same_db(
 	return(FALSE);
 }
 
-/********************************************************************//**
-Return the end of table name where we have removed dbname and '/'.
-@return table name */
-const char*
-dict_remove_db_name(
-/*================*/
-	const char*	name)	/*!< in: table name in the form
-				dbname '/' tablename */
-{
-	const char*	s = strchr(name, '/');
-	ut_a(s);
-
-	return(s + 1);
-}
-
 /** Decrement the count of open handles */
 void dict_table_close(dict_table_t *table)
 {
@@ -3844,15 +3829,10 @@ dict_index_calc_min_rec_len(
 	return(sum);
 }
 
-/**********************************************************************//**
-Outputs info on a foreign key of a table in a format suitable for
-CREATE TABLE. */
 std::string
-dict_print_info_on_foreign_key_in_create_format(
-/*============================================*/
-	trx_t*		trx,		/*!< in: transaction */
-	dict_foreign_t*	foreign,	/*!< in: foreign key constraint */
-	ibool		add_newline)	/*!< in: whether to add a newline */
+dict_print_info_on_foreign_key_in_create_format(const trx_t *trx,
+                                                const dict_foreign_t *foreign,
+                                                bool add_newline)
 {
 	const char*	stripped_id;
 	ulint	i;
diff --git a/storage/innobase/gis/gis0sea.cc b/storage/innobase/gis/gis0sea.cc
index c544325bc4c..d084db25996 100644
--- a/storage/innobase/gis/gis0sea.cc
+++ b/storage/innobase/gis/gis0sea.cc
@@ -669,8 +669,7 @@ dberr_t rtr_search_to_nth_level(btr_cur_t *cur, que_thr_t *thr,
     if (err)
     {
     err_exit:
-      if (err == DB_DECRYPTION_FAILED)
-        btr_decryption_failed(*index);
+      btr_read_failed(err, *index);
       mtr->rollback_to_savepoint(savepoint);
     }
   func_exit:
diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
index 6dd41996dac..e1bcda284c8 100644
--- a/storage/innobase/handler/ha_innodb.cc
+++ b/storage/innobase/handler/ha_innodb.cc
@@ -3337,7 +3337,7 @@ innobase_invalidate_query_cache(
 void
 innobase_quote_identifier(
 	FILE*		file,
-	trx_t*		trx,
+	const trx_t*	trx,
 	const char*	id)
 {
 	const int	q = trx != NULL && trx->mysql_thd != NULL
@@ -3367,7 +3367,7 @@ innobase_quote_identifier(
 std::string
 innobase_quote_identifier(
 /*======================*/
-	trx_t*		trx,
+	const trx_t*	trx,
 	const char*	id)
 {
 	std::string quoted_identifier;
@@ -21071,64 +21071,46 @@ static void innodb_remember_check_sysvar_funcs()
 	check_sysvar_int = MYSQL_SYSVAR_NAME(flush_log_at_timeout).check;
 }
 
-static const size_t MAX_BUF_SIZE = 4 * 1024;
-
-/********************************************************************//**
-Helper function to push warnings from InnoDB internals to SQL-layer. */
-void
-ib_push_warning(
-	trx_t*		trx,	/*!< in: trx */
-	dberr_t		error,	/*!< in: error code to push as warning */
-	const char	*format,/*!< in: warning message */
-	...)
+/** Report that a table cannot be decrypted.
+@param thd    connection context
+@param table  table that cannot be decrypted
+@retval DB_DECRYPTION_FAILED (always) */
+ATTRIBUTE_COLD
+dberr_t innodb_decryption_failed(THD *thd, dict_table_t *table)
 {
-	if (trx && trx->mysql_thd) {
-		THD *thd = (THD *)trx->mysql_thd;
-		va_list args;
-		char *buf;
-
-		va_start(args, format);
-		buf = (char *)my_malloc(PSI_INSTRUMENT_ME, MAX_BUF_SIZE, MYF(MY_WME));
-		buf[MAX_BUF_SIZE - 1] = 0;
-		vsnprintf(buf, MAX_BUF_SIZE - 1, format, args);
-
-		push_warning_printf(
-			thd, Sql_condition::WARN_LEVEL_WARN,
-			uint(convert_error_code_to_mysql(error, 0, thd)), buf);
-		my_free(buf);
-		va_end(args);
-	}
+  table->file_unreadable= true;
+  if (!thd)
+    thd= current_thd;
+  const int dblen= int(table->name.dblen());
+  push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                      HA_ERR_DECRYPTION_FAILED,
+                      "Table %`.*s.%`s in tablespace " UINT32PF
+                      " (file %s) cannot be decrypted.",
+                      dblen, table->name.m_name,
+                      table->name.m_name + dblen + 1,
+                      uint32_t(table->space_id),
+                      UT_LIST_GET_FIRST(table->space->chain)->name);
+  return DB_DECRYPTION_FAILED;
 }
 
-/********************************************************************//**
-Helper function to push warnings from InnoDB internals to SQL-layer. */
-void
-ib_push_warning(
-	void*		ithd,	/*!< in: thd */
-	dberr_t		error,	/*!< in: error code to push as warning */
-	const char	*format,/*!< in: warning message */
-	...)
+/** Report a foreign key error.
+@param error    error to report
+@param name     table name
+@param foreign  constraint */
+ATTRIBUTE_COLD
+void innodb_fk_error(const trx_t *trx, dberr_t err, const char *name,
+                     const dict_foreign_t& foreign)
 {
-	va_list args;
-	THD *thd = (THD *)ithd;
-	char *buf;
-
-	if (ithd == NULL) {
-		thd = current_thd;
-	}
-
-	if (thd) {
-		va_start(args, format);
-		buf = (char *)my_malloc(PSI_INSTRUMENT_ME, MAX_BUF_SIZE, MYF(MY_WME));
-		buf[MAX_BUF_SIZE - 1] = 0;
-		vsnprintf(buf, MAX_BUF_SIZE - 1, format, args);
-
-		push_warning_printf(
-			thd, Sql_condition::WARN_LEVEL_WARN,
-			uint(convert_error_code_to_mysql(error, 0, thd)), buf);
-		my_free(buf);
-		va_end(args);
-	}
+  const int dblen= int(table_name_t(const_cast<char*>(name)).dblen());
+  std::string fk= dict_print_info_on_foreign_key_in_create_format
+    (trx, &foreign, false);
+  push_warning_printf(trx->mysql_thd, Sql_condition::WARN_LEVEL_WARN,
+                      convert_error_code_to_mysql(err, 0, nullptr),
+                      "CREATE or ALTER TABLE %`.*s.%`s failed%s%.*s",
+                      dblen, name, name + dblen + 1,
+                      err == DB_DUPLICATE_KEY
+                      ? ": duplicate name" : "",
+                      int(fk.length()), fk.data());
 }
 
 /** Helper function to push warnings from InnoDB internals to SQL-layer.
diff --git a/storage/innobase/include/btr0btr.h b/storage/innobase/include/btr0btr.h
index 35a567d7bee..999509ac337 100644
--- a/storage/innobase/include/btr0btr.h
+++ b/storage/innobase/include/btr0btr.h
@@ -83,8 +83,10 @@ btr_root_adjust_on_import(
 bool btr_root_fseg_validate(ulint offset, const buf_block_t &block,
                             const fil_space_t &space);
 
-/** Report a decryption failure. */
-ATTRIBUTE_COLD void btr_decryption_failed(const dict_index_t &index);
+/** Report a read failure if it is a decryption failure.
+@param err   error code
+@param index the index that is being accessed */
+ATTRIBUTE_COLD void btr_read_failed(dberr_t err, const dict_index_t &index);
 
 /** Get an index page and declare its latching order level.
 @param[in]	index	index tree
diff --git a/storage/innobase/include/dict0dict.h b/storage/innobase/include/dict0dict.h
index 376b24ce111..f9874056405 100644
--- a/storage/innobase/include/dict0dict.h
+++ b/storage/innobase/include/dict0dict.h
@@ -102,15 +102,9 @@ dict_table_is_partition(const dict_table_t* table)
 	return (strstr(table->name.m_name, "#p#")
 		|| strstr(table->name.m_name, "#P#"));
 }
-/********************************************************************//**
-Return the end of table name where we have removed dbname and '/'.
-@return table name */
-const char*
-dict_remove_db_name(
-/*================*/
-	const char*	name)	/*!< in: table name in the form
-				dbname '/' tablename */
-	MY_ATTRIBUTE((nonnull, warn_unused_result));
+
+#define dict_remove_db_name(name) \
+	(table_name_t{const_cast<char*>(name)}.dbend() + 1)
 
 /** Operation to perform when opening a table */
 enum dict_table_op_t {
@@ -566,15 +560,15 @@ dict_print_info_on_foreign_keys(
 	trx_t*		trx,	/*!< in: transaction */
 	dict_table_t*	table);	/*!< in: table */
 
-/**********************************************************************//**
-Outputs info on a foreign key of a table in a format suitable for
-CREATE TABLE. */
+/** Output info on a foreign key of a table in a format suitable for
+CREATE TABLE.
+@param trx          transaction
+@param foreign      constraint
+@param add_newline  whether to add a newline */
 std::string
-dict_print_info_on_foreign_key_in_create_format(
-/*============================================*/
-	trx_t*		trx,		/*!< in: transaction */
-	dict_foreign_t*	foreign,	/*!< in: foreign key constraint */
-	ibool		add_newline);	/*!< in: whether to add a newline */
+dict_print_info_on_foreign_key_in_create_format(const trx_t *trx,
+                                                const dict_foreign_t *foreign,
+                                                bool add_newline);
 
 /*********************************************************************//**
 Tries to find an index whose first fields are the columns in the array,
diff --git a/storage/innobase/include/ha_prototypes.h b/storage/innobase/include/ha_prototypes.h
index d5239ec3f9a..48ab763a2ac 100644
--- a/storage/innobase/include/ha_prototypes.h
+++ b/storage/innobase/include/ha_prototypes.h
@@ -37,6 +37,9 @@ simple headers.
 /* Forward declarations */
 class THD;
 class Field;
+struct dict_table_t;
+struct dict_foreign_t;
+struct table_name_t;
 
 // JAN: TODO missing features:
 #undef MYSQL_FT_INIT_EXT
@@ -83,7 +86,7 @@ innobase_invalidate_query_cache(
 void
 innobase_quote_identifier(
 	FILE*		file,
-	trx_t*		trx,
+	const trx_t*	trx,
 	const char*	id);
 
 /** Quote an standard SQL identifier like tablespace, index or column name.
@@ -93,7 +96,7 @@ Return the string as an std:string object.
 @return a std::string with id properly quoted. */
 std::string
 innobase_quote_identifier(
-	trx_t*		trx,
+	const trx_t*	trx,
 	const char*	id);
 
 /*****************************************************************//**
@@ -406,23 +409,20 @@ innobase_convert_to_filename_charset(
 	const char*	from,	/* in: identifier to convert */
 	ulint		len);	/* in: length of 'to', in bytes */
 
-/********************************************************************//**
-Helper function to push warnings from InnoDB internals to SQL-layer. */
-void
-ib_push_warning(
-	trx_t*		trx,	/*!< in: trx */
-	dberr_t		error,	/*!< in: error code to push as warning */
-	const char	*format,/*!< in: warning message */
-	...);
+/** Report that a table cannot be decrypted.
+@param thd    connection context
+@param table  table that cannot be decrypted
+@retval DB_DECRYPTION_FAILED (always) */
+ATTRIBUTE_COLD
+dberr_t innodb_decryption_failed(THD *thd, dict_table_t *table);
 
-/********************************************************************//**
-Helper function to push warnings from InnoDB internals to SQL-layer. */
-void
-ib_push_warning(
-	void*		ithd,	/*!< in: thd */
-	dberr_t		error,	/*!< in: error code to push as warning */
-	const char	*format,/*!< in: warning message */
-	...);
+/** Report a foreign key error.
+@param error    error to report
+@param name     table name
+@param foreign  constraint */
+ATTRIBUTE_COLD
+void innodb_fk_error(const trx_t *trx, dberr_t err, const char *name,
+                     const dict_foreign_t& foreign);
 
 /********************************************************************//**
 Helper function to push warnings from InnoDB internals to SQL-layer. */
diff --git a/storage/innobase/os/os0file.cc b/storage/innobase/os/os0file.cc
index 57e07a685ed..6ea53d80952 100644
--- a/storage/innobase/os/os0file.cc
+++ b/storage/innobase/os/os0file.cc
@@ -1088,13 +1088,11 @@ static ATTRIBUTE_COLD void os_file_log_buffered()
   log_sys.log_maybe_unbuffered= false;
   log_sys.log_buffered= true;
 }
-# endif
 
 /** @return whether the log file may work with unbuffered I/O. */
 static ATTRIBUTE_COLD bool os_file_log_maybe_unbuffered(const struct stat &st)
 {
   MSAN_STAT_WORKAROUND(&st);
-# ifdef __linux__
   char b[20 + sizeof "/sys/dev/block/" ":" "/../queue/physical_block_size"];
   if (snprintf(b, sizeof b, "/sys/dev/block/%u:%u/queue/physical_block_size",
                major(st.st_dev), minor(st.st_dev)) >=
@@ -1126,13 +1124,11 @@ static ATTRIBUTE_COLD bool os_file_log_maybe_unbuffered(const struct stat &st)
   if (s > 4096 || s < 64 || !ut_is_2pow(s))
     return false;
   log_sys.set_block_size(uint32_t(s));
-# else
-  constexpr unsigned long s= 4096;
-# endif
 
   return !(st.st_size & (s - 1));
 }
-#endif
+# endif /* __linux__ */
+#endif /* O_DIRECT */
 
 /** NOTE! Use the corresponding macro os_file_create(), not directly
 this function!
@@ -1187,7 +1183,9 @@ os_file_create_func(
 	ut_a(purpose == OS_FILE_AIO || purpose == OS_FILE_NORMAL);
 
 #ifdef O_DIRECT
+# ifdef __linux__
 	struct stat st;
+# endif
 	ut_a(type == OS_LOG_FILE
 	     || type == OS_DATA_FILE || type == OS_DATA_FILE_NO_O_DIRECT);
 	int direct_flag = 0;
diff --git a/storage/innobase/row/row0ins.cc b/storage/innobase/row/row0ins.cc
index 5918288631d..aee1ff64d3b 100644
--- a/storage/innobase/row/row0ins.cc
+++ b/storage/innobase/row/row0ins.cc
@@ -3051,7 +3051,8 @@ row_ins_sec_index_entry_low(
 
 	if (err != DB_SUCCESS) {
 		if (err == DB_DECRYPTION_FAILED) {
-			btr_decryption_failed(*index);
+			innodb_decryption_failed(thr_get_trx(thr)->mysql_thd,
+						 index->table);
 		}
 		goto func_exit;
 	}
diff --git a/storage/innobase/row/row0merge.cc b/storage/innobase/row/row0merge.cc
index 56e930417f5..2668780cf50 100644
--- a/storage/innobase/row/row0merge.cc
+++ b/storage/innobase/row/row0merge.cc
@@ -4730,13 +4730,9 @@ row_merge_build_indexes(
 	/* Do not continue if we can't encrypt table pages */
 	if (!old_table->is_readable() ||
 	    !new_table->is_readable()) {
-		error = DB_DECRYPTION_FAILED;
-		ib_push_warning(trx->mysql_thd, DB_DECRYPTION_FAILED,
-			"Table %s is encrypted but encryption service or"
-			" used key_id is not available. "
-			" Can't continue reading table.",
-			!old_table->is_readable() ? old_table->name.m_name :
-				new_table->name.m_name);
+		error = innodb_decryption_failed(trx->mysql_thd,
+						 !old_table->is_readable()
+						 ? old_table : new_table);
 		goto func_exit;
 	}
 
diff --git a/storage/innobase/row/row0mysql.cc b/storage/innobase/row/row0mysql.cc
index 4b570779742..15d959ae601 100644
--- a/storage/innobase/row/row0mysql.cc
+++ b/storage/innobase/row/row0mysql.cc
@@ -1185,51 +1185,26 @@ row_lock_table(row_prebuilt_t* prebuilt)
 	return(err);
 }
 
-/** Determine is tablespace encrypted but decryption failed, is table corrupted
-or is tablespace .ibd file missing.
-@param[in]	table		Table
-@param[in]	trx		Transaction
-@param[in]	push_warning	true if we should push warning to user
+/** Report an error for a failure to access a table.
+@param table   unreadable table
+@param trx     transaction
 @retval	DB_DECRYPTION_FAILED	table is encrypted but decryption failed
 @retval	DB_CORRUPTION		table is corrupted
 @retval	DB_TABLESPACE_NOT_FOUND	tablespace .ibd file not found */
-static
-dberr_t
-row_mysql_get_table_status(
-	const dict_table_t*	table,
-	trx_t*			trx,
-	bool 			push_warning = true)
+ATTRIBUTE_COLD
+static dberr_t row_mysql_get_table_error(trx_t *trx, dict_table_t *table)
 {
-	dberr_t err;
-	if (const fil_space_t* space = table->space) {
-		if (space->crypt_data && space->crypt_data->is_encrypted()) {
-			// maybe we cannot access the table due to failing
-			// to decrypt
-			if (push_warning) {
-				ib_push_warning(trx, DB_DECRYPTION_FAILED,
-					"Table %s is encrypted."
-					"However key management plugin or used key_id is not found or"
-					" used encryption algorithm or method does not match.",
-					table->name.m_name);
-			}
+  if (const fil_space_t *space= table->space)
+  {
+    if (space->crypt_data && space->crypt_data->is_encrypted())
+      return innodb_decryption_failed(trx->mysql_thd, table);
+    return DB_CORRUPTION;
+  }
 
-			err = DB_DECRYPTION_FAILED;
-		} else {
-			if (push_warning) {
-				ib_push_warning(trx, DB_CORRUPTION,
-					"Table %s in tablespace %lu corrupted.",
-					table->name.m_name, table->space);
-			}
-
-			err = DB_CORRUPTION;
-		}
-	} else {
-		ib::error() << ".ibd file is missing for table "
-			<< table->name;
-		err = DB_TABLESPACE_NOT_FOUND;
-	}
-
-	return(err);
+  const int dblen= int(table->name.dblen());
+  sql_print_error("InnoDB .ibd file is missing for table %`.*s.%`s",
+                  dblen, table->name.m_name, table->name.m_name + dblen + 1);
+  return DB_TABLESPACE_NOT_FOUND;
 }
 
 /** Does an insert for MySQL.
@@ -1265,7 +1240,7 @@ row_insert_for_mysql(
 
 		return(DB_TABLESPACE_DELETED);
 	} else if (!table->is_readable()) {
-		return row_mysql_get_table_status(table, trx, true);
+		return row_mysql_get_table_error(trx, table);
 	} else if (high_level_read_only) {
 		return(DB_READ_ONLY);
 	} else if (UNIV_UNLIKELY(table->corrupted)
@@ -1622,7 +1597,7 @@ row_update_for_mysql(row_prebuilt_t* prebuilt)
 	ut_ad(table->stat_initialized);
 
 	if (!table->is_readable()) {
-		return(row_mysql_get_table_status(table, trx, true));
+		return row_mysql_get_table_error(trx, table);
 	}
 
 	if (high_level_read_only) {
diff --git a/storage/innobase/row/row0sel.cc b/storage/innobase/row/row0sel.cc
index 970dce3c90d..4442f6f43ba 100644
--- a/storage/innobase/row/row0sel.cc
+++ b/storage/innobase/row/row0sel.cc
@@ -4844,7 +4844,8 @@ page_corrupted:
 
 		if (err != DB_SUCCESS) {
 			if (err == DB_DECRYPTION_FAILED) {
-				btr_decryption_failed(*index);
+				innodb_decryption_failed(trx->mysql_thd,
+							 index->table);
 			}
 			rec = NULL;
 			goto page_read_error;
diff --git a/storage/maria/aria_s3_copy.cc b/storage/maria/aria_s3_copy.cc
index 6dfe7572a3f..d47812498aa 100644
--- a/storage/maria/aria_s3_copy.cc
+++ b/storage/maria/aria_s3_copy.cc
@@ -43,7 +43,10 @@ static const char *opt_database;
 static const char *opt_s3_bucket="MariaDB";
 static my_bool opt_compression, opt_verbose, opt_force, opt_s3_debug;
 static my_bool opt_s3_use_http;
+static my_bool opt_s3_ssl_no_verify;
+static my_bool opt_s3_no_content_type;
 static ulong opt_operation= OP_IMPOSSIBLE, opt_protocol_version= 1;
+static ulong opt_provider= 0;
 static ulong opt_block_size;
 static ulong opt_s3_port;
 static char **default_argv=0;
@@ -75,6 +78,13 @@ static struct my_option my_long_options[] =
   {"s3_use_http", 'P', "If true, force use of HTTP protocol",
    (char**) &opt_s3_use_http, (char**) &opt_s3_use_http,
    0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
+  {"s3_ssl_no_verify", 's', "If true, verification of the S3 endpoint SSL "
+   "certificate is disabled",
+   (char**) &opt_s3_ssl_no_verify, (char**) &opt_s3_ssl_no_verify,
+   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
+  {"s3_no_content_type", 'n', "If true, disables the Content-Type header",
+   (char**) &opt_s3_no_content_type, (char**) &opt_s3_no_content_type,
+   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
   {"compress", 'c', "Use compression", &opt_compression, &opt_compression,
    0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
   {"op", 'o', "Operation to execute. One of 'from_s3', 'to_s3' or "
@@ -94,6 +104,10 @@ static struct my_option my_long_options[] =
    "Note: \"Legacy\", \"Original\" and \"Amazon\" are deprecated.",
    &opt_protocol_version, &opt_protocol_version, &s3_protocol_typelib,
    GET_ENUM, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"s3_provider", 'R', "Enable S3 provider specific compatibility tweaks "
+   "\"Default\", \"Amazon\", or \"Huawei\".",
+   &opt_provider, &opt_provider, &s3_provider_typelib,
+   GET_ENUM, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
   {"force", 'f', "Force copy even if target exists",
    &opt_force, &opt_force, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
   {"verbose", 'v', "Write more information", &opt_verbose, &opt_verbose,
@@ -216,6 +230,19 @@ int main(int argc, char** argv)
 
   ms3_set_option(global_s3_client, MS3_OPT_BUFFER_CHUNK_SIZE, &block_size);
 
+  /* Provider specific overrides */
+  switch (opt_provider)
+  {
+    case 0: /* Default */
+      break;
+    case 1: /* Amazon */
+      opt_protocol_version = 5;
+      break;
+    case 2: /* Huawei */
+      opt_s3_no_content_type = 1;
+      break;
+  }
+
   if (opt_protocol_version > 2)
   {
     uint8_t protocol_version;
@@ -241,6 +268,11 @@ int main(int argc, char** argv)
   if (opt_s3_use_http)
     ms3_set_option(global_s3_client, MS3_OPT_USE_HTTP, NULL);
 
+  if (opt_s3_ssl_no_verify)
+    ms3_set_option(global_s3_client, MS3_OPT_DISABLE_SSL_VERIFY, NULL);
+
+  if (opt_s3_no_content_type)
+    ms3_set_option(global_s3_client, MS3_OPT_NO_CONTENT_TYPE, NULL);
 
   for (; *argv ; argv++)
   {
diff --git a/storage/maria/ha_s3.cc b/storage/maria/ha_s3.cc
index 50611f64712..ac511d47319 100644
--- a/storage/maria/ha_s3.cc
+++ b/storage/maria/ha_s3.cc
@@ -78,7 +78,7 @@
 #define DEFAULT_AWS_HOST_NAME "s3.amazonaws.com"
 
 static PAGECACHE s3_pagecache;
-static ulong s3_block_size, s3_protocol_version;
+static ulong s3_block_size, s3_protocol_version, s3_provider;
 static ulong s3_pagecache_division_limit, s3_pagecache_age_threshold;
 static ulong s3_pagecache_file_hash_size;
 static ulonglong s3_pagecache_buffer_size;
@@ -86,6 +86,8 @@ static char *s3_bucket, *s3_access_key=0, *s3_secret_key=0, *s3_region;
 static char *s3_host_name;
 static int s3_port;
 static my_bool s3_use_http;
+static my_bool s3_ssl_no_verify;
+static my_bool s3_no_content_type;
 static char *s3_tmp_access_key=0, *s3_tmp_secret_key=0;
 static my_bool s3_debug= 0, s3_slave_ignore_updates= 0;
 static my_bool s3_replicate_alter_as_create_select= 0;
@@ -222,6 +224,10 @@ static MYSQL_SYSVAR_BOOL(use_http, s3_use_http,
        PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
       "If true, force use of HTTP protocol",
        NULL /*check*/, NULL /*update*/, 0 /*default*/);
+static MYSQL_SYSVAR_BOOL(ssl_no_verify, s3_ssl_no_verify,
+       PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+      "If true, SSL certificate verifiction for the S3 endpoint is disabled",
+       NULL, NULL, 0);
 static MYSQL_SYSVAR_STR(access_key, s3_tmp_access_key,
        PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY | PLUGIN_VAR_MEMALLOC,
       "AWS access key",
@@ -234,6 +240,15 @@ static MYSQL_SYSVAR_STR(region, s3_region,
        PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
       "AWS region",
        0, 0, "");
+static MYSQL_SYSVAR_BOOL(no_content_type, s3_no_content_type,
+       PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+      "If true, disables the Content-Type header, required for some providers",
+      NULL, NULL, 0);
+static MYSQL_SYSVAR_ENUM(provider, s3_provider,
+                         PLUGIN_VAR_RQCMDARG,
+                         "Enable S3 provider specific compatibility tweaks "
+                         "\"Default\", \"Amazon\", or \"Huawei\". ",
+                         NULL, NULL, 0, &s3_provider_typelib);
 
 ha_create_table_option s3_table_option_list[]=
 {
@@ -320,6 +335,9 @@ static my_bool s3_info_init(S3_INFO *info)
   lex_string_set(&info->host_name,  s3_host_name);
   info->port= s3_port;
   info->use_http= s3_use_http;
+  info->ssl_no_verify= s3_ssl_no_verify;
+  info->no_content_type = s3_no_content_type;
+  info->provider= s3_provider;
   lex_string_set(&info->access_key, s3_access_key);
   lex_string_set(&info->secret_key, s3_secret_key);
   lex_string_set(&info->region,     s3_region);
@@ -1121,12 +1139,15 @@ static struct st_mysql_sys_var* system_variables[]= {
   MYSQL_SYSVAR(host_name),
   MYSQL_SYSVAR(port),
   MYSQL_SYSVAR(use_http),
+  MYSQL_SYSVAR(ssl_no_verify),
   MYSQL_SYSVAR(bucket),
   MYSQL_SYSVAR(access_key),
   MYSQL_SYSVAR(secret_key),
   MYSQL_SYSVAR(region),
   MYSQL_SYSVAR(slave_ignore_updates),
   MYSQL_SYSVAR(replicate_alter_as_create_select),
+  MYSQL_SYSVAR(no_content_type),
+  MYSQL_SYSVAR(provider),
   NULL
 };
 
diff --git a/storage/maria/libmarias3 b/storage/maria/libmarias3
index a81724ab07b..5e6aa32f96e 160000
--- a/storage/maria/libmarias3
+++ b/storage/maria/libmarias3
@@ -1 +1 @@
-Subproject commit a81724ab07bd28e16bf431419c24b6362d5894fc
+Subproject commit 5e6aa32f96ebdbcaf32b90d6182685156f8198b5
diff --git a/storage/maria/s3_func.c b/storage/maria/s3_func.c
index d85dc8a0b40..b8918c48d4b 100644
--- a/storage/maria/s3_func.c
+++ b/storage/maria/s3_func.c
@@ -43,6 +43,9 @@ static const char *protocol_types[]= {"Auto", "Original", "Amazon", "Legacy", "P
 TYPELIB s3_protocol_typelib= {array_elements(protocol_types)-1,"",
                               protocol_types, NULL};
 
+static const char *providers[]= {"Default", "Amazon", "Huawei", NullS};
+TYPELIB s3_provider_typelib = {array_elements(providers)-1,"",providers, NULL};
+
 /******************************************************************************
  Allocations handler for libmarias3
  To be removed when we do the init allocation in mysqld.cc
@@ -154,6 +157,20 @@ ms3_st *s3_open_connection(S3_INFO *s3)
                     errno, ms3_error(errno));
     my_errno= HA_ERR_NO_SUCH_TABLE;
   }
+
+  /* Provider specific overrides */
+  switch (s3->provider)
+  {
+    case 0: /* Default */
+      break;
+    case 1: /* Amazon */
+      s3->protocol_version = 5;
+      break;
+    case 2: /* Huawei */
+      s3->no_content_type = 1;
+      break;
+  }
+
   if (s3->protocol_version > 2)
   {
     uint8_t protocol_version;
@@ -177,6 +194,12 @@ ms3_st *s3_open_connection(S3_INFO *s3)
   if (s3->use_http)
     ms3_set_option(s3_client, MS3_OPT_USE_HTTP, NULL);
 
+  if (s3->ssl_no_verify)
+    ms3_set_option(s3_client, MS3_OPT_DISABLE_SSL_VERIFY, NULL);
+
+  if (s3->no_content_type)
+    ms3_set_option(s3_client, MS3_OPT_NO_CONTENT_TYPE, NULL);
+
   return s3_client;
 }
 
diff --git a/storage/maria/s3_func.h b/storage/maria/s3_func.h
index f73a95dea24..9c0831b158d 100644
--- a/storage/maria/s3_func.h
+++ b/storage/maria/s3_func.h
@@ -38,6 +38,7 @@ extern struct s3_func {
 } s3f;
 
 extern TYPELIB s3_protocol_typelib;
+extern TYPELIB s3_provider_typelib;
 
 /* Store information about a s3 connection */
 
@@ -47,6 +48,8 @@ struct s3_info
   LEX_CSTRING access_key, secret_key, region, bucket, host_name;
   int port; // 0 means 'Use default'
   my_bool use_http;
+  my_bool ssl_no_verify;
+  my_bool no_content_type;
 
   /* Will be set by caller or by ma_open() */
   LEX_CSTRING database, table;
@@ -63,6 +66,8 @@ struct s3_info
 
   /* Protocol for the list bucket API call. 1 for Amazon, 2 for some others */
   uint8_t protocol_version;
+
+  uint8_t provider;
 };
 
 
diff --git a/storage/spider/ha_spider.cc b/storage/spider/ha_spider.cc
index 51e214f848e..b1792e28f98 100644
--- a/storage/spider/ha_spider.cc
+++ b/storage/spider/ha_spider.cc
@@ -21,7 +21,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "sql_class.h"
@@ -1164,13 +1163,7 @@ int ha_spider::extra(
       if (!(wide_handler->trx = spider_get_trx(ha_thd(), TRUE, &error_num)))
         DBUG_RETURN(error_num);
       break;
-#if defined(HA_EXTRA_HAS_STARTING_ORDERED_INDEX_SCAN) || defined(HA_EXTRA_HAS_HA_EXTRA_USE_CMP_REF)
-#ifdef HA_EXTRA_HAS_STARTING_ORDERED_INDEX_SCAN
     case HA_EXTRA_STARTING_ORDERED_INDEX_SCAN:
-#endif
-#ifdef HA_EXTRA_HAS_HA_EXTRA_USE_CMP_REF
-    case HA_EXTRA_USE_CMP_REF:
-#endif
       DBUG_PRINT("info",("spider HA_EXTRA_STARTING_ORDERED_INDEX_SCAN"));
       if (table_share->primary_key != MAX_KEY)
       {
@@ -1198,7 +1191,6 @@ int ha_spider::extra(
         }
       }
       break;
-#endif
     default:
       break;
   }
@@ -1268,24 +1260,160 @@ int ha_spider::index_end()
   DBUG_ENTER("ha_spider::index_end");
   DBUG_PRINT("info",("spider this=%p", this));
   active_index = MAX_KEY;
-/*
-#ifdef INFO_KIND_FORCE_LIMIT_BEGIN
-  info_limit = 9223372036854775807LL;
-#endif
-  if (
-    (error_num = drop_tmp_tables()) ||
-    (error_num = check_and_end_bulk_update(
-      SPD_BU_START_BY_INDEX_OR_RND_INIT)) ||
-    (error_num = spider_trx_check_link_idx_failed(this))
-  )
-    DBUG_RETURN(check_error_mode(error_num));
-*/
   if ((error_num = drop_tmp_tables()))
     DBUG_RETURN(check_error_mode(error_num));
   result_list.use_union = FALSE;
   DBUG_RETURN(0);
 }
 
+static int spider_maybe_ping(ha_spider *spider, int link_idx, int error_num)
+{
+  if (
+    spider->share->monitoring_kind[link_idx] &&
+    spider->need_mons[link_idx]
+  ) {
+    error_num = spider_ping_table_mon_from_table(
+      spider->wide_handler->trx,
+      spider->wide_handler->trx->thd,
+      spider->share,
+      link_idx,
+      (uint32) spider->share->monitoring_sid[link_idx],
+      spider->share->table_name,
+      spider->share->table_name_length,
+      spider->conn_link_idx[link_idx],
+      NULL,
+      0,
+      spider->share->monitoring_kind[link_idx],
+      spider->share->monitoring_limit[link_idx],
+      spider->share->monitoring_flag[link_idx],
+      TRUE
+    );
+  }
+  return spider->check_error_mode_eof(error_num);
+}
+
+static int spider_maybe_ping_1(ha_spider *spider,
+                             int link_idx, int error_num)
+{
+  if (
+    spider->share->monitoring_kind[link_idx] &&
+    spider->need_mons[link_idx]
+  ) {
+    error_num = spider_ping_table_mon_from_table(
+      spider->wide_handler->trx,
+      spider->wide_handler->trx->thd,
+      spider->share,
+      link_idx,
+      (uint32) spider->share->monitoring_sid[link_idx],
+      spider->share->table_name,
+      spider->share->table_name_length,
+      spider->conn_link_idx[link_idx],
+      NULL,
+      0,
+      spider->share->monitoring_kind[link_idx],
+      spider->share->monitoring_limit[link_idx],
+      spider->share->monitoring_flag[link_idx],
+      TRUE
+    );
+  }
+  return error_num;
+}
+
+static void spider_prep_loop(ha_spider *spider, int *roop_start, int *roop_end, int *link_ok)
+{
+  int lock_mode = spider_conn_lock_mode(spider);
+  if (lock_mode)
+  {
+    /* "for update" or "lock in share mode" */
+    *link_ok = spider_conn_link_idx_next(spider->share->link_statuses,
+      spider->conn_link_idx, -1, spider->share->link_count,
+      SPIDER_LINK_STATUS_OK);
+    *roop_start = spider_conn_link_idx_next(spider->share->link_statuses,
+      spider->conn_link_idx, -1, spider->share->link_count,
+      SPIDER_LINK_STATUS_RECOVERY);
+    *roop_end = spider->share->link_count;
+  } else {
+    *link_ok = spider->search_link_idx;
+    *roop_start = spider->search_link_idx;
+    *roop_end = spider->search_link_idx + 1;
+  }
+}
+
+/* Returns true if the caller should return *error_num */
+static bool spider_start_bg(ha_spider* spider, int roop_count, int roop_start, int link_ok, int *error_num)
+{
+  if ((*error_num = spider_check_and_init_casual_read(
+         spider->wide_handler->trx->thd, spider,
+         roop_count)))
+    return true;
+  if ((*error_num = spider_bg_conn_search(spider, roop_count, roop_start,
+                                          TRUE, FALSE, (roop_count != link_ok))))
+  {
+    if (
+      *error_num != HA_ERR_END_OF_FILE
+    ) {
+      *error_num= spider_maybe_ping(spider, roop_count, *error_num);
+      return true;
+    }
+    *error_num= spider->check_error_mode_eof(*error_num);
+    return true;
+  }
+  return false;
+}
+
+/* Updates error_num. Returning true if the caller should return. */
+static bool spider_send_query(ha_spider *spider, TABLE *table, int link_idx, int link_ok, int *error_num)
+{
+  ulong sql_type;
+  SPIDER_CONN *conn = spider->conns[link_idx];
+  sql_type = SPIDER_SQL_TYPE_SELECT_SQL;
+  spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
+  if ((*error_num = dbton_hdl->set_sql_for_exec(sql_type, link_idx)))
+  {
+    return true;
+  }
+  DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
+  spider_lock_before_query(conn, &spider->need_mons[link_idx]);
+  if ((*error_num = spider_db_set_names(spider, conn,
+                                        link_idx)))
+  {
+    spider_unlock_after_query(conn, 0);
+    *error_num= spider_maybe_ping(spider, link_idx, *error_num);
+    return true;
+  }
+  spider_conn_set_timeout_from_share(conn, link_idx,
+                                     spider->wide_handler->trx->thd, spider->share);
+  if (dbton_hdl->execute_sql(
+        sql_type,
+        conn,
+        spider->result_list.quick_mode,
+        &spider->need_mons[link_idx])
+  ) {
+    *error_num= spider_unlock_after_query_1(conn);
+    *error_num= (spider_maybe_ping(spider, link_idx, *error_num));
+    return true;
+  }
+  spider->connection_ids[link_idx] = conn->connection_id;
+  if (link_idx == link_ok)
+  {
+    if ((*error_num = spider_unlock_after_query_2(conn, spider, link_idx, table)))
+    {
+      if (
+        *error_num != HA_ERR_END_OF_FILE
+      ) {
+        *error_num= spider_maybe_ping(spider, link_idx, *error_num);
+        return true;
+      }
+      *error_num= spider->check_error_mode_eof(*error_num);
+      return true;
+    }
+    spider->result_link_idx = link_ok;
+  } else {
+    spider_db_discard_result(spider, link_idx, conn);
+    spider_unlock_after_query(conn, 0);
+  }
+  return false;
+}
 
 int ha_spider::index_read_map_internal(
   uchar *buf,
@@ -1293,9 +1421,8 @@ int ha_spider::index_read_map_internal(
   key_part_map keypart_map,
   enum ha_rkey_function find_flag
 ) {
-  int error_num, roop_count;
+  int error_num;
   key_range start_key;
-  SPIDER_CONN *conn;
   backup_error_status();
   DBUG_ENTER("ha_spider::index_read_map_internal");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -1323,6 +1450,7 @@ int ha_spider::index_read_map_internal(
   start_key.key = key;
   start_key.keypart_map = keypart_map;
   start_key.flag = find_flag;
+  /* Query construction */
   if ((error_num= reset_sql_sql(SPIDER_SQL_TYPE_SELECT_SQL)))
     DBUG_RETURN(error_num);
   if ((error_num = spider_set_conn_bg_param(this)))
@@ -1398,23 +1526,8 @@ int ha_spider::index_read_map_internal(
     }
   }
 
-  int roop_start, roop_end, lock_mode, link_ok;
-  lock_mode = spider_conn_lock_mode(this);
-  if (lock_mode)
-  {
-    /* "for update" or "lock in share mode" */
-    link_ok = spider_conn_link_idx_next(share->link_statuses,
-      conn_link_idx, -1, share->link_count,
-      SPIDER_LINK_STATUS_OK);
-    roop_start = spider_conn_link_idx_next(share->link_statuses,
-      conn_link_idx, -1, share->link_count,
-      SPIDER_LINK_STATUS_RECOVERY);
-    roop_end = share->link_count;
-  } else {
-    link_ok = search_link_idx;
-    roop_start = search_link_idx;
-    roop_end = search_link_idx + 1;
-  }
+  int roop_start, roop_end, roop_count, link_ok;
+  spider_prep_loop(this, &roop_start, &roop_end, &link_ok);
   for (roop_count = roop_start; roop_count < roop_end;
     roop_count = spider_conn_link_idx_next(share->link_statuses,
       conn_link_idx, roop_count, share->link_count,
@@ -1422,162 +1535,11 @@ int ha_spider::index_read_map_internal(
   ) {
     if (result_list.bgs_phase > 0)
     {
-      if ((error_num = spider_check_and_init_casual_read(
-        wide_handler->trx->thd, this,
-        roop_count)))
+      if (spider_start_bg(this, roop_count, roop_start, link_ok, &error_num))
         DBUG_RETURN(error_num);
-      if ((error_num = spider_bg_conn_search(this, roop_count, roop_start,
-        TRUE, FALSE, (roop_count != link_ok))))
-      {
-        if (
-          error_num != HA_ERR_END_OF_FILE &&
-          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_eof(error_num));
-      }
     } else {
-      ulong sql_type;
-      conn= conns[roop_count];
-      sql_type= SPIDER_SQL_TYPE_SELECT_SQL;
-      spider_db_handler *dbton_hdl = dbton_handler[conn->dbton_id];
-      pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-      if ((error_num = dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
-      {
+      if (spider_send_query(this, table, roop_count, link_ok, &error_num))
         DBUG_RETURN(error_num);
-      }
-      pthread_mutex_lock(&conn->mta_conn_mutex);
-      SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
-        conn->need_mon = &need_mons[roop_count];
-        DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = TRUE;
-        conn->mta_conn_mutex_unlock_later = TRUE;
-        if ((error_num = spider_db_set_names(this, conn,
-          roop_count)))
-        {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
-          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_eof(error_num));
-        }
-        spider_conn_set_timeout_from_share(conn, roop_count,
-          wide_handler->trx->thd, share);
-        if (dbton_hdl->execute_sql(
-          sql_type,
-          conn,
-          result_list.quick_mode,
-          &need_mons[roop_count])
-        ) {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          error_num = spider_db_errorno(conn);
-          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_eof(error_num));
-        }
-        connection_ids[roop_count] = conn->connection_id;
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        if (roop_count == link_ok)
-        {
-          if ((error_num = spider_db_store_result(this, roop_count, table)))
-          {
-            if (
-              error_num != HA_ERR_END_OF_FILE &&
-              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_eof(error_num));
-          }
-          result_link_idx = link_ok;
-        } else {
-          spider_db_discard_result(this, roop_count, conn);
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
-        }
     }
   }
   if (buf && (error_num = spider_db_fetch(buf, this, table)))
@@ -1641,7 +1603,6 @@ int ha_spider::index_read_last_map_internal(
 ) {
   int error_num;
   key_range start_key;
-  SPIDER_CONN *conn;
   backup_error_status();
   DBUG_ENTER("ha_spider::index_read_last_map_internal");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -1734,23 +1695,8 @@ int ha_spider::index_read_last_map_internal(
     }
   }
 
-  int roop_start, roop_end, roop_count, tmp_lock_mode, link_ok;
-  tmp_lock_mode = spider_conn_lock_mode(this);
-  if (tmp_lock_mode)
-  {
-    /* "for update" or "lock in share mode" */
-    link_ok = spider_conn_link_idx_next(share->link_statuses,
-      conn_link_idx, -1, share->link_count,
-      SPIDER_LINK_STATUS_OK);
-    roop_start = spider_conn_link_idx_next(share->link_statuses,
-      conn_link_idx, -1, share->link_count,
-      SPIDER_LINK_STATUS_RECOVERY);
-    roop_end = share->link_count;
-  } else {
-    link_ok = search_link_idx;
-    roop_start = search_link_idx;
-    roop_end = search_link_idx + 1;
-  }
+  int roop_start, roop_end, roop_count, link_ok;
+  spider_prep_loop(this, &roop_start, &roop_end, &link_ok);
   for (roop_count = roop_start; roop_count < roop_end;
     roop_count = spider_conn_link_idx_next(share->link_statuses,
       conn_link_idx, roop_count, share->link_count,
@@ -1758,162 +1704,11 @@ int ha_spider::index_read_last_map_internal(
   ) {
     if (result_list.bgs_phase > 0)
     {
-      if ((error_num = spider_check_and_init_casual_read(
-        wide_handler->trx->thd, this,
-        roop_count)))
+      if (spider_start_bg(this, roop_count, roop_start, link_ok, &error_num))
         DBUG_RETURN(error_num);
-      if ((error_num = spider_bg_conn_search(this, roop_count, roop_start,
-        TRUE, FALSE, (roop_count != link_ok))))
-      {
-        if (
-          error_num != HA_ERR_END_OF_FILE &&
-          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_eof(error_num));
-      }
     } else {
-      ulong sql_type;
-      conn= conns[roop_count];
-      sql_type= SPIDER_SQL_TYPE_SELECT_SQL;
-      spider_db_handler *dbton_hdl = dbton_handler[conn->dbton_id];
-      pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-      if ((error_num = dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
-      {
+      if (spider_send_query(this, table, roop_count, link_ok, &error_num))
         DBUG_RETURN(error_num);
-      }
-      pthread_mutex_lock(&conn->mta_conn_mutex);
-      SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
-        conn->need_mon = &need_mons[roop_count];
-        DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = TRUE;
-        conn->mta_conn_mutex_unlock_later = TRUE;
-        if ((error_num = spider_db_set_names(this, conn,
-          roop_count)))
-        {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
-          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_eof(error_num));
-        }
-        spider_conn_set_timeout_from_share(conn, roop_count,
-          wide_handler->trx->thd, share);
-        if (dbton_hdl->execute_sql(
-          sql_type,
-          conn,
-          result_list.quick_mode,
-          &need_mons[roop_count])
-        ) {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          error_num = spider_db_errorno(conn);
-          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_eof(error_num));
-        }
-        connection_ids[roop_count] = conn->connection_id;
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        if (roop_count == link_ok)
-        {
-          if ((error_num = spider_db_store_result(this, roop_count, table)))
-          {
-            if (
-              error_num != HA_ERR_END_OF_FILE &&
-              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_eof(error_num));
-          }
-          result_link_idx = link_ok;
-        } else {
-          spider_db_discard_result(this, roop_count, conn);
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
-        }
     }
   }
   if (buf && (error_num = spider_db_fetch(buf, this, table)))
@@ -2028,7 +1823,6 @@ int ha_spider::index_first_internal(
   uchar *buf
 ) {
   int error_num;
-  SPIDER_CONN *conn;
   backup_error_status();
   DBUG_ENTER("ha_spider::index_first_internal");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -2116,187 +1910,20 @@ int ha_spider::index_first_internal(
       }
     }
 
-    int roop_start, roop_end, roop_count, tmp_lock_mode, link_ok;
-    tmp_lock_mode = spider_conn_lock_mode(this);
-    if (tmp_lock_mode)
-    {
-      /* "for update" or "lock in share mode" */
-      link_ok = spider_conn_link_idx_next(share->link_statuses,
-        conn_link_idx, -1, share->link_count,
-        SPIDER_LINK_STATUS_OK);
-      roop_start = spider_conn_link_idx_next(share->link_statuses,
-        conn_link_idx, -1, share->link_count,
-        SPIDER_LINK_STATUS_RECOVERY);
-      roop_end = share->link_count;
-    } else {
-      link_ok = search_link_idx;
-      roop_start = search_link_idx;
-      roop_end = search_link_idx + 1;
-    }
+    int roop_start, roop_end, roop_count, link_ok;
+    spider_prep_loop(this, &roop_start, &roop_end, &link_ok);
     for (roop_count = roop_start; roop_count < roop_end;
       roop_count = spider_conn_link_idx_next(share->link_statuses,
         conn_link_idx, roop_count, share->link_count,
         SPIDER_LINK_STATUS_RECOVERY)
     ) {
-      if (result_list.bgs_phase > 0)
-      {
-        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,
-          TRUE, FALSE, (roop_count != link_ok))))
-        {
-          if (
-            error_num != HA_ERR_END_OF_FILE &&
-            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_eof(error_num));
-        }
-      } else {
-        ulong sql_type;
-        conn= conns[roop_count];
-        sql_type= SPIDER_SQL_TYPE_SELECT_SQL;
-        spider_db_handler *dbton_hdl = dbton_handler[conn->dbton_id];
-        pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-        if ((error_num =
-          dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
-        {
-          DBUG_RETURN(error_num);
-        }
-        pthread_mutex_lock(&conn->mta_conn_mutex);
-        SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
-          conn->need_mon = &need_mons[roop_count];
-          DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = TRUE;
-          conn->mta_conn_mutex_unlock_later = TRUE;
-          if ((error_num = spider_db_set_names(this, conn,
-            roop_count)))
-          {
-            DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-            conn->mta_conn_mutex_lock_already = FALSE;
-            conn->mta_conn_mutex_unlock_later = FALSE;
-            SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-            pthread_mutex_unlock(&conn->mta_conn_mutex);
-            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_eof(error_num));
-          }
-          spider_conn_set_timeout_from_share(conn, roop_count,
-            wide_handler->trx->thd, share);
-          if (dbton_hdl->execute_sql(
-            sql_type,
-            conn,
-            result_list.quick_mode,
-            &need_mons[roop_count])
-          ) {
-            DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-            conn->mta_conn_mutex_lock_already = FALSE;
-            conn->mta_conn_mutex_unlock_later = FALSE;
-            error_num = spider_db_errorno(conn);
-            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_eof(error_num));
-          }
-          connection_ids[roop_count] = conn->connection_id;
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          if (roop_count == link_ok)
-          {
-            if ((error_num = spider_db_store_result(this, roop_count, table)))
-            {
-              if (
-                error_num != HA_ERR_END_OF_FILE &&
-                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_eof(error_num));
-            }
-            result_link_idx = link_ok;
-          } else {
-            spider_db_discard_result(this, roop_count, conn);
-            SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-            pthread_mutex_unlock(&conn->mta_conn_mutex);
-          }
+    if (result_list.bgs_phase > 0)
+    {
+      if (spider_start_bg(this, roop_count, roop_start, link_ok, &error_num))
+        DBUG_RETURN(error_num);
+    } else {
+      if (spider_send_query(this, table, roop_count, link_ok, &error_num))
+        DBUG_RETURN(error_num);
       }
     }
   }
@@ -2358,7 +1985,6 @@ int ha_spider::index_last_internal(
   uchar *buf
 ) {
   int error_num;
-  SPIDER_CONN *conn;
   backup_error_status();
   DBUG_ENTER("ha_spider::index_last_internal");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -2446,187 +2072,20 @@ int ha_spider::index_last_internal(
       }
     }
 
-    int roop_start, roop_end, roop_count, tmp_lock_mode, link_ok;
-    tmp_lock_mode = spider_conn_lock_mode(this);
-    if (tmp_lock_mode)
-    {
-      /* "for update" or "lock in share mode" */
-      link_ok = spider_conn_link_idx_next(share->link_statuses,
-        conn_link_idx, -1, share->link_count,
-        SPIDER_LINK_STATUS_OK);
-      roop_start = spider_conn_link_idx_next(share->link_statuses,
-        conn_link_idx, -1, share->link_count,
-        SPIDER_LINK_STATUS_RECOVERY);
-      roop_end = share->link_count;
-    } else {
-      link_ok = search_link_idx;
-      roop_start = search_link_idx;
-      roop_end = search_link_idx + 1;
-    }
+    int roop_start, roop_end, roop_count, link_ok;
+    spider_prep_loop(this, &roop_start, &roop_end, &link_ok);
     for (roop_count = roop_start; roop_count < roop_end;
       roop_count = spider_conn_link_idx_next(share->link_statuses,
         conn_link_idx, roop_count, share->link_count,
         SPIDER_LINK_STATUS_RECOVERY)
     ) {
-      if (result_list.bgs_phase > 0)
-      {
-        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,
-          TRUE, FALSE, (roop_count != link_ok))))
-        {
-          if (
-            error_num != HA_ERR_END_OF_FILE &&
-            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_eof(error_num));
-        }
-      } else {
-        ulong sql_type;
-        conn= conns[roop_count];
-        sql_type= SPIDER_SQL_TYPE_SELECT_SQL;
-        spider_db_handler *dbton_hdl = dbton_handler[conn->dbton_id];
-        pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-        if ((error_num =
-          dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
-        {
-          DBUG_RETURN(error_num);
-        }
-        pthread_mutex_lock(&conn->mta_conn_mutex);
-        SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
-          conn->need_mon = &need_mons[roop_count];
-          DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = TRUE;
-          conn->mta_conn_mutex_unlock_later = TRUE;
-          if ((error_num = spider_db_set_names(this, conn,
-            roop_count)))
-          {
-            DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-            conn->mta_conn_mutex_lock_already = FALSE;
-            conn->mta_conn_mutex_unlock_later = FALSE;
-            SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-            pthread_mutex_unlock(&conn->mta_conn_mutex);
-            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_eof(error_num));
-          }
-          spider_conn_set_timeout_from_share(conn, roop_count,
-            wide_handler->trx->thd, share);
-          if (dbton_hdl->execute_sql(
-            sql_type,
-            conn,
-            result_list.quick_mode,
-            &need_mons[roop_count])
-          ) {
-            DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-            conn->mta_conn_mutex_lock_already = FALSE;
-            conn->mta_conn_mutex_unlock_later = FALSE;
-            error_num = spider_db_errorno(conn);
-            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_eof(error_num));
-          }
-          connection_ids[roop_count] = conn->connection_id;
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          if (roop_count == link_ok)
-          {
-            if ((error_num = spider_db_store_result(this, roop_count, table)))
-            {
-              if (
-                error_num != HA_ERR_END_OF_FILE &&
-                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_eof(error_num));
-            }
-            result_link_idx = link_ok;
-          } else {
-            spider_db_discard_result(this, roop_count, conn);
-            SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-            pthread_mutex_unlock(&conn->mta_conn_mutex);
-          }
+    if (result_list.bgs_phase > 0)
+    {
+      if (spider_start_bg(this, roop_count, roop_start, link_ok, &error_num))
+        DBUG_RETURN(error_num);
+    } else {
+      if (spider_send_query(this, table, roop_count, link_ok, &error_num))
+        DBUG_RETURN(error_num);
       }
     }
   }
@@ -2725,7 +2184,6 @@ int ha_spider::read_range_first_internal(
   bool sorted
 ) {
   int error_num;
-  SPIDER_CONN *conn;
   backup_error_status();
   DBUG_ENTER("ha_spider::read_range_first_internal");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -2822,23 +2280,8 @@ int ha_spider::read_range_first_internal(
     }
   }
 
-  int roop_start, roop_end, roop_count, tmp_lock_mode, link_ok;
-  tmp_lock_mode = spider_conn_lock_mode(this);
-  if (tmp_lock_mode)
-  {
-    /* "for update" or "lock in share mode" */
-    link_ok = spider_conn_link_idx_next(share->link_statuses,
-      conn_link_idx, -1, share->link_count,
-      SPIDER_LINK_STATUS_OK);
-    roop_start = spider_conn_link_idx_next(share->link_statuses,
-      conn_link_idx, -1, share->link_count,
-      SPIDER_LINK_STATUS_RECOVERY);
-    roop_end = share->link_count;
-  } else {
-    link_ok = search_link_idx;
-    roop_start = search_link_idx;
-    roop_end = search_link_idx + 1;
-  }
+  int roop_start, roop_end, roop_count, link_ok;
+  spider_prep_loop(this, &roop_start, &roop_end, &link_ok);
   for (roop_count = roop_start; roop_count < roop_end;
     roop_count = spider_conn_link_idx_next(share->link_statuses,
       conn_link_idx, roop_count, share->link_count,
@@ -2846,162 +2289,11 @@ int ha_spider::read_range_first_internal(
   ) {
     if (result_list.bgs_phase > 0)
     {
-      if ((error_num = spider_check_and_init_casual_read(
-        wide_handler->trx->thd, this,
-        roop_count)))
+      if (spider_start_bg(this, roop_count, roop_start, link_ok, &error_num))
         DBUG_RETURN(error_num);
-      if ((error_num = spider_bg_conn_search(this, roop_count, roop_start,
-        TRUE, FALSE, (roop_count != link_ok))))
-      {
-        if (
-          error_num != HA_ERR_END_OF_FILE &&
-          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_eof(error_num));
-      }
     } else {
-      ulong sql_type;
-      conn= conns[roop_count];
-      sql_type= SPIDER_SQL_TYPE_SELECT_SQL;
-      spider_db_handler *dbton_hdl = dbton_handler[conn->dbton_id];
-      pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-      if ((error_num = dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
-      {
+      if (spider_send_query(this, table, roop_count, link_ok, &error_num))
         DBUG_RETURN(error_num);
-      }
-      pthread_mutex_lock(&conn->mta_conn_mutex);
-      SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
-        conn->need_mon = &need_mons[roop_count];
-        DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = TRUE;
-        conn->mta_conn_mutex_unlock_later = TRUE;
-        if ((error_num = spider_db_set_names(this, conn,
-          roop_count)))
-        {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
-          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_eof(error_num));
-        }
-        spider_conn_set_timeout_from_share(conn, roop_count,
-          wide_handler->trx->thd, share);
-        if (dbton_hdl->execute_sql(
-          sql_type,
-          conn,
-          result_list.quick_mode,
-          &need_mons[roop_count])
-        ) {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          error_num = spider_db_errorno(conn);
-          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_eof(error_num));
-        }
-        connection_ids[roop_count] = conn->connection_id;
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        if (roop_count == link_ok)
-        {
-          if ((error_num = spider_db_store_result(this, roop_count, table)))
-          {
-            if (
-              error_num != HA_ERR_END_OF_FILE &&
-              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_eof(error_num));
-          }
-          result_link_idx = link_ok;
-        } else {
-          spider_db_discard_result(this, roop_count, conn);
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
-        }
     }
   }
   if (buf && (error_num = spider_db_fetch(buf, this, table)))
@@ -3348,23 +2640,8 @@ int ha_spider::multi_range_read_next_first(
         }
       }
 
-      int roop_start, roop_end, tmp_lock_mode, link_ok;
-      tmp_lock_mode = spider_conn_lock_mode(this);
-      if (tmp_lock_mode)
-      {
-        /* "for update" or "lock in share mode" */
-        link_ok = spider_conn_link_idx_next(share->link_statuses,
-          conn_link_idx, -1, share->link_count,
-          SPIDER_LINK_STATUS_OK);
-        roop_start = spider_conn_link_idx_next(share->link_statuses,
-          conn_link_idx, -1, share->link_count,
-          SPIDER_LINK_STATUS_RECOVERY);
-        roop_end = share->link_count;
-      } else {
-        link_ok = search_link_idx;
-        roop_start = search_link_idx;
-        roop_end = search_link_idx + 1;
-      }
+      int roop_start, roop_end, roop_count, link_ok;
+      spider_prep_loop(this, &roop_start, &roop_end, &link_ok);
       for (roop_count = roop_start; roop_count < roop_end;
         roop_count = spider_conn_link_idx_next(share->link_statuses,
           conn_link_idx, roop_count, share->link_count,
@@ -3380,76 +2657,27 @@ int ha_spider::multi_range_read_next_first(
             TRUE, FALSE, (roop_count != link_ok));
           if (
             error_num &&
-            error_num != HA_ERR_END_OF_FILE &&
-            share->monitoring_kind[roop_count] &&
-            need_mons[roop_count]
+            error_num != HA_ERR_END_OF_FILE
           ) {
-            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
-              );
+            error_num= spider_maybe_ping_1(this, roop_count, error_num);
           }
         } else {
           ulong sql_type;
           conn= conns[roop_count];
           sql_type= SPIDER_SQL_TYPE_SELECT_SQL;
           spider_db_handler *dbton_hdl = dbton_handler[conn->dbton_id];
-          pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
           if ((error_num =
             dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
           {
             DBUG_RETURN(error_num);
           }
-          pthread_mutex_lock(&conn->mta_conn_mutex);
-          SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
           DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
-            conn->need_mon = &need_mons[roop_count];
-            DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-            conn->mta_conn_mutex_lock_already = TRUE;
-            conn->mta_conn_mutex_unlock_later = TRUE;
+            spider_lock_before_query(conn, &need_mons[roop_count]);
             if ((error_num = spider_db_set_names(this, conn,
               roop_count)))
             {
-              DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-              DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-              conn->mta_conn_mutex_lock_already = FALSE;
-              conn->mta_conn_mutex_unlock_later = FALSE;
-              SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-              pthread_mutex_unlock(&conn->mta_conn_mutex);
-              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
-                  );
-              }
+              spider_unlock_after_query(conn, 0);
+              error_num= spider_maybe_ping_1(this, roop_count, error_num);
             }
             if (!error_num)
             {
@@ -3461,72 +2689,26 @@ int ha_spider::multi_range_read_next_first(
                 result_list.quick_mode,
                 &need_mons[roop_count])
               ) {
-                DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-                DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-                conn->mta_conn_mutex_lock_already = FALSE;
-                conn->mta_conn_mutex_unlock_later = FALSE;
-                error_num = spider_db_errorno(conn);
-                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
-                    );
-                }
+                error_num= spider_unlock_after_query_1(conn);
+                error_num= spider_maybe_ping_1(this, roop_count, error_num);
               }
             }
             if (!error_num)
             {
               connection_ids[roop_count] = conn->connection_id;
-              DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-              DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-              conn->mta_conn_mutex_lock_already = FALSE;
-              conn->mta_conn_mutex_unlock_later = FALSE;
               if (roop_count == link_ok)
               {
-                error_num = spider_db_store_result(this, roop_count, table);
+                error_num = spider_unlock_after_query_2(conn, this, roop_count, table);
                 if (
                   error_num &&
-                  error_num != HA_ERR_END_OF_FILE &&
-                  share->monitoring_kind[roop_count] &&
-                  need_mons[roop_count]
+                  error_num != HA_ERR_END_OF_FILE
                 ) {
-                  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
-                    );
+                  error_num= spider_maybe_ping_1(this, roop_count, error_num);
                 }
                 result_link_idx = link_ok;
               } else {
                 spider_db_discard_result(this, roop_count, conn);
-                SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-                pthread_mutex_unlock(&conn->mta_conn_mutex);
+                spider_unlock_after_query(conn, 0);
               }
             }
         }
@@ -3960,24 +3142,8 @@ int ha_spider::multi_range_read_next_first(
         }
       }
 
-      int roop_start, roop_end, roop_count, tmp_lock_mode, link_ok;
-      tmp_lock_mode = spider_conn_lock_mode(this);
-      if (tmp_lock_mode)
-      {
-        /* "for update" or "lock in share mode" */
-        link_ok = spider_conn_link_idx_next(share->link_statuses,
-          conn_link_idx, -1, share->link_count,
-          SPIDER_LINK_STATUS_OK);
-        roop_start = spider_conn_link_idx_next(share->link_statuses,
-          conn_link_idx, -1, share->link_count,
-          SPIDER_LINK_STATUS_RECOVERY);
-        roop_end = share->link_count;
-      } else {
-        link_ok = search_link_idx;
-        roop_start = search_link_idx;
-        roop_end = search_link_idx + 1;
-      }
-
+      int roop_start, roop_end, roop_count, link_ok;
+      spider_prep_loop(this, &roop_start, &roop_end, &link_ok);
       for (roop_count = roop_start; roop_count < roop_end;
         roop_count = spider_conn_link_idx_next(share->link_statuses,
           conn_link_idx, roop_count, share->link_count,
@@ -3993,26 +3159,9 @@ int ha_spider::multi_range_read_next_first(
             TRUE, FALSE, (roop_count != link_ok))))
           {
             if (
-              error_num != HA_ERR_END_OF_FILE &&
-              share->monitoring_kind[roop_count] &&
-              need_mons[roop_count]
+              error_num != HA_ERR_END_OF_FILE
             ) {
-              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
-                );
+              error_num= spider_maybe_ping_1(this, roop_count, error_num);
             }
             break;
           }
@@ -4021,51 +3170,19 @@ int ha_spider::multi_range_read_next_first(
           conn= conns[roop_count];
           sql_type= SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_TMP_SQL;
           spider_db_handler *dbton_hdl = dbton_handler[conn->dbton_id];
-          pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
           if ((error_num =
             dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
           {
             DBUG_RETURN(error_num);
           }
-          pthread_mutex_lock(&conn->mta_conn_mutex);
-          SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
           sql_type &= ~SPIDER_SQL_TYPE_TMP_SQL;
           DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
-            conn->need_mon = &need_mons[roop_count];
-            DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-            conn->mta_conn_mutex_lock_already = TRUE;
-            conn->mta_conn_mutex_unlock_later = TRUE;
+            spider_lock_before_query(conn, &need_mons[roop_count]);
             if ((error_num = spider_db_set_names(this, conn,
               roop_count)))
             {
-              DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-              DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-              conn->mta_conn_mutex_lock_already = FALSE;
-              conn->mta_conn_mutex_unlock_later = FALSE;
-              SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-              pthread_mutex_unlock(&conn->mta_conn_mutex);
-              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
-                  );
-              }
+              spider_unlock_after_query(conn, 0);
+              error_num= spider_maybe_ping_1(this, roop_count, error_num);
               break;
             }
             if (
@@ -4083,32 +3200,8 @@ int ha_spider::multi_range_read_next_first(
                 -1,
                 &need_mons[roop_count])
               ) {
-                DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-                DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-                conn->mta_conn_mutex_lock_already = FALSE;
-                conn->mta_conn_mutex_unlock_later = FALSE;
-                error_num = spider_db_errorno(conn);
-                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
-                    );
-                }
+                error_num= spider_unlock_after_query_1(conn);
+                error_num= spider_maybe_ping_1(this, roop_count, error_num);
                 break;
               }
               spider_db_discard_multiple_result(this, roop_count, conn);
@@ -4121,72 +3214,26 @@ int ha_spider::multi_range_read_next_first(
               result_list.quick_mode,
               &need_mons[roop_count])
             ) {
-              DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-              DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-              conn->mta_conn_mutex_lock_already = FALSE;
-              conn->mta_conn_mutex_unlock_later = FALSE;
-              error_num = spider_db_errorno(conn);
-              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
-                  );
-              }
+              error_num= spider_unlock_after_query_1(conn);
+              error_num= spider_maybe_ping_1(this, roop_count, error_num);
               break;
             }
             connection_ids[roop_count] = conn->connection_id;
-            DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-            conn->mta_conn_mutex_lock_already = FALSE;
-            conn->mta_conn_mutex_unlock_later = FALSE;
             if (roop_count == link_ok)
             {
-              if ((error_num = spider_db_store_result(this, roop_count, table)))
+              if ((error_num = spider_unlock_after_query_2(conn, this, roop_count, table)))
               {
                 if (
-                  error_num != HA_ERR_END_OF_FILE &&
-                  share->monitoring_kind[roop_count] &&
-                  need_mons[roop_count]
+                  error_num != HA_ERR_END_OF_FILE
                 ) {
-                  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
-                    );
+                  error_num= spider_maybe_ping_1(this, roop_count, error_num);
                 }
                 break;
               }
               result_link_idx = link_ok;
             } else {
               spider_db_discard_result(this, roop_count, conn);
-              SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-              pthread_mutex_unlock(&conn->mta_conn_mutex);
+              spider_unlock_after_query(conn, 0);
             }
         }
       }
@@ -4336,7 +3383,7 @@ int ha_spider::multi_range_read_next_next(
   range_id_t *range_info
 )
 {
-  int error_num, roop_count;
+  int error_num;
   SPIDER_CONN *conn;
   int range_res;
   backup_error_status();
@@ -4433,23 +3480,8 @@ int ha_spider::multi_range_read_next_next(
         }
       }
 
-      int roop_start, roop_end, tmp_lock_mode, link_ok;
-      tmp_lock_mode = spider_conn_lock_mode(this);
-      if (tmp_lock_mode)
-      {
-        /* "for update" or "lock in share mode" */
-        link_ok = spider_conn_link_idx_next(share->link_statuses,
-          conn_link_idx, -1, share->link_count,
-          SPIDER_LINK_STATUS_OK);
-        roop_start = spider_conn_link_idx_next(share->link_statuses,
-          conn_link_idx, -1, share->link_count,
-          SPIDER_LINK_STATUS_RECOVERY);
-        roop_end = share->link_count;
-      } else {
-        link_ok = search_link_idx;
-        roop_start = search_link_idx;
-        roop_end = search_link_idx + 1;
-      }
+      int roop_start, roop_end, roop_count, link_ok;
+      spider_prep_loop(this, &roop_start, &roop_end, &link_ok);
       for (roop_count = roop_start; roop_count < roop_end;
         roop_count = spider_conn_link_idx_next(share->link_statuses,
           conn_link_idx, roop_count, share->link_count,
@@ -4465,76 +3497,27 @@ int ha_spider::multi_range_read_next_next(
             TRUE, FALSE, (roop_count != link_ok));
           if (
             error_num &&
-            error_num != HA_ERR_END_OF_FILE &&
-            share->monitoring_kind[roop_count] &&
-            need_mons[roop_count]
+            error_num != HA_ERR_END_OF_FILE
           ) {
-            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
-              );
+            error_num= spider_maybe_ping_1(this, roop_count, error_num);
           }
         } else {
           ulong sql_type;
           conn= conns[roop_count];
           sql_type= SPIDER_SQL_TYPE_SELECT_SQL;
           spider_db_handler *dbton_hdl = dbton_handler[conn->dbton_id];
-          pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
           if ((error_num =
             dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
           {
             DBUG_RETURN(error_num);
           }
-          pthread_mutex_lock(&conn->mta_conn_mutex);
-          SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
           DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
-            conn->need_mon = &need_mons[roop_count];
-            DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-            conn->mta_conn_mutex_lock_already = TRUE;
-            conn->mta_conn_mutex_unlock_later = TRUE;
+            spider_lock_before_query(conn, &need_mons[roop_count]);
             if ((error_num = spider_db_set_names(this, conn,
               roop_count)))
             {
-              DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-              DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-              conn->mta_conn_mutex_lock_already = FALSE;
-              conn->mta_conn_mutex_unlock_later = FALSE;
-              SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-              pthread_mutex_unlock(&conn->mta_conn_mutex);
-              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
-                  );
-              }
+              spider_unlock_after_query(conn, 0);
+              error_num= spider_maybe_ping_1(this, roop_count, error_num);
             }
             if (!error_num)
             {
@@ -4546,72 +3529,26 @@ int ha_spider::multi_range_read_next_next(
                 result_list.quick_mode,
                 &need_mons[roop_count])
               ) {
-                DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-                DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-                conn->mta_conn_mutex_lock_already = FALSE;
-                conn->mta_conn_mutex_unlock_later = FALSE;
-                error_num = spider_db_errorno(conn);
-                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
-                    );
-                }
+                error_num= spider_unlock_after_query_1(conn);
+                error_num= spider_maybe_ping_1(this, roop_count, error_num);
               }
             }
             if (!error_num)
             {
               connection_ids[roop_count] = conn->connection_id;
-              DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-              DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-              conn->mta_conn_mutex_lock_already = FALSE;
-              conn->mta_conn_mutex_unlock_later = FALSE;
               if (roop_count == link_ok)
               {
-                error_num = spider_db_store_result(this, roop_count, table);
+                error_num = spider_unlock_after_query_2(conn, this, roop_count, table);
                 if (
                   error_num &&
-                  error_num != HA_ERR_END_OF_FILE &&
-                  share->monitoring_kind[roop_count] &&
-                  need_mons[roop_count]
+                  error_num != HA_ERR_END_OF_FILE
                 ) {
-                  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
-                    );
+                  error_num= spider_maybe_ping_1(this, roop_count, error_num);
                 }
                 result_link_idx = link_ok;
               } else {
                 spider_db_discard_result(this, roop_count, conn);
-                SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-                pthread_mutex_unlock(&conn->mta_conn_mutex);
+                spider_unlock_after_query(conn, 0);
               }
             }
         }
@@ -5039,23 +3976,8 @@ int ha_spider::multi_range_read_next_next(
         }
       }
 
-      int roop_start, roop_end, roop_count, tmp_lock_mode, link_ok;
-      tmp_lock_mode = spider_conn_lock_mode(this);
-      if (tmp_lock_mode)
-      {
-        /* "for update" or "lock in share mode" */
-        link_ok = spider_conn_link_idx_next(share->link_statuses,
-          conn_link_idx, -1, share->link_count,
-          SPIDER_LINK_STATUS_OK);
-        roop_start = spider_conn_link_idx_next(share->link_statuses,
-          conn_link_idx, -1, share->link_count,
-          SPIDER_LINK_STATUS_RECOVERY);
-        roop_end = share->link_count;
-      } else {
-        link_ok = search_link_idx;
-        roop_start = search_link_idx;
-        roop_end = search_link_idx + 1;
-      }
+      int roop_start, roop_end, roop_count, link_ok;
+      spider_prep_loop(this, &roop_start, &roop_end, &link_ok);
       for (roop_count = roop_start; roop_count < roop_end;
         roop_count = spider_conn_link_idx_next(share->link_statuses,
           conn_link_idx, roop_count, share->link_count,
@@ -5071,26 +3993,9 @@ int ha_spider::multi_range_read_next_next(
             TRUE, FALSE, (roop_count != link_ok))))
           {
             if (
-              error_num != HA_ERR_END_OF_FILE &&
-              share->monitoring_kind[roop_count] &&
-              need_mons[roop_count]
+              error_num != HA_ERR_END_OF_FILE
             ) {
-              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
-                );
+              error_num= spider_maybe_ping_1(this, roop_count, error_num);
             }
             break;
           }
@@ -5099,51 +4004,19 @@ int ha_spider::multi_range_read_next_next(
           conn= conns[roop_count];
           sql_type= SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_TMP_SQL;
           spider_db_handler *dbton_hdl = dbton_handler[conn->dbton_id];
-          pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
           if ((error_num =
             dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
           {
             DBUG_RETURN(error_num);
           }
-          pthread_mutex_lock(&conn->mta_conn_mutex);
-          SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
           sql_type &= ~SPIDER_SQL_TYPE_TMP_SQL;
           DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
-            conn->need_mon = &need_mons[roop_count];
-            DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-            conn->mta_conn_mutex_lock_already = TRUE;
-            conn->mta_conn_mutex_unlock_later = TRUE;
+            spider_lock_before_query(conn, &need_mons[roop_count]);
             if ((error_num = spider_db_set_names(this, conn,
               roop_count)))
             {
-              DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-              DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-              conn->mta_conn_mutex_lock_already = FALSE;
-              conn->mta_conn_mutex_unlock_later = FALSE;
-              SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-              pthread_mutex_unlock(&conn->mta_conn_mutex);
-              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
-                  );
-              }
+              spider_unlock_after_query(conn, 0);
+              error_num= spider_maybe_ping_1(this, roop_count, error_num);
               break;
             }
             if (
@@ -5161,32 +4034,8 @@ int ha_spider::multi_range_read_next_next(
                 -1,
                 &need_mons[roop_count])
               ) {
-                DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-                DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-                conn->mta_conn_mutex_lock_already = FALSE;
-                conn->mta_conn_mutex_unlock_later = FALSE;
-                error_num = spider_db_errorno(conn);
-                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
-                    );
-                }
+                error_num= spider_unlock_after_query_1(conn);
+                error_num= spider_maybe_ping_1(this, roop_count, error_num);
                 break;
               }
               spider_db_discard_multiple_result(this, roop_count, conn);
@@ -5199,72 +4048,26 @@ int ha_spider::multi_range_read_next_next(
               result_list.quick_mode,
               &need_mons[roop_count])
             ) {
-              DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-              DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-              conn->mta_conn_mutex_lock_already = FALSE;
-              conn->mta_conn_mutex_unlock_later = FALSE;
-              error_num = spider_db_errorno(conn);
-              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
-                  );
-              }
+              error_num= spider_unlock_after_query_1(conn);
+              error_num= spider_maybe_ping_1(this, roop_count, error_num);
               break;
             }
             connection_ids[roop_count] = conn->connection_id;
-            DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-            conn->mta_conn_mutex_lock_already = FALSE;
-            conn->mta_conn_mutex_unlock_later = FALSE;
             if (roop_count == link_ok)
             {
-              if ((error_num = spider_db_store_result(this, roop_count, table)))
+              if ((error_num = spider_unlock_after_query_2(conn, this, roop_count, table)))
               {
                 if (
-                  error_num != HA_ERR_END_OF_FILE &&
-                  share->monitoring_kind[roop_count] &&
-                  need_mons[roop_count]
+                  error_num != HA_ERR_END_OF_FILE
                 ) {
-                  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
-                    );
+                  error_num= spider_maybe_ping_1(this, search_link_idx, error_num);
                 }
                 break;
               }
               result_link_idx = link_ok;
             } else {
               spider_db_discard_result(this, roop_count, conn);
-              SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-              pthread_mutex_unlock(&conn->mta_conn_mutex);
+              spider_unlock_after_query(conn, 0);
             }
         }
       }
@@ -5605,187 +4408,20 @@ int ha_spider::rnd_next_internal(
       }
     }
 
-    int roop_start, roop_end, roop_count, tmp_lock_mode, link_ok;
-    tmp_lock_mode = spider_conn_lock_mode(this);
-    if (tmp_lock_mode)
-    {
-      /* "for update" or "lock in share mode" */
-      link_ok = spider_conn_link_idx_next(share->link_statuses,
-        conn_link_idx, -1, share->link_count,
-        SPIDER_LINK_STATUS_OK);
-      roop_start = spider_conn_link_idx_next(share->link_statuses,
-        conn_link_idx, -1, share->link_count,
-        SPIDER_LINK_STATUS_RECOVERY);
-      roop_end = share->link_count;
-    } else {
-      link_ok = search_link_idx;
-      roop_start = search_link_idx;
-      roop_end = search_link_idx + 1;
-    }
+    int roop_start, roop_end, roop_count, link_ok;
+    spider_prep_loop(this, &roop_start, &roop_end, &link_ok);
     for (roop_count = roop_start; roop_count < roop_end;
       roop_count = spider_conn_link_idx_next(share->link_statuses,
         conn_link_idx, roop_count, share->link_count,
         SPIDER_LINK_STATUS_RECOVERY)
     ) {
-      if (result_list.bgs_phase > 0)
-      {
-        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,
-          TRUE, FALSE, (roop_count != link_ok))))
-        {
-          if (
-            error_num != HA_ERR_END_OF_FILE &&
-            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_eof(error_num));
-        }
-      } else {
-        SPIDER_CONN *conn = conns[roop_count];
-        ulong sql_type;
-        sql_type= SPIDER_SQL_TYPE_SELECT_SQL;
-        spider_db_handler *dbton_hdl = dbton_handler[conn->dbton_id];
-        pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-        if ((error_num =
-          dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
-        {
-          DBUG_RETURN(error_num);
-        }
-        pthread_mutex_lock(&conn->mta_conn_mutex);
-        SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
-        conn->need_mon = &need_mons[roop_count];
-        DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = TRUE;
-        conn->mta_conn_mutex_unlock_later = TRUE;
-        if ((error_num = spider_db_set_names(this, conn,
-          roop_count)))
-        {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
-          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_eof(error_num));
-        }
-        spider_conn_set_timeout_from_share(conn, roop_count,
-          wide_handler->trx->thd, share);
-        if (dbton_hdl->execute_sql(
-          sql_type,
-          conn,
-          result_list.quick_mode,
-          &need_mons[roop_count])
-        ) {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          error_num = spider_db_errorno(conn);
-          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_eof(error_num));
-        }
-        connection_ids[roop_count] = conn->connection_id;
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        if (roop_count == link_ok)
-        {
-          if ((error_num = spider_db_store_result(this, roop_count, table)))
-          {
-            if (
-              error_num != HA_ERR_END_OF_FILE &&
-              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_eof(error_num));
-          }
-          result_link_idx = link_ok;
-        } else {
-          spider_db_discard_result(this, roop_count, conn);
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
-        }
+    if (result_list.bgs_phase > 0)
+    {
+      if (spider_start_bg(this, roop_count, roop_start, link_ok, &error_num))
+        DBUG_RETURN(error_num);
+    } else {
+      if (spider_send_query(this, table, roop_count, link_ok, &error_num))
+        DBUG_RETURN(error_num);
       }
     }
     rnd_scan_and_first = FALSE;
@@ -6202,184 +4838,20 @@ int ha_spider::ft_read_internal(
       }
     }
 
-    int roop_start, roop_end, roop_count, tmp_lock_mode, link_ok;
-    tmp_lock_mode = spider_conn_lock_mode(this);
-    if (tmp_lock_mode)
-    {
-      /* "for update" or "lock in share mode" */
-      link_ok = spider_conn_link_idx_next(share->link_statuses,
-        conn_link_idx, -1, share->link_count,
-        SPIDER_LINK_STATUS_OK);
-      roop_start = spider_conn_link_idx_next(share->link_statuses,
-        conn_link_idx, -1, share->link_count,
-        SPIDER_LINK_STATUS_RECOVERY);
-      roop_end = share->link_count;
-    } else {
-      link_ok = search_link_idx;
-      roop_start = search_link_idx;
-      roop_end = search_link_idx + 1;
-    }
+    int roop_start, roop_end, roop_count, link_ok;
+    spider_prep_loop(this, &roop_start, &roop_end, &link_ok);
     for (roop_count = roop_start; roop_count < roop_end;
       roop_count = spider_conn_link_idx_next(share->link_statuses,
         conn_link_idx, roop_count, share->link_count,
         SPIDER_LINK_STATUS_RECOVERY)
     ) {
-      if (result_list.bgs_phase > 0)
-      {
-        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,
-          TRUE, FALSE, (roop_count != link_ok))))
-        {
-          if (
-            error_num != HA_ERR_END_OF_FILE &&
-            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_eof(error_num));
-        }
-      } else {
-        uint dbton_id = share->sql_dbton_ids[roop_count];
-        spider_db_handler *dbton_hdl = dbton_handler[dbton_id];
-        SPIDER_CONN *conn = conns[roop_count];
-        pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-        if ((error_num = dbton_hdl->set_sql_for_exec(
-          SPIDER_SQL_TYPE_SELECT_SQL, roop_count)))
-        {
-          DBUG_RETURN(error_num);
-        }
-        pthread_mutex_lock(&conn->mta_conn_mutex);
-        SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        conn->need_mon = &need_mons[roop_count];
-        DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = TRUE;
-        conn->mta_conn_mutex_unlock_later = TRUE;
-        if ((error_num = spider_db_set_names(this, conn, roop_count)))
-        {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
-          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_eof(error_num));
-        }
-        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,
-          result_list.quick_mode,
-          &need_mons[roop_count])
-        ) {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          error_num = spider_db_errorno(conn);
-          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_eof(error_num));
-        }
-        connection_ids[roop_count] = conn->connection_id;
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        if (roop_count == link_ok)
-        {
-          if ((error_num = spider_db_store_result(this, roop_count, table)))
-          {
-            if (
-              error_num != HA_ERR_END_OF_FILE &&
-              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_eof(error_num));
-          }
-          result_link_idx = link_ok;
-        } else {
-          spider_db_discard_result(this, roop_count, conn);
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
-        }
+    if (result_list.bgs_phase > 0)
+    {
+      if (spider_start_bg(this, roop_count, roop_start, link_ok, &error_num))
+        DBUG_RETURN(error_num);
+    } else {
+      if (spider_send_query(this, table, roop_count, link_ok, &error_num))
+        DBUG_RETURN(error_num);
       }
     }
   }
@@ -6447,9 +4919,7 @@ int ha_spider::info(
   DBUG_ENTER("ha_spider::info");
   DBUG_PRINT("info",("spider this=%p", this));
   DBUG_PRINT("info",("spider flag=%x", flag));
-#ifdef HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT
   auto_inc_temporary = FALSE;
-#endif
   wide_handler->sql_command = thd_sql_command(thd);
     if (flag & HA_STATUS_AUTO)
     {
@@ -6458,9 +4928,7 @@ int ha_spider::info(
           share->lgtm_tblhnd_share->auto_increment_value;
       else {
         stats.auto_increment_value = 1;
-#ifdef HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT
         auto_inc_temporary = TRUE;
-#endif
       }
     }
     if (
@@ -6584,27 +5052,7 @@ int ha_spider::info(
                 flag | (share->sts_init ? 0 : HA_STATUS_AUTO)))
             ) {
               pthread_mutex_unlock(&share->sts_mutex);
-              if (
-                share->monitoring_kind[search_link_idx] &&
-                need_mons[search_link_idx]
-              ) {
-                error_num = spider_ping_table_mon_from_table(
-                    wide_handler->trx,
-                    wide_handler->trx->thd,
-                    share,
-                    search_link_idx,
-                    (uint32) share->monitoring_sid[search_link_idx],
-                    share->table_name,
-                    share->table_name_length,
-                    conn_link_idx[search_link_idx],
-                    NULL,
-                    0,
-                    share->monitoring_kind[search_link_idx],
-                    share->monitoring_limit[search_link_idx],
-                    share->monitoring_flag[search_link_idx],
-                    TRUE
-                  );
-              }
+              error_num= spider_maybe_ping_1(this, search_link_idx, error_num);
               if (!share->sts_init)
               {
                 if (
@@ -6715,9 +5163,7 @@ int ha_spider::info(
     }
     if (flag & HA_STATUS_AUTO)
     {
-#ifdef HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT
       auto_inc_temporary = FALSE;
-#endif
       if (share->wide_share && table->next_number_field)
       {
         ulonglong first_value, nb_reserved_values;
@@ -6859,27 +5305,7 @@ ha_rows ha_spider::records_in_range(
               share->crd_init ? 2 : 1)))
             {
               pthread_mutex_unlock(&share->crd_mutex);
-              if (
-                share->monitoring_kind[search_link_idx] &&
-                need_mons[search_link_idx]
-              ) {
-                error_num = spider_ping_table_mon_from_table(
-                    wide_handler->trx,
-                    wide_handler->trx->thd,
-                    share,
-                    search_link_idx,
-                    (uint32) share->monitoring_sid[search_link_idx],
-                    share->table_name,
-                    share->table_name_length,
-                    conn_link_idx[search_link_idx],
-                    NULL,
-                    0,
-                    share->monitoring_kind[search_link_idx],
-                    share->monitoring_limit[search_link_idx],
-                    share->monitoring_flag[search_link_idx],
-                    TRUE
-                  );
-              }
+              error_num= spider_maybe_ping_1(this, search_link_idx, error_num);
               if (!share->crd_init)
               {
                 if (
@@ -7153,27 +5579,7 @@ int ha_spider::check_crd()
             share->crd_init ? 2 : 1)))
           {
             pthread_mutex_unlock(&share->crd_mutex);
-            if (
-              share->monitoring_kind[search_link_idx] &&
-              need_mons[search_link_idx]
-            ) {
-              error_num = spider_ping_table_mon_from_table(
-                  wide_handler->trx,
-                  wide_handler->trx->thd,
-                  share,
-                  search_link_idx,
-                  (uint32) share->monitoring_sid[search_link_idx],
-                  share->table_name,
-                  share->table_name_length,
-                  conn_link_idx[search_link_idx],
-                  NULL,
-                  0,
-                  share->monitoring_kind[search_link_idx],
-                  share->monitoring_limit[search_link_idx],
-                  share->monitoring_flag[search_link_idx],
-                  TRUE
-                );
-            }
+            error_num= spider_maybe_ping_1(this, search_link_idx, error_num);
             if (!share->crd_init)
             {
               if (
@@ -7550,7 +5956,6 @@ bool ha_spider::need_info_for_auto_inc()
   ));
 }
 
-#ifdef HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT
 bool ha_spider::can_use_for_auto_inc_init()
 {
   DBUG_ENTER("ha_spider::can_use_for_auto_inc_init");
@@ -7562,7 +5967,6 @@ bool ha_spider::can_use_for_auto_inc_init()
     !auto_inc_temporary
   ));
 }
-#endif
 
 int ha_spider::update_auto_increment()
 {
@@ -7890,19 +6294,11 @@ int ha_spider::end_bulk_update(
   DBUG_RETURN(0);
 }
 
-#ifdef SPIDER_UPDATE_ROW_HAS_CONST_NEW_DATA
 int ha_spider::bulk_update_row(
   const uchar *old_data,
   const uchar *new_data,
   ha_rows *dup_key_found
 )
-#else
-int ha_spider::bulk_update_row(
-  const uchar *old_data,
-  uchar *new_data,
-  ha_rows *dup_key_found
-)
-#endif
 {
   DBUG_ENTER("ha_spider::bulk_update_row");
   DBUG_PRINT("info",("spider this=%p", this));
@@ -7910,17 +6306,10 @@ int ha_spider::bulk_update_row(
   DBUG_RETURN(update_row(old_data, new_data));
 }
 
-#ifdef SPIDER_UPDATE_ROW_HAS_CONST_NEW_DATA
 int ha_spider::update_row(
   const uchar *old_data,
   const uchar *new_data
 )
-#else
-int ha_spider::update_row(
-  const uchar *old_data,
-  uchar *new_data
-)
-#endif
 {
   int error_num;
   THD *thd = ha_thd();
@@ -9737,7 +8126,7 @@ bool ha_spider::is_sole_projection_field(
 
 int ha_spider::drop_tmp_tables()
 {
-  int error_num = 0, tmp_error_num, need_mon;
+  int error_num = 0, need_mon;
   DBUG_ENTER("ha_spider::drop_tmp_tables");
   DBUG_PRINT("info",("spider this=%p", this));
   if (result_list.tmp_tables_created)
@@ -9766,51 +8155,19 @@ int ha_spider::drop_tmp_tables()
         uint dbton_id = share->sql_dbton_ids[roop_count];
         spider_db_handler *dbton_hdl = dbton_handler[dbton_id];
         SPIDER_CONN *conn = conns[roop_count];
-        pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
         if ((error_num = dbton_hdl->set_sql_for_exec(
           SPIDER_SQL_TYPE_TMP_SQL, roop_count)))
         {
           DBUG_RETURN(error_num);
         }
-        pthread_mutex_lock(&conn->mta_conn_mutex);
-        SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        conn->need_mon = &need_mon;
-        DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = TRUE;
-        conn->mta_conn_mutex_unlock_later = TRUE;
-        if ((tmp_error_num = spider_db_set_names(this, conn, roop_count)))
+        spider_lock_before_query(conn, &need_mon);
+        /* todo: double check the logic here w.r.t. tmp_error_num vs error_num */
+        if ((error_num = spider_db_set_names(this, conn, roop_count)))
         {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
-          if (
-            share->monitoring_kind[roop_count] &&
-            need_mons[roop_count]
-          ) {
-            tmp_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
-              );
-          }
-          error_num = tmp_error_num;
+          spider_unlock_after_query(conn, 0);
+          error_num= spider_maybe_ping_1(this, roop_count, error_num);
         }
-        if (!tmp_error_num)
+        if (!error_num)
         {
           spider_conn_set_timeout_from_share(conn, roop_count,
             wide_handler->trx->thd, share);
@@ -9820,40 +8177,10 @@ int ha_spider::drop_tmp_tables()
             -1,
             &need_mons[roop_count])
           ) {
-            DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-            conn->mta_conn_mutex_lock_already = FALSE;
-            conn->mta_conn_mutex_unlock_later = FALSE;
-            tmp_error_num = spider_db_errorno(conn);
-            if (
-              share->monitoring_kind[roop_count] &&
-              need_mons[roop_count]
-            ) {
-              tmp_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
-                );
-            }
-            error_num = tmp_error_num;
+            error_num= spider_unlock_after_query_1(conn);
+            error_num= spider_maybe_ping_1(this, roop_count, error_num);
           } else {
-            DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-            conn->mta_conn_mutex_lock_already = FALSE;
-            conn->mta_conn_mutex_unlock_later = FALSE;
-            SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-            pthread_mutex_unlock(&conn->mta_conn_mutex);
+            spider_unlock_after_query(conn, 0);
           }
         }
         spider_clear_bit(result_list.tmp_table_created, roop_count);
@@ -11958,28 +10285,7 @@ int ha_spider::lock_tables()
               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));
+          DBUG_RETURN(spider_maybe_ping(this, roop_count, error_num));
         }
         reset_first_link_idx();
       }
@@ -11989,29 +10295,8 @@ int ha_spider::lock_tables()
           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));
+          DBUG_RETURN(spider_maybe_ping(this, roop_count, error_num));
         }
         if (conns[roop_count]->table_lock == 2)
           conns[roop_count]->table_lock = 1;
@@ -12025,28 +10310,7 @@ int ha_spider::lock_tables()
             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));
+            DBUG_RETURN(spider_maybe_ping(this, roop_count, error_num));
           }
         }
       }
@@ -12096,28 +10360,7 @@ int ha_spider::dml_init()
             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));
+        DBUG_RETURN(spider_maybe_ping(this, roop_count, error_num));
       }
       reset_first_link_idx();
       if (
@@ -12134,28 +10377,7 @@ int ha_spider::dml_init()
           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));
+            DBUG_RETURN(spider_maybe_ping(this, roop_count, error_num));
           }
         }
         conns[roop_count]->semi_trx_isolation = -1;
diff --git a/storage/spider/ha_spider.h b/storage/spider/ha_spider.h
index 93b6e2c204b..f467020b13f 100644
--- a/storage/spider/ha_spider.h
+++ b/storage/spider/ha_spider.h
@@ -121,9 +121,7 @@ public:
   bool               pre_bitmap_checked;
   bool               bulk_insert;
   bool               info_auto_called;
-#ifdef HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT
   bool               auto_inc_temporary;
-#endif
   int                bulk_size= 0;
   int                direct_dup_insert;
   int                store_error_num;
@@ -353,9 +351,7 @@ public:
   uint max_supported_key_part_length() const override;
   uint8 table_cache_type() override;
   bool need_info_for_auto_inc() override;
-#ifdef HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT
   bool can_use_for_auto_inc_init() override;
-#endif
   int update_auto_increment();
   void get_auto_increment(
     ulonglong offset,
@@ -376,7 +372,6 @@ public:
   bool start_bulk_update() override;
   int exec_bulk_update(ha_rows *dup_key_found) override;
   int end_bulk_update() override;
-#ifdef SPIDER_UPDATE_ROW_HAS_CONST_NEW_DATA
   int bulk_update_row(
     const uchar *old_data,
     const uchar *new_data,
@@ -386,17 +381,6 @@ public:
     const uchar *old_data,
     const uchar *new_data
   ) override;
-#else
-  int bulk_update_row(
-    const uchar *old_data,
-    uchar *new_data,
-    ha_rows *dup_key_found
-  );
-  int update_row(
-    const uchar *old_data,
-    uchar *new_data
-  );
-#endif
   bool check_direct_update_sql_part(
     st_select_lex *select_lex,
     longlong select_limit,
diff --git a/storage/spider/spd_conn.cc b/storage/spider/spd_conn.cc
index ff289c220c1..dc73519dc37 100644
--- a/storage/spider/spd_conn.cc
+++ b/storage/spider/spd_conn.cc
@@ -17,7 +17,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "sql_class.h"
@@ -271,7 +270,6 @@ int spider_free_conn_alloc(
     conn->db_conn = NULL;
   }
   spider_conn_done(conn);
-  DBUG_ASSERT(!conn->mta_conn_mutex_file_pos.file_name);
   pthread_mutex_destroy(&conn->mta_conn_mutex);
   conn->default_database.free();
   DBUG_RETURN(0);
@@ -1469,10 +1467,6 @@ void spider_conn_clear_queue(
 ) {
   DBUG_ENTER("spider_conn_clear_queue");
   DBUG_PRINT("info", ("spider conn=%p", conn));
-/*
-  conn->queued_connect = FALSE;
-  conn->queued_ping = FALSE;
-*/
   conn->queued_trx_isolation = FALSE;
   conn->queued_semi_trx_isolation = FALSE;
   conn->queued_autocommit = FALSE;
@@ -2536,7 +2530,6 @@ void *spider_bg_conn_action(
       ) {
         ulong sql_type;
         sql_type= SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_TMP_SQL;
-        pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
         if (spider->use_fields)
         {
           if ((error_num = dbton_handler->set_sql_for_exec(sql_type,
@@ -2555,17 +2548,12 @@ void *spider_bg_conn_action(
               strmov(result_list->bgs_error_msg, spider_stmt_da_message(thd));
           }
         }
-        pthread_mutex_lock(&conn->mta_conn_mutex);
-        SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
+        /* todo: is it ok if the following statement is not locked? */
         sql_type &= ~SPIDER_SQL_TYPE_TMP_SQL;
         DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
         if (!result_list->bgs_error)
         {
-          conn->need_mon = &spider->need_mons[conn->link_idx];
-          DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = TRUE;
-          conn->mta_conn_mutex_unlock_later = TRUE;
+          spider_lock_before_query(conn, &spider->need_mons[conn->link_idx]);
             if (!(result_list->bgs_error =
               spider_db_set_names(spider, conn, conn->link_idx)))
             {
@@ -2634,15 +2622,7 @@ void *spider_bg_conn_action(
                 strmov(result_list->bgs_error_msg,
                   spider_stmt_da_message(thd));
             }
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
-        } else {
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
+            spider_unlock_after_query(conn, 0);
         }
       } else {
         spider->connection_ids[conn->link_idx] = conn->connection_id;
@@ -2717,26 +2697,14 @@ void *spider_bg_conn_action(
     {
       DBUG_PRINT("info",("spider bg exec sql start"));
       spider = (ha_spider*) conn->bg_target;
-      pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-      pthread_mutex_lock(&conn->mta_conn_mutex);
-      SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      conn->need_mon = &spider->need_mons[conn->link_idx];
-      DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = TRUE;
-      conn->mta_conn_mutex_unlock_later = TRUE;
+      spider_lock_before_query(conn, &spider->need_mons[conn->link_idx]);
       *conn->bg_error_num = spider_db_query_with_set_names(
         conn->bg_sql_type,
         spider,
         conn,
         conn->link_idx
       );
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+      spider_unlock_after_query(conn, 0);
       conn->bg_exec_sql = FALSE;
       continue;
     }
@@ -3285,32 +3253,6 @@ void *spider_bg_crd_action(
                           share->conn_keys[spider.search_link_idx], trx,
                           &spider, FALSE, FALSE, &error_num);
           conns[spider.search_link_idx]->error_mode = 0;
-/*
-          if (
-            error_num &&
-            share->monitoring_kind[spider.search_link_idx] &&
-            need_mons[spider.search_link_idx]
-          ) {
-            lex_start(thd);
-            error_num = spider_ping_table_mon_from_table(
-                trx,
-                thd,
-                share,
-                spider.search_link_idx,
-                (uint32) share->monitoring_sid[spider.search_link_idx],
-                share->table_name,
-                share->table_name_length,
-                spider.conn_link_idx[spider.search_link_idx],
-                NULL,
-                0,
-                share->monitoring_kind[spider.search_link_idx],
-                share->monitoring_limit[spider.search_link_idx],
-                share->monitoring_flag[spider.search_link_idx],
-                TRUE
-              );
-            lex_end(thd->lex);
-          }
-*/
           spider.search_link_idx = -1;
         }
         if (spider.search_link_idx != -1 && conns[spider.search_link_idx])
@@ -3321,31 +3263,6 @@ void *spider_bg_crd_action(
             share->bg_crd_sync,
             2))
           {
-/*
-            if (
-              share->monitoring_kind[spider.search_link_idx] &&
-              need_mons[spider.search_link_idx]
-            ) {
-              lex_start(thd);
-              error_num = spider_ping_table_mon_from_table(
-                  trx,
-                  thd,
-                  share,
-                  spider.search_link_idx,
-                  (uint32) share->monitoring_sid[spider.search_link_idx],
-                  share->table_name,
-                  share->table_name_length,
-                  spider.conn_link_idx[spider.search_link_idx],
-                  NULL,
-                  0,
-                  share->monitoring_kind[spider.search_link_idx],
-                  share->monitoring_limit[spider.search_link_idx],
-                  share->monitoring_flag[spider.search_link_idx],
-                  TRUE
-                );
-              lex_end(thd->lex);
-            }
-*/
             spider.search_link_idx = -1;
           }
         }
@@ -3650,17 +3567,11 @@ void *spider_bg_mon_action(
         share->monitoring_bg_interval[link_idx] * 1000);
       pthread_cond_timedwait(&share->bg_mon_sleep_conds[link_idx],
         &share->bg_mon_mutexes[link_idx], &abstime);
-/*
-      my_sleep((ulong) share->monitoring_bg_interval[link_idx]);
-*/
     }
     DBUG_PRINT("info",("spider bg mon roop start"));
     if (share->bg_mon_kill)
     {
       DBUG_PRINT("info",("spider bg mon kill start"));
-/*
-      pthread_mutex_lock(&share->bg_mon_mutexes[link_idx]);
-*/
       pthread_cond_signal(&share->bg_mon_conds[link_idx]);
       pthread_mutex_unlock(&share->bg_mon_mutexes[link_idx]);
       spider_free_trx(trx, TRUE);
@@ -4060,3 +3971,42 @@ void spider_free_ipport_conn(void *info)
   }
   DBUG_VOID_RETURN;
 }
+
+void spider_lock_before_query(SPIDER_CONN *conn, int *need_mon)
+{
+  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
+  pthread_mutex_lock(&conn->mta_conn_mutex);
+  conn->need_mon = need_mon;
+  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
+  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
+  conn->mta_conn_mutex_lock_already = TRUE;
+  conn->mta_conn_mutex_unlock_later = TRUE;
+}
+
+int spider_unlock_after_query(SPIDER_CONN *conn, int ret)
+{
+  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
+  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
+  conn->mta_conn_mutex_lock_already = FALSE;
+  conn->mta_conn_mutex_unlock_later = FALSE;
+  pthread_mutex_unlock(&conn->mta_conn_mutex);
+  return ret;
+}
+
+int spider_unlock_after_query_1(SPIDER_CONN *conn)
+{
+  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
+  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
+  conn->mta_conn_mutex_lock_already = FALSE;
+  conn->mta_conn_mutex_unlock_later = FALSE;
+  return spider_db_errorno(conn);
+}
+
+int spider_unlock_after_query_2(SPIDER_CONN *conn, ha_spider *spider, int link_idx, TABLE *table)
+{
+  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
+  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
+  conn->mta_conn_mutex_lock_already = FALSE;
+  conn->mta_conn_mutex_unlock_later = FALSE;
+  return spider_db_store_result(spider, link_idx, table);
+}
diff --git a/storage/spider/spd_conn.h b/storage/spider/spd_conn.h
index 4afa85a18b1..1152bd808f5 100644
--- a/storage/spider/spd_conn.h
+++ b/storage/spider/spd_conn.h
@@ -24,6 +24,8 @@
 #define SPIDER_SIMPLE_RECORDS             3
 #define SPIDER_SIMPLE_CHECKSUM_TABLE      4
 
+struct TABLE;
+
 /*
   The SPIDER_CONN_LOOP_CHECK has been added to the loop_check queue to
   check for self-reference.
@@ -437,3 +439,11 @@ SPIDER_CONN* spider_get_conn_from_idle_connection
  int *error_num
  );
 void spider_free_ipport_conn(void *info);
+
+void spider_lock_before_query(SPIDER_CONN *conn, int *need_mon);
+
+int spider_unlock_after_query(SPIDER_CONN *conn, int ret);
+
+int spider_unlock_after_query_1(SPIDER_CONN *conn);
+
+int spider_unlock_after_query_2(SPIDER_CONN *conn, ha_spider *spider, int link_idx, TABLE *table);
diff --git a/storage/spider/spd_copy_tables.cc b/storage/spider/spd_copy_tables.cc
index 518a7c590de..de246b09784 100644
--- a/storage/spider/spd_copy_tables.cc
+++ b/storage/spider/spd_copy_tables.cc
@@ -17,7 +17,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "sql_class.h"
diff --git a/storage/spider/spd_db_conn.cc b/storage/spider/spd_db_conn.cc
index b1ec856e3fb..21d44f7510b 100644
--- a/storage/spider/spd_db_conn.cc
+++ b/storage/spider/spd_db_conn.cc
@@ -17,7 +17,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "sql_class.h"
@@ -101,8 +100,6 @@ int spider_db_connect(
     }
   }
 
-  if (thd)
-  {
     conn->connect_timeout = spider_param_connect_timeout(thd,
       share->connect_timeouts[link_idx]);
     conn->net_read_timeout = spider_param_net_read_timeout(thd,
@@ -114,16 +111,6 @@ int spider_db_connect(
       connect_retry_count = 0;
     else
       connect_retry_count = spider_param_connect_retry_count(thd);
-  } else {
-    conn->connect_timeout = spider_param_connect_timeout(NULL,
-      share->connect_timeouts[link_idx]);
-    conn->net_read_timeout = spider_param_net_read_timeout(NULL,
-      share->net_read_timeouts[link_idx]);
-    conn->net_write_timeout = spider_param_net_write_timeout(NULL,
-      share->net_write_timeouts[link_idx]);
-    connect_retry_interval = spider_param_connect_retry_interval(NULL);
-    connect_retry_count = spider_param_connect_retry_count(NULL);
-  }
   DBUG_PRINT("info",("spider connect_timeout=%u", conn->connect_timeout));
   DBUG_PRINT("info",("spider net_read_timeout=%u", conn->net_read_timeout));
   DBUG_PRINT("info",("spider net_write_timeout=%u", conn->net_write_timeout));
@@ -179,7 +166,6 @@ int spider_db_ping_internal(
   int error_num;
   DBUG_ENTER("spider_db_ping_internal");
   pthread_mutex_assert_owner(&conn->mta_conn_mutex);
-  DBUG_ASSERT(conn->mta_conn_mutex_file_pos.file_name);
   if (conn->server_lost || conn->queued_connect)
   {
     if ((error_num = spider_db_connect(share, conn, all_link_idx)))
@@ -567,7 +553,6 @@ int spider_db_before_query(
     spider_bg_conn_break(conn, NULL);
   conn->in_before_query = TRUE;
   pthread_mutex_assert_owner(&conn->mta_conn_mutex);
-  DBUG_ASSERT(conn->mta_conn_mutex_file_pos.file_name);
   if ((error_num = spider_db_conn_queue_action(conn)))
   {
     conn->in_before_query = FALSE;
@@ -673,7 +658,6 @@ int spider_db_errorno(
       if (!conn->mta_conn_mutex_unlock_later)
       {
         DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
         pthread_mutex_unlock(&conn->mta_conn_mutex);
       }
       DBUG_RETURN(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM);
@@ -695,7 +679,6 @@ int spider_db_errorno(
         if (!conn->mta_conn_mutex_unlock_later)
         {
           DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
           pthread_mutex_unlock(&conn->mta_conn_mutex);
         }
         DBUG_RETURN(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM);
@@ -708,7 +691,6 @@ int spider_db_errorno(
         if (!conn->mta_conn_mutex_unlock_later)
         {
           DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
           pthread_mutex_unlock(&conn->mta_conn_mutex);
         }
         DBUG_RETURN(HA_ERR_FOUND_DUPP_KEY);
@@ -734,7 +716,6 @@ int spider_db_errorno(
         if (!conn->mta_conn_mutex_unlock_later)
         {
           DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
           pthread_mutex_unlock(&conn->mta_conn_mutex);
         }
         DBUG_RETURN(error_num);
@@ -756,7 +737,6 @@ int spider_db_errorno(
       if (!conn->mta_conn_mutex_unlock_later)
       {
         DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
         pthread_mutex_unlock(&conn->mta_conn_mutex);
       }
       DBUG_RETURN(error_num);
@@ -764,7 +744,6 @@ int spider_db_errorno(
   if (!conn->mta_conn_mutex_unlock_later)
   {
     DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
     pthread_mutex_unlock(&conn->mta_conn_mutex);
   }
   DBUG_RETURN(0);
@@ -788,7 +767,6 @@ int spider_db_set_names_internal(
 ) {
   DBUG_ENTER("spider_db_set_names_internal");
     pthread_mutex_assert_owner(&conn->mta_conn_mutex);
-    DBUG_ASSERT(conn->mta_conn_mutex_file_pos.file_name);
     DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
     DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
     if (
@@ -929,20 +907,10 @@ int spider_db_query_for_bulk_update(
   SPIDER_SHARE *share = spider->share;
   DBUG_ENTER("spider_db_query_for_bulk_update");
 
-  pthread_mutex_assert_owner(&conn->mta_conn_mutex);
-  conn->need_mon = &spider->need_mons[link_idx];
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
+  spider_lock_before_query(conn, &spider->need_mons[link_idx]);
   if ((error_num = spider_db_set_names(spider, conn, link_idx)))
   {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
+    spider_unlock_after_query(conn, 0);
     if (
       share->monitoring_kind[link_idx] &&
       spider->need_mons[link_idx]
@@ -976,11 +944,7 @@ int spider_db_query_for_bulk_update(
     -1,
     &spider->need_mons[link_idx])
   ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    error_num = spider_db_errorno(conn);
+    error_num= spider_unlock_after_query_1(conn);
     if (
       error_num != ER_DUP_ENTRY &&
       error_num != ER_DUP_KEY &&
@@ -1025,12 +989,7 @@ int spider_db_query_for_bulk_update(
   }
   if (error_num > 0 && !conn->db_conn->is_dup_entry_error(error_num))
   {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
+    spider_unlock_after_query(conn, 0);
     if (
       share->monitoring_kind[link_idx] &&
       spider->need_mons[link_idx]
@@ -1054,13 +1013,7 @@ int spider_db_query_for_bulk_update(
     }
     DBUG_RETURN(error_num);
   }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+  DBUG_RETURN(spider_unlock_after_query(conn, 0));
 }
 
 size_t spider_db_real_escape_string(
@@ -3071,7 +3024,6 @@ int spider_db_store_result(
       if (!conn->mta_conn_mutex_unlock_later)
       {
         DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
         pthread_mutex_unlock(&conn->mta_conn_mutex);
       }
       DBUG_RETURN(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM);
@@ -3088,7 +3040,6 @@ int spider_db_store_result(
           if (!conn->mta_conn_mutex_unlock_later)
           {
             DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-            SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
             pthread_mutex_unlock(&conn->mta_conn_mutex);
           }
           DBUG_RETURN(HA_ERR_OUT_OF_MEM);
@@ -3118,7 +3069,6 @@ int spider_db_store_result(
             if (!conn->mta_conn_mutex_unlock_later)
             {
               DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-              SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
               pthread_mutex_unlock(&conn->mta_conn_mutex);
             }
             DBUG_RETURN(HA_ERR_OUT_OF_MEM);
@@ -3161,7 +3111,6 @@ int spider_db_store_result(
             if (!conn->mta_conn_mutex_unlock_later)
             {
               DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-              SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
               pthread_mutex_unlock(&conn->mta_conn_mutex);
             }
             DBUG_RETURN(HA_ERR_OUT_OF_MEM);
@@ -3202,7 +3151,6 @@ int spider_db_store_result(
           if (!conn->mta_conn_mutex_unlock_later)
           {
             DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-            SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
             pthread_mutex_unlock(&conn->mta_conn_mutex);
           }
           DBUG_RETURN(error_num);
@@ -3227,7 +3175,6 @@ int spider_db_store_result(
         if (!conn->mta_conn_mutex_unlock_later && !call_db_errorno)
         {
           DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
           pthread_mutex_unlock(&conn->mta_conn_mutex);
         }
         DBUG_RETURN(HA_ERR_END_OF_FILE);
@@ -3235,7 +3182,6 @@ int spider_db_store_result(
         if (!conn->mta_conn_mutex_unlock_later)
         {
           DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
           pthread_mutex_unlock(&conn->mta_conn_mutex);
         }
         current->record_num = current->result->num_rows();
@@ -3275,7 +3221,6 @@ int spider_db_store_result(
         if (!conn->mta_conn_mutex_unlock_later)
         {
           DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
           pthread_mutex_unlock(&conn->mta_conn_mutex);
         }
       } else {
@@ -3300,7 +3245,6 @@ int spider_db_store_result(
             if (!conn->mta_conn_mutex_unlock_later)
             {
               DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-              SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
               pthread_mutex_unlock(&conn->mta_conn_mutex);
             }
           }
@@ -3312,7 +3256,6 @@ int spider_db_store_result(
         if (!conn->mta_conn_mutex_unlock_later)
         {
           DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
           pthread_mutex_unlock(&conn->mta_conn_mutex);
         }
       }
@@ -4120,44 +4063,32 @@ int spider_db_seek_next(
               link_idx = link_idx_holder->link_idx;
               spider_db_handler *dbton_handler =
                 spider->dbton_handler[conn->dbton_id];
-              pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
               if ((error_num = dbton_handler->set_sql_for_exec(sql_type,
                 link_idx)))
               {
                 DBUG_PRINT("info",("spider error_num 6=%d", error_num));
                 DBUG_RETURN(error_num);
               }
-              pthread_mutex_lock(&conn->mta_conn_mutex);
-              SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
               if (conn->db_conn->limit_mode() == 1)
               {
+                pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
+                pthread_mutex_lock(&conn->mta_conn_mutex);
                 conn->db_conn->set_limit(result_list->limit_num);
                 if (fields->is_first_link_ok_chain(link_idx_chain))
                 {
                   if ((error_num = spider_db_store_result_for_reuse_cursor(
                     spider, link_idx, table)))
                   {
-                    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
                     pthread_mutex_unlock(&conn->bg_conn_mutex);
                     DBUG_RETURN(error_num);
                   }
                 }
-                SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
                 pthread_mutex_unlock(&conn->bg_conn_mutex);
               } else {
-                conn->need_mon = &spider->need_mons[link_idx];
-                DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-                DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-                conn->mta_conn_mutex_lock_already = TRUE;
-                conn->mta_conn_mutex_unlock_later = TRUE;
+                spider_lock_before_query(conn, &spider->need_mons[conn->link_idx]);
                 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
                 {
-                  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-                  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-                  conn->mta_conn_mutex_lock_already = FALSE;
-                  conn->mta_conn_mutex_unlock_later = FALSE;
-                  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-                  pthread_mutex_unlock(&conn->mta_conn_mutex);
+                  spider_unlock_after_query(conn, 0);
                   if (
                     spider->need_mons[link_idx]
                   ) {
@@ -4174,11 +4105,7 @@ int spider_db_seek_next(
                   result_list->quick_mode,
                   &spider->need_mons[link_idx])
                 ) {
-                  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-                  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-                  conn->mta_conn_mutex_lock_already = FALSE;
-                  conn->mta_conn_mutex_unlock_later = FALSE;
-                  error_num = spider_db_errorno(conn);
+                  error_num= spider_unlock_after_query_1(conn);
                   if (
                     spider->need_mons[link_idx]
                   ) {
@@ -4188,14 +4115,9 @@ int spider_db_seek_next(
                   DBUG_RETURN(error_num);
                 }
                 spider->connection_ids[link_idx] = conn->connection_id;
-                DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-                DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-                conn->mta_conn_mutex_lock_already = FALSE;
-                conn->mta_conn_mutex_unlock_later = FALSE;
                 if (fields->is_first_link_ok_chain(link_idx_chain))
                 {
-                  if ((error_num = spider_db_store_result(spider, link_idx,
-                    table)))
+                  if ((error_num = spider_unlock_after_query_2(conn, spider, link_idx, table)))
                   {
                     if (
                       error_num != HA_ERR_END_OF_FILE &&
@@ -4210,8 +4132,7 @@ int spider_db_seek_next(
                   spider->result_link_idx = link_ok;
                 } else {
                   spider_db_discard_result(spider, link_idx, conn);
-                  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-                  pthread_mutex_unlock(&conn->mta_conn_mutex);
+                  spider_unlock_after_query(conn, 0);
                 }
               }
             }
@@ -4226,44 +4147,32 @@ int spider_db_seek_next(
               sql_type= SPIDER_SQL_TYPE_SELECT_SQL;
               spider_db_handler *dbton_handler =
                 spider->dbton_handler[conn->dbton_id];
-              pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
               if ((error_num = dbton_handler->set_sql_for_exec(sql_type,
                 roop_count)))
               {
                 DBUG_PRINT("info",("spider error_num 6=%d", error_num));
                 DBUG_RETURN(error_num);
               }
-              pthread_mutex_lock(&conn->mta_conn_mutex);
-              SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
               if (conn->db_conn->limit_mode() == 1)
               {
+                pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
+                pthread_mutex_lock(&conn->mta_conn_mutex);
                 conn->db_conn->set_limit(result_list->limit_num);
                 if (roop_count == link_ok)
                 {
                   if ((error_num = spider_db_store_result_for_reuse_cursor(
                     spider, link_idx, table)))
                   {
-                    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
                     pthread_mutex_unlock(&conn->bg_conn_mutex);
                     DBUG_RETURN(error_num);
                   }
                 }
-                SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
                 pthread_mutex_unlock(&conn->bg_conn_mutex);
               } else {
-                conn->need_mon = &spider->need_mons[roop_count];
-                DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-                DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-                conn->mta_conn_mutex_lock_already = TRUE;
-                conn->mta_conn_mutex_unlock_later = TRUE;
+                spider_lock_before_query(conn, &spider->need_mons[roop_count]);
                 if ((error_num = spider_db_set_names(spider, conn, roop_count)))
                 {
-                  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-                  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-                  conn->mta_conn_mutex_lock_already = FALSE;
-                  conn->mta_conn_mutex_unlock_later = FALSE;
-                  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-                  pthread_mutex_unlock(&conn->mta_conn_mutex);
+                  spider_unlock_after_query(conn, 0);
                   if (
                     share->monitoring_kind[roop_count] &&
                     spider->need_mons[roop_count]
@@ -4296,11 +4205,7 @@ int spider_db_seek_next(
                   result_list->quick_mode,
                   &spider->need_mons[roop_count])
                 ) {
-                  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-                  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-                  conn->mta_conn_mutex_lock_already = FALSE;
-                  conn->mta_conn_mutex_unlock_later = FALSE;
-                  error_num = spider_db_errorno(conn);
+                  error_num= spider_unlock_after_query_1(conn);
                   if (
                     share->monitoring_kind[roop_count] &&
                     spider->need_mons[roop_count]
@@ -4326,14 +4231,9 @@ int spider_db_seek_next(
                   DBUG_RETURN(error_num);
                 }
                 spider->connection_ids[roop_count] = conn->connection_id;
-                DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-                DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-                conn->mta_conn_mutex_lock_already = FALSE;
-                conn->mta_conn_mutex_unlock_later = FALSE;
                 if (roop_count == link_ok)
                 {
-                  if ((error_num = spider_db_store_result(spider, roop_count,
-                    table)))
+                  if ((error_num = spider_unlock_after_query_2(conn, spider, roop_count, table)))
                   {
                     if (
                       error_num != HA_ERR_END_OF_FILE &&
@@ -4363,8 +4263,7 @@ int spider_db_seek_next(
                   spider->result_link_idx = link_ok;
                 } else {
                   spider_db_discard_result(spider, roop_count, conn);
-                  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-                  pthread_mutex_unlock(&conn->mta_conn_mutex);
+                  spider_unlock_after_query(conn, 0);
                 }
               }
             }
@@ -4476,43 +4375,31 @@ int spider_db_seek_last(
       sql_type= SPIDER_SQL_TYPE_SELECT_SQL;
       conn = spider->conns[roop_count];
       spider_db_handler *dbton_handler = spider->dbton_handler[conn->dbton_id];
-      pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
       if ((error_num = dbton_handler->set_sql_for_exec(sql_type, roop_count)))
       {
         DBUG_RETURN(error_num);
       }
-      pthread_mutex_lock(&conn->mta_conn_mutex);
-      SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
       DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
       if (conn->db_conn->limit_mode() == 1)
       {
+        pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
+        pthread_mutex_lock(&conn->mta_conn_mutex);
         conn->db_conn->set_limit(result_list->limit_num);
         if (roop_count == link_ok)
         {
           if ((error_num = spider_db_store_result_for_reuse_cursor(
             spider, roop_count, table)))
           {
-            SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
             pthread_mutex_unlock(&conn->bg_conn_mutex);
             DBUG_RETURN(error_num);
           }
         }
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
         pthread_mutex_unlock(&conn->bg_conn_mutex);
       } else {
-        conn->need_mon = &spider->need_mons[roop_count];
-        DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = TRUE;
-        conn->mta_conn_mutex_unlock_later = TRUE;
+        spider_lock_before_query(conn, &spider->need_mons[roop_count]);
         if ((error_num = spider_db_set_names(spider, conn, roop_count)))
         {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
+          spider_unlock_after_query(conn, 0);
           if (
             share->monitoring_kind[roop_count] &&
             spider->need_mons[roop_count]
@@ -4545,11 +4432,7 @@ int spider_db_seek_last(
           result_list->quick_mode,
           &spider->need_mons[roop_count])
         ) {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          error_num = spider_db_errorno(conn);
+          error_num= spider_unlock_after_query_1(conn);
           if (
             share->monitoring_kind[roop_count] &&
             spider->need_mons[roop_count]
@@ -4574,13 +4457,9 @@ int spider_db_seek_last(
           DBUG_RETURN(error_num);
         }
         spider->connection_ids[roop_count] = conn->connection_id;
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
         if (roop_count == link_ok)
         {
-          if ((error_num = spider_db_store_result(spider, roop_count, table)))
+          if ((error_num = spider_unlock_after_query_2(conn, spider, roop_count, table)))
           {
             if (
               error_num != HA_ERR_END_OF_FILE &&
@@ -4609,8 +4488,7 @@ int spider_db_seek_last(
           spider->result_link_idx = link_ok;
         } else {
           spider_db_discard_result(spider, roop_count, conn);
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
+          spider_unlock_after_query(conn, 0);
         }
       }
     }
@@ -4669,27 +4547,15 @@ int spider_db_seek_last(
     sql_type= SPIDER_SQL_TYPE_SELECT_SQL;
     conn = spider->conns[roop_count];
     spider_db_handler *dbton_handler = spider->dbton_handler[conn->dbton_id];
-    pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
     if ((error_num = dbton_handler->set_sql_for_exec(sql_type, roop_count)))
     {
       DBUG_RETURN(error_num);
     }
-    pthread_mutex_lock(&conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
     DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
-    conn->need_mon = &spider->need_mons[roop_count];
-    DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = TRUE;
-    conn->mta_conn_mutex_unlock_later = TRUE;
+    spider_lock_before_query(conn, &spider->need_mons[roop_count]);
     if ((error_num = spider_db_set_names(spider, conn, roop_count)))
     {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+      spider_unlock_after_query(conn, 0);
       if (
         share->monitoring_kind[roop_count] &&
         spider->need_mons[roop_count]
@@ -4722,11 +4588,7 @@ int spider_db_seek_last(
       result_list->quick_mode,
       &spider->need_mons[roop_count])
     ) {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      error_num = spider_db_errorno(conn);
+      error_num= spider_unlock_after_query_1(conn);
       if (
         share->monitoring_kind[roop_count] &&
         spider->need_mons[roop_count]
@@ -4751,13 +4613,9 @@ int spider_db_seek_last(
       DBUG_RETURN(error_num);
     }
     spider->connection_ids[roop_count] = conn->connection_id;
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
     if (roop_count == link_ok)
     {
-      if ((error_num = spider_db_store_result(spider, roop_count, table)))
+      if ((error_num = spider_unlock_after_query_2(conn, spider, roop_count, table)))
       {
         if (
           error_num != HA_ERR_END_OF_FILE &&
@@ -4786,8 +4644,7 @@ int spider_db_seek_last(
       spider->result_link_idx = link_ok;
     } else {
       spider_db_discard_result(spider, roop_count, conn);
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+      spider_unlock_after_query(conn, 0);
     }
   }
   DBUG_RETURN(spider_db_fetch(buf, spider, table));
@@ -5422,29 +5279,17 @@ int spider_db_bulk_insert(
           sql_type = SPIDER_SQL_TYPE_INSERT_SQL;
           conn = spider->conns[roop_count2];
           dbton_handler = spider->dbton_handler[conn->dbton_id];
-          pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
           if ((error_num = dbton_handler->set_sql_for_exec(sql_type,
             roop_count2)))
           {
             spider->set_insert_to_pos_sql(SPIDER_SQL_TYPE_INSERT_SQL);
             DBUG_RETURN(error_num);
           }
-          pthread_mutex_lock(&conn->mta_conn_mutex);
-          SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        conn->need_mon = &spider->need_mons[roop_count2];
-        DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = TRUE;
-        conn->mta_conn_mutex_unlock_later = TRUE;
+        spider_lock_before_query(conn, &spider->need_mons[roop_count2]);
         if ((error_num = spider_db_set_names(spider, conn, roop_count2)))
         {
           spider->set_insert_to_pos_sql(SPIDER_SQL_TYPE_INSERT_SQL);
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
+          spider_unlock_after_query(conn, 0);
           if (
             share->monitoring_kind[roop_count2] &&
             spider->need_mons[roop_count2]
@@ -5480,12 +5325,7 @@ int spider_db_bulk_insert(
           {
             conn->db_conn->set_dup_key_idx(spider, roop_count2);
           }
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
+          spider_unlock_after_query(conn, 0);
           if (
             error_num != ER_DUP_ENTRY &&
             error_num != ER_DUP_KEY &&
@@ -5512,17 +5352,12 @@ int spider_db_bulk_insert(
           }
           DBUG_RETURN(error_num);
         }
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
         if (!insert_info && copy_info)
         {
           insert_info =
             conn->db_conn->inserted_info(dbton_handler, copy_info);
         }
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
+        spider_unlock_after_query(conn, 0);
         if (first_insert_link_idx == -1)
         {
           first_insert_link_idx = roop_count2;
@@ -5531,14 +5366,7 @@ int spider_db_bulk_insert(
       }
 
       conn = first_insert_conn;
-      pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-      pthread_mutex_lock(&conn->mta_conn_mutex);
-      SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      conn->need_mon = &spider->need_mons[first_insert_link_idx];
-      DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = TRUE;
-      conn->mta_conn_mutex_unlock_later= TRUE;
+      spider_lock_before_query(conn, &spider->need_mons[first_insert_link_idx]);
       spider->set_insert_to_pos_sql(SPIDER_SQL_TYPE_INSERT_SQL);
       if (table->next_number_field &&
         (
@@ -5557,13 +5385,7 @@ int spider_db_bulk_insert(
         else if ((error_num = dbton_handler->
           show_last_insert_id(first_insert_link_idx, last_insert_id)))
         {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
-          DBUG_RETURN(error_num);
+          DBUG_RETURN(spider_unlock_after_query(conn, error_num));
         }
         table->next_number_field->set_notnull();
         if (
@@ -5572,21 +5394,10 @@ int spider_db_bulk_insert(
           (error_num = table->next_number_field->store(
             last_insert_id, TRUE))
         ) {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
-          DBUG_RETURN(error_num);
+          DBUG_RETURN(spider_unlock_after_query(conn, error_num));
         }
       }
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+      spider_unlock_after_query(conn, 0);
       spider->store_last_insert_id = 0;
   }
   if (
@@ -5706,7 +5517,6 @@ int spider_db_bulk_update_size_limit(
         DBUG_RETURN(error_num);
       }
       pthread_mutex_lock(&conn->mta_conn_mutex);
-      SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
       if ((error_num = spider_db_query_for_bulk_update(
         spider, conn, roop_count, &dup_key_found)))
       {
@@ -5790,7 +5600,6 @@ int spider_db_bulk_update_end(
             DBUG_RETURN(error_num);
           }
           pthread_mutex_lock(&conn->mta_conn_mutex);
-          SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
           if ((error_num = spider_db_query_for_bulk_update(
             spider, conn, roop_count, dup_key_found)))
           {
@@ -5829,7 +5638,6 @@ int spider_db_bulk_update_end(
           DBUG_RETURN(error_num);
         }
         pthread_mutex_lock(&conn->mta_conn_mutex);
-        SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
         if ((error_num = spider_db_query_for_bulk_update(
           spider, conn, roop_count, dup_key_found)))
         {
@@ -5902,27 +5710,15 @@ int spider_db_update(
     conn = spider->conns[roop_count];
     spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
     conn->ignore_dup_key = spider->wide_handler->ignore_dup_key;
-    pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
     if ((error_num = dbton_hdl->set_sql_for_exec(
       SPIDER_SQL_TYPE_UPDATE_SQL, roop_count)))
     {
       DBUG_RETURN(error_num);
     }
-    pthread_mutex_lock(&conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    conn->need_mon = &spider->need_mons[roop_count];
-    DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = TRUE;
-    conn->mta_conn_mutex_unlock_later = TRUE;
+    spider_lock_before_query(conn, &spider->need_mons[roop_count]);
     if ((error_num = spider_db_set_names(spider, conn, roop_count)))
     {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+      spider_unlock_after_query(conn, 0);
       if (
         share->monitoring_kind[roop_count] &&
         spider->need_mons[roop_count]
@@ -5955,11 +5751,7 @@ int spider_db_update(
       -1,
       &spider->need_mons[roop_count])
     ) {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      error_num = spider_db_errorno(conn);
+      error_num= spider_unlock_after_query_1(conn);
       if (
         error_num != ER_DUP_ENTRY &&
         error_num != ER_DUP_KEY &&
@@ -5996,13 +5788,7 @@ int spider_db_update(
       if ((error_num = dbton_hdl->append_insert_for_recovery(
         SPIDER_SQL_TYPE_INSERT_SQL, roop_count)))
       {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
-        DBUG_RETURN(error_num);
+        DBUG_RETURN(spider_unlock_after_query(conn, error_num));
       }
       spider_conn_set_timeout_from_share(conn, roop_count,
         spider->wide_handler->trx->thd,
@@ -6013,11 +5799,7 @@ int spider_db_update(
         -1,
         &spider->need_mons[roop_count])
       ) {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        error_num = spider_db_errorno(conn);
+        error_num= spider_unlock_after_query_1(conn);
         if (
           error_num != ER_DUP_ENTRY &&
           error_num != ER_DUP_KEY &&
@@ -6045,12 +5827,7 @@ int spider_db_update(
         DBUG_RETURN(error_num);
       }
     }
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
+    spider_unlock_after_query(conn, 0);
     result_list->update_sqls[roop_count].length(0);
   }
   spider->reset_sql_sql(SPIDER_SQL_TYPE_UPDATE_SQL);
@@ -6137,26 +5914,14 @@ int spider_db_direct_update(
     conn = spider->conns[roop_count];
     sql_type = SPIDER_SQL_TYPE_UPDATE_SQL;
     spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
-    pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
     if ((error_num = dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
     {
       DBUG_RETURN(error_num);
     }
-    pthread_mutex_lock(&conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      conn->need_mon = &spider->need_mons[roop_count];
-      DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = TRUE;
-      conn->mta_conn_mutex_unlock_later = TRUE;
+    spider_lock_before_query(conn, &spider->need_mons[roop_count]);
       if ((error_num = spider_db_set_names(spider, conn, roop_count)))
       {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
+        spider_unlock_after_query(conn, 0);
         if (
           share->monitoring_kind[roop_count] &&
           spider->need_mons[roop_count]
@@ -6193,11 +5958,7 @@ int spider_db_direct_update(
         (error_num != HA_ERR_FOUND_DUPP_KEY ||
           !spider->wide_handler->ignore_dup_key)
       ) {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        error_num = spider_db_errorno(conn);
+        error_num= spider_unlock_after_query_1(conn);
         if (
           error_num != ER_DUP_ENTRY &&
           error_num != ER_DUP_KEY &&
@@ -6232,12 +5993,7 @@ int spider_db_direct_update(
         DBUG_PRINT("info", ("spider found_rows = %llu", *found_rows));
         counted = TRUE;
       }
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
+      spider_unlock_after_query(conn, 0);
   }
   spider->reset_sql_sql(SPIDER_SQL_TYPE_UPDATE_SQL);
   DBUG_RETURN(0);
@@ -6291,35 +6047,18 @@ int spider_db_delete(
   ) {
     conn = spider->conns[roop_count];
     spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
-    pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
     if ((error_num = dbton_hdl->set_sql_for_exec(
       SPIDER_SQL_TYPE_DELETE_SQL, roop_count)))
     {
       DBUG_RETURN(error_num);
     }
-    pthread_mutex_lock(&conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = TRUE;
-    conn->mta_conn_mutex_unlock_later = TRUE;
+    spider_lock_before_query(conn, &spider->need_mons[roop_count]);
     if ((error_num = spider_db_query_with_set_names(
       SPIDER_SQL_TYPE_DELETE_SQL, spider, conn, roop_count)))
     {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
-      DBUG_RETURN(error_num);
+      DBUG_RETURN(spider_unlock_after_query(conn, error_num));
     }
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
+    spider_unlock_after_query(conn, 0);
     result_list->update_sqls[roop_count].length(0);
   }
   if ((error_num = spider->reset_sql_sql(SPIDER_SQL_TYPE_DELETE_SQL)))
@@ -6395,26 +6134,14 @@ int spider_db_direct_delete(
     conn = spider->conns[roop_count];
     sql_type = SPIDER_SQL_TYPE_DELETE_SQL;
     spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
-    pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
     if ((error_num = dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
     {
       DBUG_RETURN(error_num);
     }
-    pthread_mutex_lock(&conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      conn->need_mon = &spider->need_mons[roop_count];
-      DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = TRUE;
-      conn->mta_conn_mutex_unlock_later = TRUE;
+    spider_lock_before_query(conn, &spider->need_mons[roop_count]);
       if ((error_num = spider_db_set_names(spider, conn, roop_count)))
       {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
+        spider_unlock_after_query(conn, 0);
         if (
           share->monitoring_kind[roop_count] &&
           spider->need_mons[roop_count]
@@ -6447,11 +6174,7 @@ int spider_db_direct_delete(
         -1,
         &spider->need_mons[roop_count])
       ) {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        error_num = spider_db_errorno(conn);
+        error_num= spider_unlock_after_query_1(conn);
         if (
           share->monitoring_kind[roop_count] &&
           spider->need_mons[roop_count]
@@ -6475,18 +6198,13 @@ int spider_db_direct_delete(
         }
         DBUG_RETURN(error_num);
       }
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
       if (!counted)
       {
         *delete_rows = spider->conns[roop_count]->db_conn->affected_rows();
         DBUG_PRINT("info", ("spider delete_rows = %llu", *delete_rows));
         counted = TRUE;
       }
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
+    spider_unlock_after_query(conn, 0);
   }
   int error_num2 = 0;
   {
@@ -6519,19 +6237,12 @@ int spider_db_delete_all_rows(
     uint dbton_id = share->sql_dbton_ids[roop_count];
     spider_db_handler *dbton_hdl = spider->dbton_handler[dbton_id];
     conn = spider->conns[roop_count];
-    pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
     if ((error_num = dbton_hdl->set_sql_for_exec(
       SPIDER_SQL_TYPE_DELETE_SQL, roop_count)))
     {
       DBUG_RETURN(error_num);
     }
-    pthread_mutex_lock(&conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    conn->need_mon = &spider->need_mons[roop_count];
-    DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = TRUE;
-    conn->mta_conn_mutex_unlock_later = TRUE;
+    spider_lock_before_query(conn, &spider->need_mons[roop_count]);
     spider_conn_set_timeout_from_share(conn, roop_count,
       spider->wide_handler->trx->thd,
       share);
@@ -6553,12 +6264,7 @@ int spider_db_delete_all_rows(
         /* retry */
         if ((error_num = spider_db_ping(spider, conn, roop_count)))
         {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
+          spider_unlock_after_query(conn, 0);
           if (
             share->monitoring_kind[roop_count] &&
             spider->need_mons[roop_count]
@@ -6584,12 +6290,7 @@ int spider_db_delete_all_rows(
         }
         if ((error_num = spider_db_set_names(spider, conn, roop_count)))
         {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&conn->mta_conn_mutex);
+          spider_unlock_after_query(conn, 0);
           if (
             share->monitoring_kind[roop_count] &&
             spider->need_mons[roop_count]
@@ -6622,11 +6323,7 @@ int spider_db_delete_all_rows(
           -1,
           &spider->need_mons[roop_count])
         ) {
-          DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-          conn->mta_conn_mutex_lock_already = FALSE;
-          conn->mta_conn_mutex_unlock_later = FALSE;
-          error_num = spider_db_errorno(conn);
+          spider_unlock_after_query(conn, 0);
           if (
             share->monitoring_kind[roop_count] &&
             spider->need_mons[roop_count]
@@ -6651,12 +6348,7 @@ int spider_db_delete_all_rows(
           DBUG_RETURN(error_num);
         }
       } else {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
+        spider_unlock_after_query(conn, 0);
         if (
           share->monitoring_kind[roop_count] &&
           spider->need_mons[roop_count]
@@ -6681,12 +6373,7 @@ int spider_db_delete_all_rows(
         DBUG_RETURN(error_num);
       }
     }
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
+    spider_unlock_after_query(conn, 0);
   }
   if ((error_num = spider->reset_sql_sql(SPIDER_SQL_TYPE_DELETE_SQL)))
     DBUG_RETURN(error_num);
@@ -8444,14 +8131,7 @@ int spider_db_udf_direct_sql(
   sql_command_backup = c_thd->lex->sql_command;
   c_thd->lex->sql_command = SQLCOM_INSERT;
 
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = &need_mon;
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
+  spider_lock_before_query(conn, &need_mon);
   if (
     !(error_num = spider_db_udf_direct_sql_set_names(direct_sql, trx, conn)) &&
     !(error_num = spider_db_udf_direct_sql_select_db(direct_sql, conn))
@@ -8672,12 +8352,7 @@ int spider_db_udf_direct_sql(
       } while (status == 0);
     }
   }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
+  spider_unlock_after_query(conn, 0);
   if (need_trx_end && insert_start)
   {
     if (error_num)
@@ -8710,7 +8385,6 @@ int spider_db_udf_direct_sql_select_db(
   if (
     spider_dbton[conn->dbton_id].db_util->database_has_default_value()
   ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_file_pos.file_name);
     if (
       !conn->default_database.length() ||
       conn->default_database.length() !=
@@ -8753,7 +8427,6 @@ int spider_db_udf_direct_sql_set_names(
   int error_num, need_mon = 0;
   DBUG_ENTER("spider_db_udf_direct_sql_set_names");
   pthread_mutex_assert_owner(&conn->mta_conn_mutex);
-    DBUG_ASSERT(conn->mta_conn_mutex_file_pos.file_name);
     if (
       !conn->access_charset ||
       trx->udf_access_charset->cset != conn->access_charset->cset
@@ -8838,22 +8511,10 @@ int spider_db_udf_ping_table(
     spider.conn_link_idx = &tmp_conn_link_idx;
     spider.db_request_phase = &db_request_phase;
     spider.db_request_id = &db_request_id;
-    pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-    pthread_mutex_lock(&conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    conn->need_mon = &need_mon;
-    DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = TRUE;
-    conn->mta_conn_mutex_unlock_later = TRUE;
+    spider_lock_before_query(conn, &need_mon);
     if ((error_num = spider_db_ping(&spider, conn, 0)))
     {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+      spider_unlock_after_query(conn, 0);
       table_mon_list->last_mon_result = error_num;
       pthread_mutex_unlock(&table_mon_list->monitor_mutex);
       if (error_num == ER_CON_COUNT_ERROR)
@@ -8865,12 +8526,7 @@ int spider_db_udf_ping_table(
         share->server_names[0]);
       DBUG_RETURN(ER_CONNECT_TO_FOREIGN_DATA_SOURCE);
     }
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
+    spider_unlock_after_query(conn, 0);
     if (!ping_only)
     {
       int init_sql_alloc_size =
@@ -8913,22 +8569,10 @@ int spider_db_udf_ping_table(
         my_afree(sql_buf);
         DBUG_RETURN(error_num);
       }
-      pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-      pthread_mutex_lock(&conn->mta_conn_mutex);
-      SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      conn->need_mon = &need_mon;
-      DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = TRUE;
-      conn->mta_conn_mutex_unlock_later = TRUE;
+      spider_lock_before_query(conn, &need_mon);
       if ((error_num = spider_db_set_names(&spider, conn, 0)))
       {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
+        spider_unlock_after_query(conn, 0);
         table_mon_list->last_mon_result = error_num;
         pthread_mutex_unlock(&table_mon_list->monitor_mutex);
         DBUG_PRINT("info",("spider error_num=%d", error_num));
@@ -8943,24 +8587,15 @@ int spider_db_udf_ping_table(
         -1,
         &need_mon)
       ) {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        error_num = spider_db_errorno(conn);
+        error_num = spider_unlock_after_query_1(conn);
         table_mon_list->last_mon_result = error_num;
         pthread_mutex_unlock(&table_mon_list->monitor_mutex);
         DBUG_PRINT("info",("spider error_num=%d", error_num));
         my_afree(sql_buf);
         DBUG_RETURN(error_num);
       }
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
+      spider_unlock_after_query(conn, 0);
       spider_db_discard_result(&spider, 0, conn);
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
       my_afree(sql_buf);
     }
     table_mon_list->last_mon_result = 0;
@@ -9179,37 +8814,18 @@ int spider_db_udf_ping_table_mon_next(
     DBUG_RETURN(error_num);
   }
 
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = &need_mon;
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
+  spider_lock_before_query(conn, &need_mon);
   if ((error_num = spider_db_ping(&spider, conn, 0)))
   {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
     my_error(ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0),
       share->server_names[0]);
     my_afree(sql_buf);
-    DBUG_RETURN(ER_CONNECT_TO_FOREIGN_DATA_SOURCE);
+    DBUG_RETURN(spider_unlock_after_query(conn, ER_CONNECT_TO_FOREIGN_DATA_SOURCE));
   }
   if ((error_num = spider_db_set_names(&spider, conn, 0)))
   {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
     my_afree(sql_buf);
-    DBUG_RETURN(error_num);
+    DBUG_RETURN(spider_unlock_after_query(conn, error_num));
   }
   spider_conn_set_timeout_from_share(conn, 0, thd, share);
   if (spider_db_query(
@@ -9219,12 +8835,8 @@ int spider_db_udf_ping_table_mon_next(
     -1,
     &need_mon)
   ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
     my_afree(sql_buf);
-    DBUG_RETURN(spider_db_errorno(conn));
+    DBUG_RETURN(spider_unlock_after_query_1(conn));
   }
   st_spider_db_request_key request_key;
   request_key.spider_thread_id = trx.spider_thread_id;
@@ -9234,32 +8846,22 @@ int spider_db_udf_ping_table_mon_next(
   request_key.next = NULL;
   if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
   {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
     if (error_num)
     {
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
       my_afree(sql_buf);
-      DBUG_RETURN(error_num);
+      DBUG_RETURN(spider_unlock_after_query(conn, error_num));
     }
-    else if ((error_num = spider_db_errorno(conn)))
+    else if ((error_num = spider_unlock_after_query_1(conn)))
     {
       my_afree(sql_buf);
       DBUG_RETURN(error_num);
     }
+    spider_unlock_after_query(conn, 0);
     my_error(HA_ERR_OUT_OF_MEM, MYF(0));
     my_afree(sql_buf);
     DBUG_RETURN(HA_ERR_OUT_OF_MEM);
   }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
+  spider_unlock_after_query(conn, 0);
   my_afree(sql_buf);
   error_num = res->fetch_table_mon_status(mon_table_result->result_status);
   res->free_result();
@@ -9337,22 +8939,10 @@ int spider_db_udf_copy_tables(
         spider_conn_clear_queue_at_commit(tmp_conn);
         if (!tmp_conn->trx_start)
         {
-          pthread_mutex_assert_not_owner(&tmp_conn->mta_conn_mutex);
-          pthread_mutex_lock(&tmp_conn->mta_conn_mutex);
-          SPIDER_SET_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-          tmp_conn->need_mon = &tmp_spider->need_mons[0];
-          DBUG_ASSERT(!tmp_conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(!tmp_conn->mta_conn_mutex_unlock_later);
-          tmp_conn->mta_conn_mutex_lock_already = TRUE;
-          tmp_conn->mta_conn_mutex_unlock_later = TRUE;
+          spider_lock_before_query(tmp_conn, &tmp_spider->need_mons[0]);
           if (spider_db_ping(tmp_spider, tmp_conn, 0))
           {
-            DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-            tmp_conn->mta_conn_mutex_lock_already = FALSE;
-            tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-            SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-            pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
+            spider_unlock_after_query(tmp_conn, 0);
             my_error(ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0),
               tmp_spider->share->server_names[0]);
             error_num = ER_CONNECT_TO_FOREIGN_DATA_SOURCE;
@@ -9363,20 +8953,10 @@ int spider_db_udf_copy_tables(
             (error_num = spider_db_start_transaction(tmp_conn,
               tmp_spider->need_mons))
           ) {
-            DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-            tmp_conn->mta_conn_mutex_lock_already = FALSE;
-            tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-            SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-            pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
+            spider_unlock_after_query(tmp_conn, 0);
             goto error_start_transaction;
           }
-          DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-          tmp_conn->mta_conn_mutex_lock_already = FALSE;
-          tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
+          spider_unlock_after_query(tmp_conn, 0);
         }
       }
     } else {
@@ -9396,22 +8976,10 @@ int spider_db_udf_copy_tables(
       {
         tmp_spider = &spider[roop_count];
         tmp_conn = tmp_spider->conns[0];
-        pthread_mutex_assert_not_owner(&tmp_conn->mta_conn_mutex);
-        pthread_mutex_lock(&tmp_conn->mta_conn_mutex);
-        SPIDER_SET_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-        tmp_conn->need_mon = &tmp_spider->need_mons[0];
-        DBUG_ASSERT(!tmp_conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(!tmp_conn->mta_conn_mutex_unlock_later);
-        tmp_conn->mta_conn_mutex_lock_already = TRUE;
-        tmp_conn->mta_conn_mutex_unlock_later = TRUE;
+        spider_lock_before_query(tmp_conn, &tmp_spider->need_mons[0]);
         if (spider_db_ping(tmp_spider, tmp_conn, 0))
         {
-          DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-          tmp_conn->mta_conn_mutex_lock_already = FALSE;
-          tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
+          spider_unlock_after_query(tmp_conn, 0);
           my_error(ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0),
             tmp_spider->share->server_names[0]);
           error_num = ER_CONNECT_TO_FOREIGN_DATA_SOURCE;
@@ -9424,23 +8992,13 @@ int spider_db_udf_copy_tables(
             (error_num = spider_db_lock_tables(tmp_spider, 0))
           )
         ) {
-          DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-          tmp_conn->mta_conn_mutex_lock_already = FALSE;
-          tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
+          spider_unlock_after_query(tmp_conn, 0);
           tmp_conn->table_lock = 0;
           if (error_num == HA_ERR_OUT_OF_MEM)
             my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
           goto error_lock_tables;
         }
-        DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-        tmp_conn->mta_conn_mutex_lock_already = FALSE;
-        tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
+        spider_unlock_after_query(tmp_conn, 0);
         tmp_conn->table_lock = 1;
       }
     }
@@ -9448,24 +9006,13 @@ int spider_db_udf_copy_tables(
     tmp_conn = src_tbl_conn->conn;
     spider_conn_set_timeout_from_share(tmp_conn, 0,
       copy_tables->trx->thd, src_tbl_conn->share);
-    pthread_mutex_assert_not_owner(&tmp_conn->mta_conn_mutex);
-    pthread_mutex_lock(&tmp_conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-    tmp_conn->need_mon = &src_tbl_conn->need_mon;
-    DBUG_ASSERT(!tmp_conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(!tmp_conn->mta_conn_mutex_unlock_later);
-    tmp_conn->mta_conn_mutex_lock_already = TRUE;
-    tmp_conn->mta_conn_mutex_unlock_later = TRUE;
+    spider_lock_before_query(tmp_conn, &src_tbl_conn->need_mon);
     if (select_ct->exec_query(
       tmp_conn,
       -1,
       &src_tbl_conn->need_mon)
     ) {
-      DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-      tmp_conn->mta_conn_mutex_lock_already = FALSE;
-      tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-      error_num = spider_db_errorno(tmp_conn);
+      error_num= spider_unlock_after_query_1(tmp_conn);
       if (error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM)
         my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
           ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
@@ -9493,12 +9040,7 @@ int spider_db_udf_copy_tables(
               my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
             result->free_result();
             delete result;
-            DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-            tmp_conn->mta_conn_mutex_lock_already = FALSE;
-            tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-            SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-            pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
+            spider_unlock_after_query(tmp_conn, 0);
             goto error_db_query;
           }
           for (dst_tbl_conn = dst_tbl_conn->next; dst_tbl_conn;
@@ -9512,12 +9054,7 @@ int spider_db_udf_copy_tables(
                 my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
               result->free_result();
               delete result;
-              DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-              DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-              tmp_conn->mta_conn_mutex_lock_already = FALSE;
-              tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-              SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-              pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
+              spider_unlock_after_query(tmp_conn, 0);
               goto error_db_query;
             }
           }
@@ -9542,12 +9079,7 @@ int spider_db_udf_copy_tables(
                 my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
               result->free_result();
               delete result;
-              DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-              DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-              tmp_conn->mta_conn_mutex_lock_already = FALSE;
-              tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-              SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-              pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
+              spider_unlock_after_query(tmp_conn, 0);
               goto error_db_query;
             }
             if (
@@ -9561,13 +9093,7 @@ int spider_db_udf_copy_tables(
               my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
               result->free_result();
               delete result;
-              DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-              DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-              tmp_conn->mta_conn_mutex_lock_already = FALSE;
-              tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-              SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-              pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
-              error_num = ER_OUT_OF_RESOURCES;
+              error_num= spider_unlock_after_query(tmp_conn, ER_OUT_OF_RESOURCES);
               goto error_db_query;
             }
             error_num = 0;
@@ -9577,22 +9103,12 @@ int spider_db_udf_copy_tables(
             my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
           result->free_result();
           delete result;
-          DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-          tmp_conn->mta_conn_mutex_lock_already = FALSE;
-          tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
+          spider_unlock_after_query(tmp_conn, 0);
           goto error_db_query;
         }
         result->free_result();
         delete result;
-        DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-        tmp_conn->mta_conn_mutex_lock_already = FALSE;
-        tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
+        spider_unlock_after_query(tmp_conn, 0);
         for (dst_tbl_conn = copy_tables->table_conn[1]; dst_tbl_conn;
           dst_tbl_conn = dst_tbl_conn->next)
         {
@@ -9611,12 +9127,7 @@ int spider_db_udf_copy_tables(
         }
         if (error_num)
         {
-          DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-          tmp_conn->mta_conn_mutex_lock_already = FALSE;
-          tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-          SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-          pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
+          spider_unlock_after_query(tmp_conn, 0);
           if (error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM)
             my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
               ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
@@ -9624,32 +9135,12 @@ int spider_db_udf_copy_tables(
         }
         error_num = HA_ERR_END_OF_FILE;
         end_of_file = TRUE;
-        DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-        tmp_conn->mta_conn_mutex_lock_already = FALSE;
-        tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
+        spider_unlock_after_query(tmp_conn, 0);
       }
     }
 
     if (!error_num && roop_count)
     {
-/*
-      dst_tbl_conn = copy_tables->table_conn[1];
-      spider_db_copy_table *source_ct = dst_tbl_conn->copy_table;
-      for (dst_tbl_conn = dst_tbl_conn->next; dst_tbl_conn;
-        dst_tbl_conn = dst_tbl_conn->next)
-      {
-        insert_ct = dst_tbl_conn->copy_table;
-        if (insert_ct->copy_insert_values(source_ct))
-        {
-          my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
-          error_num = ER_OUT_OF_RESOURCES;
-          goto error_db_query;
-        }
-      }
-*/
       if (copy_tables->bg_mode)
       {
         for (dst_tbl_conn = copy_tables->table_conn[1]; dst_tbl_conn;
@@ -9668,14 +9159,7 @@ int spider_db_udf_copy_tables(
         {
           tmp_conn = dst_tbl_conn->conn;
           insert_ct = dst_tbl_conn->copy_table;
-          pthread_mutex_assert_not_owner(&tmp_conn->mta_conn_mutex);
-          pthread_mutex_lock(&tmp_conn->mta_conn_mutex);
-          SPIDER_SET_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-          tmp_conn->need_mon = &dst_tbl_conn->need_mon;
-          DBUG_ASSERT(!tmp_conn->mta_conn_mutex_lock_already);
-          DBUG_ASSERT(!tmp_conn->mta_conn_mutex_unlock_later);
-          tmp_conn->mta_conn_mutex_lock_already = TRUE;
-          tmp_conn->mta_conn_mutex_unlock_later = TRUE;
+          spider_lock_before_query(tmp_conn, &dst_tbl_conn->need_mon);
           spider_conn_set_timeout_from_share(tmp_conn, 0,
             copy_tables->trx->thd, dst_tbl_conn->share);
           if (insert_ct->exec_query(
@@ -9683,22 +9167,13 @@ int spider_db_udf_copy_tables(
             -1,
             &dst_tbl_conn->need_mon)
           ) {
-            DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-            tmp_conn->mta_conn_mutex_lock_already = FALSE;
-            tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-            error_num = spider_db_errorno(tmp_conn);
+          error_num= spider_unlock_after_query_1(tmp_conn);
             if (error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM)
               my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
                 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
             goto error_db_query;
           } else {
-            DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
-            DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
-            tmp_conn->mta_conn_mutex_lock_already = FALSE;
-            tmp_conn->mta_conn_mutex_unlock_later = FALSE;
-            SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
-            pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
+            spider_unlock_after_query(tmp_conn, 0);
           }
         }
       }
diff --git a/storage/spider/spd_db_include.cc b/storage/spider/spd_db_include.cc
index 466e2eadf0c..0531f8a8ed9 100644
--- a/storage/spider/spd_db_include.cc
+++ b/storage/spider/spd_db_include.cc
@@ -17,7 +17,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "sql_class.h"
diff --git a/storage/spider/spd_db_mysql.cc b/storage/spider/spd_db_mysql.cc
index 26f16e22969..9c3438a2ed1 100644
--- a/storage/spider/spd_db_mysql.cc
+++ b/storage/spider/spd_db_mysql.cc
@@ -17,7 +17,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "sql_class.h"
@@ -2005,9 +2004,7 @@ int spider_db_mbase::connect(
       connect_retry_count--;
       my_sleep((ulong) connect_retry_interval);
     } else {
-#ifdef SPIDER_NET_HAS_THD
       db_conn->net.thd = NULL;
-#endif
       if (connect_mutex)
         pthread_mutex_unlock(&spider_open_conn_mutex);
       break;
@@ -2473,39 +2470,24 @@ int spider_db_mbase::select_db(
   DBUG_RETURN(mysql_select_db(db_conn, dbname));
 }
 
+static int spider_db_query_with_lock(SPIDER_CONN *conn, const char *query,
+                                     uint len, int *need_mon)
+{
+  int error_num= 0;
+  spider_lock_before_query(conn, need_mon);
+  if (spider_db_query(conn, query, len, -1, need_mon))
+    error_num= spider_db_errorno(conn);
+  return spider_unlock_after_query(conn, error_num);
+}
+
 int spider_db_mbase::consistent_snapshot(
   int *need_mon
 ) {
   DBUG_ENTER("spider_db_mbase::consistent_snapshot");
   DBUG_PRINT("info",("spider this=%p", this));
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = need_mon;
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
-  if (spider_db_query(
-    conn,
-    SPIDER_SQL_START_CONSISTENT_SNAPSHOT_STR,
-    SPIDER_SQL_START_CONSISTENT_SNAPSHOT_LEN,
-    -1,
-    need_mon)
-  ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    DBUG_RETURN(spider_db_errorno(conn));
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+  DBUG_RETURN(spider_db_query_with_lock(
+                conn, SPIDER_SQL_START_CONSISTENT_SNAPSHOT_STR,
+                SPIDER_SQL_START_CONSISTENT_SNAPSHOT_LEN, need_mon));
 }
 
 bool spider_db_mbase::trx_start_in_bulk_sql()
@@ -2540,82 +2522,30 @@ int spider_db_mbase::commit(
 ) {
   DBUG_ENTER("spider_db_mbase::commit");
   DBUG_PRINT("info",("spider this=%p", this));
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = need_mon;
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
-  if (spider_db_query(
-    conn,
-    SPIDER_SQL_COMMIT_STR,
-    SPIDER_SQL_COMMIT_LEN,
-    -1,
-    need_mon)
-  ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    DBUG_RETURN(spider_db_errorno(conn));
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+  DBUG_RETURN(spider_db_query_with_lock(conn, SPIDER_SQL_COMMIT_STR,
+                                        SPIDER_SQL_COMMIT_LEN, need_mon));
 }
 
 int spider_db_mbase::rollback(
   int *need_mon
 ) {
   bool is_error;
-  int error_num;
+  int error_num= 0;
   DBUG_ENTER("spider_db_mbase::rollback");
   DBUG_PRINT("info",("spider this=%p", this));
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = need_mon;
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
-  if (spider_db_query(
-    conn,
-    SPIDER_SQL_ROLLBACK_STR,
-    SPIDER_SQL_ROLLBACK_LEN,
-    -1,
-    need_mon)
-  ) {
-    is_error = conn->thd->is_error();
-    error_num = spider_db_errorno(conn);
-    if (
-      error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
-      !is_error
-    )
+  spider_lock_before_query(conn, need_mon);
+  if (spider_db_query(conn, SPIDER_SQL_ROLLBACK_STR,
+                      SPIDER_SQL_ROLLBACK_LEN, -1, need_mon))
+  {
+    is_error= conn->thd->is_error();
+    error_num= spider_db_errorno(conn);
+    if (error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM && !is_error)
+    {
       conn->thd->clear_error();
-    else {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
-      DBUG_RETURN(error_num);
+      error_num= 0;
     }
   }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+  DBUG_RETURN(spider_unlock_after_query(conn, error_num));
 }
 
 int spider_db_mbase::xa_start(
@@ -2648,34 +2578,8 @@ int spider_db_mbase::xa_end(
   sql_str.length(0);
   sql_str.q_append(SPIDER_SQL_XA_END_STR, SPIDER_SQL_XA_END_LEN);
   spider_db_append_xid_str(&sql_str, xid);
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = need_mon;
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
-  if (spider_db_query(
-    conn,
-    sql_str.ptr(),
-    sql_str.length(),
-    -1,
-    need_mon)
-  ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    DBUG_RETURN(spider_db_errorno(conn));
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+  DBUG_RETURN(spider_db_query_with_lock(conn, sql_str.ptr(),
+                                        sql_str.length(), need_mon));
 }
 
 int spider_db_mbase::xa_prepare(
@@ -2691,34 +2595,8 @@ int spider_db_mbase::xa_prepare(
   sql_str.length(0);
   sql_str.q_append(SPIDER_SQL_XA_PREPARE_STR, SPIDER_SQL_XA_PREPARE_LEN);
   spider_db_append_xid_str(&sql_str, xid);
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = need_mon;
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
-  if (spider_db_query(
-    conn,
-    sql_str.ptr(),
-    sql_str.length(),
-    -1,
-    need_mon)
-  ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    DBUG_RETURN(spider_db_errorno(conn));
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+  DBUG_RETURN(spider_db_query_with_lock(conn, sql_str.ptr(),
+                                        sql_str.length(), need_mon));
 }
 
 int spider_db_mbase::xa_commit(
@@ -2734,34 +2612,8 @@ int spider_db_mbase::xa_commit(
   sql_str.length(0);
   sql_str.q_append(SPIDER_SQL_XA_COMMIT_STR, SPIDER_SQL_XA_COMMIT_LEN);
   spider_db_append_xid_str(&sql_str, xid);
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = need_mon;
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
-  if (spider_db_query(
-    conn,
-    sql_str.ptr(),
-    sql_str.length(),
-    -1,
-    need_mon)
-  ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    DBUG_RETURN(spider_db_errorno(conn));
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+  DBUG_RETURN(spider_db_query_with_lock(conn, sql_str.ptr(),
+                                        sql_str.length(), need_mon));
 }
 
 int spider_db_mbase::xa_rollback(
@@ -2777,34 +2629,8 @@ int spider_db_mbase::xa_rollback(
   sql_str.length(0);
   sql_str.q_append(SPIDER_SQL_XA_ROLLBACK_STR, SPIDER_SQL_XA_ROLLBACK_LEN);
   spider_db_append_xid_str(&sql_str, xid);
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = need_mon;
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
-  if (spider_db_query(
-    conn,
-    sql_str.ptr(),
-    sql_str.length(),
-    -1,
-    need_mon)
-  ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    DBUG_RETURN(spider_db_errorno(conn));
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+  DBUG_RETURN(spider_db_query_with_lock(conn, sql_str.ptr(),
+                                        sql_str.length(), need_mon));
 }
 
 bool spider_db_mbase::set_trx_isolation_in_bulk_sql()
@@ -2823,121 +2649,21 @@ int spider_db_mbase::set_trx_isolation(
   switch (trx_isolation)
   {
     case ISO_READ_UNCOMMITTED:
-      pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-      pthread_mutex_lock(&conn->mta_conn_mutex);
-      SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      conn->need_mon = need_mon;
-      DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = TRUE;
-      conn->mta_conn_mutex_unlock_later = TRUE;
-      if (spider_db_query(
-        conn,
-        SPIDER_SQL_ISO_READ_UNCOMMITTED_STR,
-        SPIDER_SQL_ISO_READ_UNCOMMITTED_LEN,
-        -1,
-        need_mon)
-      ) {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        DBUG_RETURN(spider_db_errorno(conn));
-      }
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
-      break;
+      DBUG_RETURN(spider_db_query_with_lock(
+                    conn, SPIDER_SQL_ISO_READ_UNCOMMITTED_STR,
+                    SPIDER_SQL_ISO_READ_UNCOMMITTED_LEN, need_mon));
     case ISO_READ_COMMITTED:
-      pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-      pthread_mutex_lock(&conn->mta_conn_mutex);
-      SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      conn->need_mon = need_mon;
-      DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = TRUE;
-      conn->mta_conn_mutex_unlock_later = TRUE;
-      if (spider_db_query(
-        conn,
-        SPIDER_SQL_ISO_READ_COMMITTED_STR,
-        SPIDER_SQL_ISO_READ_COMMITTED_LEN,
-        -1,
-        need_mon)
-      ) {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        DBUG_RETURN(spider_db_errorno(conn));
-      }
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
-      break;
+      DBUG_RETURN(spider_db_query_with_lock(
+                    conn, SPIDER_SQL_ISO_READ_COMMITTED_STR,
+                    SPIDER_SQL_ISO_READ_COMMITTED_LEN, need_mon));
     case ISO_REPEATABLE_READ:
-      pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-      pthread_mutex_lock(&conn->mta_conn_mutex);
-      SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      conn->need_mon = need_mon;
-      DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = TRUE;
-      conn->mta_conn_mutex_unlock_later = TRUE;
-      if (spider_db_query(
-        conn,
-        SPIDER_SQL_ISO_REPEATABLE_READ_STR,
-        SPIDER_SQL_ISO_REPEATABLE_READ_LEN,
-        -1,
-        need_mon)
-      ) {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        DBUG_RETURN(spider_db_errorno(conn));
-      }
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
-      break;
+      DBUG_RETURN(spider_db_query_with_lock(
+                    conn, SPIDER_SQL_ISO_REPEATABLE_READ_STR,
+                    SPIDER_SQL_ISO_REPEATABLE_READ_LEN, need_mon));
     case ISO_SERIALIZABLE:
-      pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-      pthread_mutex_lock(&conn->mta_conn_mutex);
-      SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      conn->need_mon = need_mon;
-      DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = TRUE;
-      conn->mta_conn_mutex_unlock_later = TRUE;
-      if (spider_db_query(
-        conn,
-        SPIDER_SQL_ISO_SERIALIZABLE_STR,
-        SPIDER_SQL_ISO_SERIALIZABLE_LEN,
-        -1,
-        need_mon)
-      ) {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        DBUG_RETURN(spider_db_errorno(conn));
-      }
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
-      break;
+      DBUG_RETURN(spider_db_query_with_lock(
+                    conn, SPIDER_SQL_ISO_SERIALIZABLE_STR,
+                    SPIDER_SQL_ISO_SERIALIZABLE_LEN, need_mon));
     default:
       DBUG_RETURN(HA_ERR_UNSUPPORTED);
   }
@@ -2958,64 +2684,12 @@ int spider_db_mbase::set_autocommit(
   DBUG_ENTER("spider_db_mbase::set_autocommit");
   DBUG_PRINT("info",("spider this=%p", this));
   if (autocommit)
-  {
-    pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-    pthread_mutex_lock(&conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    conn->need_mon = need_mon;
-    DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = TRUE;
-    conn->mta_conn_mutex_unlock_later = TRUE;
-    if (spider_db_query(
-      conn,
-      SPIDER_SQL_AUTOCOMMIT_ON_STR,
-      SPIDER_SQL_AUTOCOMMIT_ON_LEN,
-      -1,
-      need_mon)
-    ) {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      DBUG_RETURN(spider_db_errorno(conn));
-    }
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
-  } else {
-    pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-    pthread_mutex_lock(&conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    conn->need_mon = need_mon;
-    DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = TRUE;
-    conn->mta_conn_mutex_unlock_later = TRUE;
-    if (spider_db_query(
-      conn,
-      SPIDER_SQL_AUTOCOMMIT_OFF_STR,
-      SPIDER_SQL_AUTOCOMMIT_OFF_LEN,
-      -1,
-      need_mon)
-    ) {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      DBUG_RETURN(spider_db_errorno(conn));
-    }
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
-  }
-  DBUG_RETURN(0);
+    DBUG_RETURN(spider_db_query_with_lock(
+                  conn, SPIDER_SQL_AUTOCOMMIT_ON_STR,
+                  SPIDER_SQL_AUTOCOMMIT_ON_LEN, need_mon));
+  DBUG_RETURN(spider_db_query_with_lock(
+                conn, SPIDER_SQL_AUTOCOMMIT_OFF_STR,
+                SPIDER_SQL_AUTOCOMMIT_OFF_LEN, need_mon));
 }
 
 bool spider_db_mbase::set_sql_log_off_in_bulk_sql()
@@ -3032,64 +2706,12 @@ int spider_db_mbase::set_sql_log_off(
   DBUG_ENTER("spider_db_mbase::set_sql_log_off");
   DBUG_PRINT("info",("spider this=%p", this));
   if (sql_log_off)
-  {
-    pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-    pthread_mutex_lock(&conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    conn->need_mon = need_mon;
-    DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = TRUE;
-    conn->mta_conn_mutex_unlock_later = TRUE;
-    if (spider_db_query(
-      conn,
-      SPIDER_SQL_SQL_LOG_ON_STR,
-      SPIDER_SQL_SQL_LOG_ON_LEN,
-      -1,
-      need_mon)
-    ) {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      DBUG_RETURN(spider_db_errorno(conn));
-    }
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
-  } else {
-    pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-    pthread_mutex_lock(&conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    conn->need_mon = need_mon;
-    DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = TRUE;
-    conn->mta_conn_mutex_unlock_later = TRUE;
-    if (spider_db_query(
-      conn,
-      SPIDER_SQL_SQL_LOG_OFF_STR,
-      SPIDER_SQL_SQL_LOG_OFF_LEN,
-      -1,
-      need_mon)
-    ) {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      DBUG_RETURN(spider_db_errorno(conn));
-    }
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
-  }
-  DBUG_RETURN(0);
+    DBUG_RETURN(spider_db_query_with_lock(
+                  conn, SPIDER_SQL_SQL_LOG_ON_STR,
+                  SPIDER_SQL_SQL_LOG_ON_LEN, need_mon));
+  DBUG_RETURN(spider_db_query_with_lock(
+                conn, SPIDER_SQL_SQL_LOG_OFF_STR,
+                SPIDER_SQL_SQL_LOG_OFF_LEN, need_mon));
 }
 
 bool spider_db_mbase::set_wait_timeout_in_bulk_sql()
@@ -3117,34 +2739,8 @@ int spider_db_mbase::set_wait_timeout(
     DBUG_RETURN(HA_ERR_OUT_OF_MEM);
   sql_str.q_append(SPIDER_SQL_WAIT_TIMEOUT_STR, SPIDER_SQL_WAIT_TIMEOUT_LEN);
   sql_str.q_append(timeout_str, timeout_str_length);
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = need_mon;
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
-  if (spider_db_query(
-    conn,
-    sql_str.ptr(),
-    sql_str.length(),
-    -1,
-    need_mon)
-  ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    DBUG_RETURN(spider_db_errorno(conn));
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+  DBUG_RETURN(spider_db_query_with_lock(
+                conn, sql_str.ptr(), sql_str.length(), need_mon));
 }
 
 bool spider_db_mbase::set_sql_mode_in_bulk_sql()
@@ -3182,34 +2778,8 @@ int spider_db_mbase::set_sql_mode(
     }
   }
   sql_str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = need_mon;
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
-  if (spider_db_query(
-    conn,
-    sql_str.ptr(),
-    sql_str.length(),
-    -1,
-    need_mon)
-  ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    DBUG_RETURN(spider_db_errorno(conn));
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+  DBUG_RETURN(spider_db_query_with_lock(
+                conn, sql_str.ptr(), sql_str.length(), need_mon));
 }
 
 bool spider_db_mbase::set_time_zone_in_bulk_sql()
@@ -3236,34 +2806,8 @@ int spider_db_mbase::set_time_zone(
   sql_str.q_append(SPIDER_SQL_TIME_ZONE_STR, SPIDER_SQL_TIME_ZONE_LEN);
   sql_str.q_append(tz_str->ptr(), tz_str->length());
   sql_str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = need_mon;
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
-  if (spider_db_query(
-    conn,
-    sql_str.ptr(),
-    sql_str.length(),
-    -1,
-    need_mon)
-  ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    DBUG_RETURN(spider_db_errorno(conn));
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+  DBUG_RETURN(spider_db_query_with_lock(
+                conn, sql_str.ptr(), sql_str.length(), need_mon));
 }
 
 int spider_db_mbase::exec_simple_sql_with_result(
@@ -3275,18 +2819,10 @@ int spider_db_mbase::exec_simple_sql_with_result(
   int *need_mon,
   SPIDER_DB_RESULT **res
 ) {
-  int error_num;
+  int error_num= 0;
   DBUG_ENTER("spider_db_mbase::exec_simple_sql_with_result");
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = need_mon;
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
-  spider_conn_set_timeout_from_share(conn, all_link_idx, trx->thd,
-    share);
+  spider_lock_before_query(conn, need_mon);
+  spider_conn_set_timeout_from_share(conn, all_link_idx, trx->thd, share);
   if (
     (error_num = spider_db_set_names_internal(trx, share, conn,
       all_link_idx, need_mon)) ||
@@ -3300,92 +2836,39 @@ int spider_db_mbase::exec_simple_sql_with_result(
       (error_num = spider_db_errorno(conn))
     )
   ) {
-    if (
-      error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
-      !conn->disable_reconnect
-    ) {
-      /* retry */
-      if ((error_num = spider_db_ping_internal(share, conn,
-        all_link_idx, need_mon)))
-      {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
-        DBUG_PRINT("info", ("spider error_num=%d 1", error_num));
-        DBUG_RETURN(error_num);
-      }
-      if ((error_num = spider_db_set_names_internal(trx, share, conn,
-        all_link_idx, need_mon)))
-      {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
-        DBUG_PRINT("info", ("spider error_num=%d 2", error_num));
-        DBUG_RETURN(error_num);
-      }
-      spider_conn_set_timeout_from_share(conn, all_link_idx, trx->thd,
-        share);
-      if (spider_db_query(
-        conn,
-        sql,
-        sql_length,
-        -1,
-        need_mon)
+      if (
+        error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
+        !conn->disable_reconnect
       ) {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        DBUG_PRINT("info", ("spider error_num=%d 3", error_num));
-        DBUG_RETURN(spider_db_errorno(conn));
-      }
-    } else {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
-      DBUG_PRINT("info", ("spider error_num=%d 4", error_num));
-      DBUG_RETURN(error_num);
+        if ((error_num = spider_db_ping_internal(share, conn,
+          all_link_idx, need_mon)))
+          goto unlock;
+        if ((error_num= spider_db_set_names_internal(trx, share, conn,
+          all_link_idx, need_mon)))
+          goto unlock;
+        spider_conn_set_timeout_from_share(conn, all_link_idx, trx->thd,
+          share);
+        if (spider_db_query(
+              conn,
+              sql,
+              sql_length,
+              -1,
+              need_mon)
+        ) {
+          error_num= spider_db_errorno(conn);
+          goto unlock;
+        }
+      } else
+        goto unlock;
     }
-  }
-  if (!(*res = store_result(NULL, NULL, &error_num)))
-  {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    if (error_num)
+    if (!(*res = store_result(NULL, NULL, &error_num)))
     {
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
-      DBUG_PRINT("info", ("spider error_num=%d 5", error_num));
-      DBUG_RETURN(error_num);
+      if (error_num || (error_num= spider_db_errorno(conn)) ||
+          (error_num= ER_QUERY_ON_FOREIGN_DATA_SOURCE))
+        goto unlock;
     }
-    else if ((error_num = spider_db_errorno(conn)))
-    {
-      DBUG_PRINT("info", ("spider error_num=%d 6", error_num));
-      DBUG_RETURN(error_num);
-    } else {
-      DBUG_PRINT("info", ("spider error_num=%d 7",
-        ER_QUERY_ON_FOREIGN_DATA_SOURCE));
-      DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE);
-    }
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+unlock:
+    DBUG_RETURN(spider_unlock_after_query(conn, error_num));
 }
 
 int spider_db_mbase::show_master_status(
@@ -3438,10 +2921,6 @@ int spider_db_mbase::show_master_status(
       spider_store_binlog_pos_gtid(table, NULL, 0, conn->access_charset);
     }
   }
-/*
-  res->free_result();
-  delete res;
-*/
   if (error_num)
   {
     DBUG_PRINT("info", ("spider error_num=%d 2", error_num));
@@ -3507,10 +2986,6 @@ int spider_db_mbase::select_binlog_gtid_pos(
   {
     spider_store_binlog_pos_gtid(table, gtid_pos, strlen(gtid_pos), conn->access_charset);
   }
-/*
-  res->free_result();
-  delete res;
-*/
   if (error_num)
   {
     DBUG_PRINT("info", ("spider error_num=%d 2", error_num));
@@ -4019,70 +3494,15 @@ int spider_db_mysql_util::append_column_value(
       ptr = tmp_str.get_str();
     } else if (field->type() == MYSQL_TYPE_GEOMETRY)
     {
-/*
-      uint mlength = SIZEOF_STORED_DOUBLE, lcnt;
-      uchar *dest = (uchar *) buf;
-      const uchar *source;
-      for (lcnt = 0; lcnt < 4; lcnt++)
-      {
-        mlength = SIZEOF_STORED_DOUBLE;
-        source = new_ptr + mlength + SIZEOF_STORED_DOUBLE * lcnt;
-        while (mlength--)
-          *dest++ = *--source;
-      }
-      tmp_str.length(SIZEOF_STORED_DOUBLE * lcnt);
-*/
 #ifdef DBUG_TRACE
       double xmin, xmax, ymin, ymax;
-/*
-      float8store(buf,xmin);
-      float8store(buf+8,xmax);
-      float8store(buf+16,ymin);
-      float8store(buf+24,ymax);
-      memcpy(&xmin,new_ptr,sizeof(xmin));
-      memcpy(&xmax,new_ptr + 8,sizeof(xmax));
-      memcpy(&ymin,new_ptr + 16,sizeof(ymin));
-      memcpy(&ymax,new_ptr + 24,sizeof(ymax));
-      float8get(xmin, buf);
-      float8get(xmax, buf + 8);
-      float8get(ymin, buf + 16);
-      float8get(ymax, buf + 24);
-      DBUG_PRINT("info", ("spider geo is %f %f %f %f",
-        xmin, xmax, ymin, ymax));
-      DBUG_PRINT("info", ("spider geo is %.14g %.14g %.14g %.14g",
-        xmin, xmax, ymin, ymax));
-*/
       float8get(xmin, new_ptr);
       float8get(xmax, new_ptr + 8);
       float8get(ymin, new_ptr + 16);
       float8get(ymax, new_ptr + 24);
       DBUG_PRINT("info", ("spider geo is %f %f %f %f",
         xmin, xmax, ymin, ymax));
-/*
-      float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 4);
-      float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 5);
-      float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 6);
-      float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 7);
-      DBUG_PRINT("info", ("spider geo is %f %f %f %f",
-        xmin, xmax, ymin, ymax));
-      float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 8);
-      float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 9);
-      float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 10);
-      float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 11);
-      DBUG_PRINT("info", ("spider geo is %f %f %f %f",
-        xmin, xmax, ymin, ymax));
-      float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 12);
-      float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 13);
-      float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 14);
-      float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 15);
-      DBUG_PRINT("info", ("spider geo is %f %f %f %f",
-        xmin, xmax, ymin, ymax));
-*/
 #endif
-/*
-      tmp_str.set((char *) new_ptr, SIZEOF_STORED_DOUBLE * 4,
-        &my_charset_bin);
-*/
       tmp_str.length(0);
       tmp_str.q_append((char *) SPIDER_SQL_LINESTRING_HEAD_STR,
         SPIDER_SQL_LINESTRING_HEAD_LEN);
@@ -4111,27 +3531,6 @@ int spider_db_mysql_util::append_column_value(
 
   DBUG_PRINT("info", ("spider field->type() is %d", field->type()));
   DBUG_PRINT("info", ("spider ptr->length() is %d", ptr->length()));
-/*
-  if (
-    field->type() == MYSQL_TYPE_BIT ||
-    (field->type() >= MYSQL_TYPE_TINY_BLOB &&
-      field->type() <= MYSQL_TYPE_BLOB)
-  ) {
-    uchar *hex_ptr = (uchar *) ptr->ptr(), *end_ptr;
-    char *str_ptr;
-    DBUG_PRINT("info", ("spider HEX"));
-    if (str->reserve(SPIDER_SQL_HEX_LEN + ptr->length() * 2))
-      DBUG_RETURN(HA_ERR_OUT_OF_MEM);
-    str->q_append(SPIDER_SQL_HEX_STR, SPIDER_SQL_HEX_LEN);
-    str_ptr = (char *) str->ptr() + str->length();
-    for (end_ptr = hex_ptr + ptr->length(); hex_ptr < end_ptr; hex_ptr++)
-    {
-      *str_ptr++ = spider_dig_upper[(*hex_ptr) >> 4];
-      *str_ptr++ = spider_dig_upper[(*hex_ptr) & 0x0F];
-    }
-    str->length(str->length() + ptr->length() * 2);
-  } else 
-*/
   if (field->result_type() == STRING_RESULT)
   {
     DBUG_PRINT("info", ("spider STRING_RESULT"));
@@ -7979,180 +7378,105 @@ int spider_mbase_share::discover_table_structure(
     sql_str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
 
     SPIDER_CONN *conn;
-    int need_mon;
+    int need_mon_deref;
+    int *need_mon= &need_mon_deref;
     if (!(conn= spider_get_conn(spider_share, 0,
                                 spider_share->conn_keys[roop_count], trx, NULL,
                                 FALSE, FALSE, &error_num)))
     {
       DBUG_RETURN(error_num);
     }
-    pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-    pthread_mutex_lock(&conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    conn->need_mon = &need_mon;
-    DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = TRUE;
-    conn->mta_conn_mutex_unlock_later = TRUE;
+    spider_lock_before_query(conn, need_mon);
     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.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;
-      if ((error_num = spider_db_ping(&tmp_spider, conn, 0)))
+      int need_mon= 0;
+      uint tmp_conn_link_idx= 0;
+      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;
+      if ((error_num= spider_db_ping(&tmp_spider, conn, 0)))
       {
-        DBUG_PRINT("info",("spider spider_db_ping error"));
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
+        spider_unlock_after_query(conn, 0);
         continue;
       }
     }
     spider_conn_set_timeout_from_share(conn, roop_count, trx->thd,
-      spider_share);
-    if (
-      (error_num = spider_db_set_names_internal(trx, spider_share, conn,
-        roop_count, &need_mon)) ||
-      (
-        spider_db_query(
-          conn,
-          sql_str.ptr(),
-          sql_str.length(),
-          -1,
-          &need_mon) &&
-        (error_num = spider_db_errorno(conn))
-      )
-    ) {
-      DBUG_PRINT("info",("spider spider_get_trx error"));
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+                                         spider_share);
+    if ((error_num= spider_db_set_names_internal(trx, spider_share, conn,
+                                                 roop_count, need_mon)) ||
+        (spider_db_query(conn, sql_str.ptr(), sql_str.length(), -1,
+                         need_mon) &&
+         (error_num= spider_db_errorno(conn))))
+    {
+      spider_unlock_after_query(conn, 0);
       continue;
     }
     st_spider_db_request_key request_key;
-    request_key.spider_thread_id = trx->spider_thread_id;
-    request_key.query_id = trx->thd->query_id;
-    request_key.handler = NULL;
-    request_key.request_id = 1;
-    request_key.next = NULL;
-    spider_db_result *res;
+    request_key.spider_thread_id= trx->spider_thread_id;
+    request_key.query_id= trx->thd->query_id; request_key.handler= NULL;
+    request_key.request_id= 1; request_key.next= NULL;
+    spider_db_result * res;
     /* get column list */
-    if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
-    {
-      if (error_num || (error_num = spider_db_errorno(conn)))
+    if (!(res= conn->db_conn->store_result(NULL, &request_key,
+                                           &error_num))) {
+      if (error_num || (error_num= spider_db_errorno(conn)))
       {
-        DBUG_PRINT("info",("spider column store error"));
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
+        spider_unlock_after_query(conn, 0);
         continue;
       }
-      /* no record */
-      DBUG_PRINT("info",("spider column no record error"));
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+      spider_unlock_after_query(conn, 0);
       continue;
     }
-    if ((error_num = res->fetch_columns_for_discover_table_structure(str,
-      spider_share->access_charset)))
-    {
-      DBUG_PRINT("info",("spider column fetch error"));
+    if ((error_num=
+         res->fetch_columns_for_discover_table_structure(
+           str, spider_share->access_charset))) {
+      DBUG_PRINT("info", ("spider column fetch error"));
       res->free_result();
       delete res;
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
       my_printf_error(ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM,
-        ER_SPIDER_REMOTE_TABLE_NOT_FOUND_STR, MYF(0),
-        db_names_str[roop_count].ptr(),
-        table_names_str[roop_count].ptr());
-      error_num = ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM;
+                      ER_SPIDER_REMOTE_TABLE_NOT_FOUND_STR, MYF(0),
+                      db_names_str[roop_count].ptr(),
+                      table_names_str[roop_count].ptr());
+      error_num= ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM;
+      spider_unlock_after_query(conn, 0);
       continue;
     }
     res->free_result();
     delete res;
     if (conn->db_conn->next_result())
     {
-      DBUG_PRINT("info",("spider single result error"));
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+      spider_unlock_after_query(conn, 0);
       continue;
     }
     /* get index list */
-    if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
-    {
-      if (error_num || (error_num = spider_db_errorno(conn)))
+    if (!(res= conn->db_conn->store_result(NULL, &request_key,
+                                           &error_num))) {
+      if (error_num || (error_num= spider_db_errorno(conn)))
       {
-        DBUG_PRINT("info",("spider index store error"));
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
+        spider_unlock_after_query(conn, 0);
         continue;
       }
-      /* no record */
-      DBUG_PRINT("info",("spider index no record error"));
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+      spider_unlock_after_query(conn, 0);
       continue;
     }
-    if ((error_num = res->fetch_index_for_discover_table_structure(str,
-      spider_share->access_charset)))
-    {
-      DBUG_PRINT("info",("spider index fetch error"));
+    if ((error_num=
+         res->fetch_index_for_discover_table_structure(
+           str, spider_share->access_charset))) {
+      DBUG_PRINT("info", ("spider index fetch error"));
       res->free_result();
       delete res;
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+      spider_unlock_after_query(conn, 0);
       continue;
     }
     res->free_result();
     delete res;
-    if (conn->db_conn->next_result())
-    {
-      DBUG_PRINT("info",("spider dual result error"));
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+    if (conn->db_conn->next_result()) {
+      DBUG_PRINT("info", ("spider dual result error"));
+      spider_unlock_after_query(conn, 0);
       continue;
     }
     /* get table info */
@@ -8161,48 +7485,30 @@ int spider_mbase_share::discover_table_structure(
       if (error_num || (error_num = spider_db_errorno(conn)))
       {
         DBUG_PRINT("info",("spider table store error"));
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
+        spider_unlock_after_query(conn, 0);
         continue;
       }
       /* no record */
       DBUG_PRINT("info",("spider table no record error"));
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+      spider_unlock_after_query(conn, 0);
       continue;
     }
     if ((error_num = res->fetch_table_for_discover_table_structure(str,
-      spider_share, spider_share->access_charset)))
+     spider_share, spider_share->access_charset)))
     {
       DBUG_PRINT("info",("spider table fetch error"));
       res->free_result();
       delete res;
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+      spider_unlock_after_query(conn, 0);
       continue;
     }
     res->free_result();
     delete res;
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
     if (!error_num)
+    {
+      spider_unlock_after_query(conn, 0);
       break;
+    }
   }
   DBUG_RETURN(error_num);
 }
@@ -13191,35 +12497,6 @@ int spider_db_mbase::reset_lock_wait_timeout()
   DBUG_RETURN(0);
 }
 
-/** FIXME: refactor more functions to use spider_setup_for_query() and
-spider_teardown_after_query(). */
-void spider_setup_for_query(ha_spider *spider, SPIDER_CONN *conn, int link_idx)
-{
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon= &spider->need_mons[link_idx];
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already= TRUE;
-  conn->mta_conn_mutex_unlock_later= TRUE;
-  conn->disable_connect_retry= TRUE;
-}
-
-int spider_teardown_after_query(SPIDER_CONN *conn, int error_num, bool clear)
-{
-  conn->disable_connect_retry= FALSE;
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already= FALSE;
-  conn->mta_conn_mutex_unlock_later= FALSE;
-  if (clear)
-  {
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
-  }
-  return error_num;
-}
 /**
   Executes show table status query and stores results in share->stat
 */
@@ -13238,7 +12515,8 @@ int spider_mbase_handler::show_table_status(
   DBUG_ENTER("spider_mbase_handler::show_table_status");
   DBUG_PRINT("info",("spider sts_mode=%d", sts_mode));
 
-  spider_setup_for_query(spider, conn, link_idx);
+  spider_lock_before_query(conn, &spider->need_mons[link_idx]);
+  conn->disable_connect_retry = TRUE;
   spider_conn_set_timeout_from_share(
     conn, link_idx, spider->wide_handler->trx->thd, share);
 
@@ -13259,15 +12537,15 @@ int spider_mbase_handler::show_table_status(
     {
       /* retry */
       if ((error_num = spider_db_ping(spider, conn, link_idx)))
-        DBUG_RETURN(spider_teardown_after_query(conn, error_num, true));
+        goto unlock;
       if ((error_num = spider_db_set_names(spider, conn, link_idx)))
-        DBUG_RETURN(spider_teardown_after_query(conn, error_num, true));
+        goto unlock;
       spider_conn_set_timeout_from_share(conn, link_idx,
                                          spider->wide_handler->trx->thd,
                                          share);
       if ((error_num =
            spider_set_lock_wait_timeout(1, conn, &spider->need_mons[link_idx])))
-        DBUG_RETURN(spider_teardown_after_query(conn, error_num, true));
+        goto unlock;
       if (spider_db_query(
             conn,
             mysql_share->show_table_status[pos].ptr(),
@@ -13275,45 +12553,40 @@ int spider_mbase_handler::show_table_status(
             -1,
             &spider->need_mons[link_idx])
       ) {
-        spider_teardown_after_query(conn, 0, false);
-        DBUG_RETURN(spider_db_errorno(conn));
+        goto unlock;
       }
     } else
-      DBUG_RETURN(spider_teardown_after_query(conn, error_num, true));
+      goto unlock;
   }
-  st_spider_db_request_key request_key = {
-    spider->wide_handler->trx->spider_thread_id,
-    spider->wide_handler->trx->thd->query_id, spider, 1, NULL};
+  error_num= 0;
+  st_spider_db_request_key request_key;
+  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;
   if (spider_param_dry_access())
-    DBUG_RETURN(spider_teardown_after_query(conn, 0, true));
+    goto unlock;
   if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
   {
-    if (sts_mode == 1)          /* get from status table */
+    if (error_num || (error_num = spider_db_errorno(conn)))
+      goto unlock;
+    else if (sts_mode == 1)
     {
-      if (error_num)
-        DBUG_RETURN(spider_teardown_after_query(conn, error_num, true));
-      spider_teardown_after_query(conn, 0, false);
-      if ((error_num = spider_db_errorno(conn)))
-        DBUG_RETURN(error_num);
-      else
-      {
-        my_printf_error(
-          ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM,
-          ER_SPIDER_REMOTE_TABLE_NOT_FOUND_STR, MYF(0),
-          mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
-          mysql_share->table_names_str[spider->conn_link_idx[link_idx]].ptr());
-        DBUG_RETURN(ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM);
-      }
-    } else                      /* get from information schema */
+      my_printf_error(ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM,
+        ER_SPIDER_REMOTE_TABLE_NOT_FOUND_STR, MYF(0),
+        mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
+        mysql_share->table_names_str[spider->conn_link_idx[
+          link_idx]].ptr());
+      error_num= ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM;
+      goto unlock;
+    }
+    else                      /* sts_mode != 1 */
     {
-      spider_teardown_after_query(conn, error_num, false);
-      if (error_num || (error_num= spider_db_errorno(conn)))
-        DBUG_RETURN(error_num);
-      else
-        DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE);
+      error_num= ER_QUERY_ON_FOREIGN_DATA_SOURCE;
+      goto unlock;
     }
   }
-  spider_teardown_after_query(conn, 0, true);
   /* Fetches query results into share->stat. */
   error_num = res->fetch_table_status(sts_mode, share->stat);
   auto_increment_value = share->stat.auto_increment_value;
@@ -13340,7 +12613,7 @@ int spider_mbase_handler::show_table_status(
     default:
       break;
     }
-    DBUG_RETURN(error_num);
+    goto unlock;
   }
   if ((error_num = ((spider_db_mbase *) conn->db_conn)->fetch_and_print_warnings(NULL)))
   {
@@ -13354,11 +12627,11 @@ int spider_mbase_handler::show_table_status(
         mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
         mysql_share->table_names_str[spider->conn_link_idx[link_idx]].ptr());
     }
-    DBUG_RETURN(error_num);
+    goto unlock;
   }
   if ((error_num =
        ((spider_db_mbase *) conn->db_conn)->reset_lock_wait_timeout()))
-    DBUG_RETURN(error_num);
+    goto unlock;
   if (share->static_records_for_status != -1)
     share->stat.records = (ha_rows) share->static_records_for_status;
   if (share->static_mean_rec_length != -1)
@@ -13367,9 +12640,11 @@ int spider_mbase_handler::show_table_status(
   {
     share->lgtm_tblhnd_share->auto_increment_value = auto_increment_value;
     DBUG_PRINT("info",("spider auto_increment_value=%llu",
-      share->lgtm_tblhnd_share->auto_increment_value));
+                       share->lgtm_tblhnd_share->auto_increment_value));
   }
-  DBUG_RETURN(0);
+unlock:
+  conn->disable_connect_retry = FALSE;
+  DBUG_RETURN(spider_unlock_after_query(conn, error_num));
 }
 
 int spider_mbase_handler::crd_mode_exchange(
@@ -13395,7 +12670,7 @@ int spider_mbase_handler::show_index(
     (crd_mode == 1 ? 0 : 1);
   DBUG_ENTER("spider_mbase_handler::show_index");
   DBUG_PRINT("info",("spider crd_mode=%d", crd_mode));
-  spider_setup_for_query(spider, conn, link_idx);
+  spider_lock_before_query(conn, &spider->need_mons[link_idx]);
   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)) ||
@@ -13407,22 +12682,22 @@ int spider_mbase_handler::show_index(
         mysql_share->show_index[pos].length(),
         -1,
         &spider->need_mons[link_idx]) &&
-      (error_num = spider_db_errorno(conn))))
+       (error_num = spider_db_errorno(conn))))
   {
     if (error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
         !conn->disable_reconnect)
     {
       /* retry */
       if ((error_num = spider_db_ping(spider, conn, link_idx)))
-        DBUG_RETURN(spider_teardown_after_query(conn, error_num, true));
+        goto unlock;
       if ((error_num = spider_db_set_names(spider, conn, link_idx)))
-        DBUG_RETURN(spider_teardown_after_query(conn, error_num, true));
+        goto unlock;
       spider_conn_set_timeout_from_share(conn, link_idx,
                                          spider->wide_handler->trx->thd,
                                          share);
       if ((error_num =
            spider_set_lock_wait_timeout(1, conn, &spider->need_mons[link_idx])))
-        DBUG_RETURN(spider_teardown_after_query(conn, error_num, true));
+        goto unlock;
       if (spider_db_query(
             conn,
             mysql_share->show_index[pos].ptr(),
@@ -13430,20 +12705,25 @@ int spider_mbase_handler::show_index(
             -1,
             &spider->need_mons[link_idx]))
       {
-        spider_teardown_after_query(conn, 0, false);
-        DBUG_RETURN(spider_db_errorno(conn));
+        error_num= spider_db_errorno(conn);
+        goto unlock;
       }
     } else
-      DBUG_RETURN(spider_teardown_after_query(conn, error_num, true));
+      goto unlock;
+  }
+  error_num= 0;
+  st_spider_db_request_key request_key;
+  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;
+  if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
+  {
+    if (error_num || (error_num = spider_db_errorno(conn)))
+      goto unlock;
+    /* no record is ok */
   }
-  st_spider_db_request_key request_key = {
-    spider->wide_handler->trx->spider_thread_id,
-    spider->wide_handler->trx->thd->query_id, spider, 1, NULL};
-  /* no record is ok */
-  if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)) &&
-      (error_num || (error_num = spider_db_errorno(conn))))
-    DBUG_RETURN(spider_teardown_after_query(conn, error_num, true));
-  spider_teardown_after_query(conn, 0, true);
   if (res)
     error_num = res->fetch_table_cardinality(
       crd_mode, table, share->cardinality, share->cardinality_upd,
@@ -13464,30 +12744,35 @@ int spider_mbase_handler::show_index(
     res->free_result();
     delete res;
   }
-  switch (error_num)
+  if (error_num)
   {
-  case ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM:
-    my_printf_error(
-      ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM,
-      ER_SPIDER_REMOTE_TABLE_NOT_FOUND_STR, MYF(0),
-      mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
-      mysql_share->table_names_str[spider->conn_link_idx[link_idx]].ptr());
-    break;
-  case ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM:
-    my_printf_error(
-      ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM,
-      ER_SPIDER_INVALID_REMOTE_TABLE_INFO_STR, MYF(0),
-      mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
-      mysql_share->table_names_str[spider->conn_link_idx[link_idx]].ptr());
-    break;
-  default:
-    break;
+    switch (error_num)
+    {
+    case ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM:
+      my_printf_error(
+        ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM,
+        ER_SPIDER_REMOTE_TABLE_NOT_FOUND_STR, MYF(0),
+        mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
+        mysql_share->table_names_str[spider->conn_link_idx[link_idx]].ptr());
+      break;
+    case ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM:
+      my_printf_error(
+        ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM,
+        ER_SPIDER_INVALID_REMOTE_TABLE_INFO_STR, MYF(0),
+        mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
+        mysql_share->table_names_str[spider->conn_link_idx[link_idx]].ptr());
+      break;
+    default:
+      break;
+    }
+    goto unlock;
   }
   if (!error_num)
     error_num = ((spider_db_mbase *) conn->db_conn)->reset_lock_wait_timeout();
   else
     ((spider_db_mbase *) conn->db_conn)->reset_lock_wait_timeout();
-  DBUG_RETURN(error_num);
+unlock:
+  DBUG_RETURN(spider_unlock_after_query(conn, error_num));
 }
 
 int spider_mbase_handler::simple_action(
@@ -13539,15 +12824,8 @@ int spider_mbase_handler::simple_action(
     default:
       DBUG_ASSERT(0);
       DBUG_RETURN(0);
-  }
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = &spider->need_mons[link_idx];
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
+    }
+  spider_lock_before_query(conn, &spider->need_mons[link_idx]);
   spider_conn_set_timeout_from_share(conn, link_idx,
     spider->wide_handler->trx->thd,
     share);
@@ -13569,27 +12847,9 @@ int spider_mbase_handler::simple_action(
     ) {
       /* retry */
       if ((error_num = spider_db_ping(spider, conn, link_idx)))
-      {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
-        DBUG_PRINT("info", ("spider error_num=%d 1", error_num));
-        DBUG_RETURN(error_num);
-      }
+        goto unlock;
       if ((error_num = spider_db_set_names(spider, conn, link_idx)))
-      {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
-        DBUG_PRINT("info", ("spider error_num=%d 2", error_num));
-        DBUG_RETURN(error_num);
-      }
+        goto unlock;
       spider_conn_set_timeout_from_share(conn, link_idx,
         spider->wide_handler->trx->thd,
         share);
@@ -13600,24 +12860,14 @@ int spider_mbase_handler::simple_action(
         -1,
         &spider->need_mons[link_idx])
       ) {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        DBUG_PRINT("info", ("spider error_num=%d 3", error_num));
-        DBUG_RETURN(spider_db_errorno(conn));
+        error_num= spider_db_errorno(conn);
+        goto unlock;
       }
     } else {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
-      DBUG_PRINT("info", ("spider error_num=%d 4", error_num));
-      DBUG_RETURN(error_num);
+      goto unlock;
     }
   }
+  error_num= 0;
   st_spider_db_request_key request_key;
   request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id;
   request_key.query_id = spider->wide_handler->trx->thd->query_id;
@@ -13626,33 +12876,15 @@ int spider_mbase_handler::simple_action(
   request_key.next = NULL;
   if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
   {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
     if (error_num)
-    {
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
-      DBUG_PRINT("info", ("spider error_num=%d 5", error_num));
-      DBUG_RETURN(error_num);
-    }
+      goto unlock;
     else if ((error_num = spider_db_errorno(conn)))
-    {
-      DBUG_PRINT("info", ("spider error_num=%d 6", error_num));
-      DBUG_RETURN(error_num);
-    } else {
-      DBUG_PRINT("info", ("spider error_num=%d 7",
-        ER_QUERY_ON_FOREIGN_DATA_SOURCE));
-      DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE);
+      goto unlock;
+    else {
+      error_num= ER_QUERY_ON_FOREIGN_DATA_SOURCE;
+      goto unlock;
     }
   }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
   switch (simple_action)
   {
     case SPIDER_SIMPLE_RECORDS:
@@ -13669,12 +12901,8 @@ int spider_mbase_handler::simple_action(
   }
   res->free_result();
   delete res;
-  if (error_num)
-  {
-    DBUG_PRINT("info", ("spider error_num=%d 7", error_num));
-    DBUG_RETURN(error_num);
-  }
-  DBUG_RETURN(0);
+unlock:
+  DBUG_RETURN(spider_unlock_after_query(conn, error_num));
 }
 
 int spider_mbase_handler::show_records(
@@ -13729,14 +12957,7 @@ ha_rows spider_mbase_handler::explain_select(
     DBUG_RETURN(HA_POS_ERROR);
   }
 
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = &spider->need_mons[link_idx];
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
+  spider_lock_before_query(conn, &spider->need_mons[link_idx]);
   spider_conn_set_timeout_from_share(conn, link_idx,
     spider->wide_handler->trx->thd,
     spider->share);
@@ -13761,25 +12982,15 @@ ha_rows spider_mbase_handler::explain_select(
       {
         if (spider->check_error_mode(error_num))
           my_errno = error_num;
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
-        DBUG_RETURN(HA_POS_ERROR);
+        rows= HA_POS_ERROR;
+        goto unlock;
       }
       if ((error_num = spider_db_set_names(spider, conn, link_idx)))
       {
         if (spider->check_error_mode(error_num))
           my_errno = error_num;
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
-        DBUG_RETURN(HA_POS_ERROR);
+        rows= HA_POS_ERROR;
+        goto unlock;
       }
       spider_conn_set_timeout_from_share(conn, link_idx,
         spider->wide_handler->trx->thd,
@@ -13794,24 +13005,14 @@ ha_rows spider_mbase_handler::explain_select(
         error_num = spider_db_errorno(conn);
         if (spider->check_error_mode(error_num))
           my_errno = error_num;
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
-        DBUG_RETURN(HA_POS_ERROR);
+        rows= HA_POS_ERROR;
+        goto unlock;
       }
     } else {
       if (spider->check_error_mode(error_num))
         my_errno = error_num;
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
-      DBUG_RETURN(HA_POS_ERROR);
+      rows= HA_POS_ERROR;
+      goto unlock;
     }
   }
   st_spider_db_request_key request_key;
@@ -13826,30 +13027,13 @@ ha_rows spider_mbase_handler::explain_select(
     {
       if (spider->check_error_mode(error_num))
         my_errno = error_num;
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
-      DBUG_RETURN(HA_POS_ERROR);
+      rows= HA_POS_ERROR;
+      goto unlock;
     } else {
-      my_errno = ER_QUERY_ON_FOREIGN_DATA_SOURCE;
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
-      DBUG_RETURN(HA_POS_ERROR);
+      rows= HA_POS_ERROR;
+      goto unlock;
     }
   }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
   error_num = res->fetch_table_records(
     2,
     rows
@@ -13859,8 +13043,10 @@ ha_rows spider_mbase_handler::explain_select(
   if (error_num)
   {
     my_errno = error_num;
-    DBUG_RETURN(HA_POS_ERROR);
+    rows= HA_POS_ERROR;
   }
+unlock:
+  spider_unlock_after_query(conn, 0);
   DBUG_RETURN(rows);
 }
 
@@ -13878,24 +13064,9 @@ int spider_mbase_handler::lock_tables(
   }
   if (str->length())
   {
-    pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-    pthread_mutex_lock(&conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    conn->need_mon = &spider->need_mons[link_idx];
-    DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = TRUE;
-    conn->mta_conn_mutex_unlock_later = TRUE;
+    spider_lock_before_query(conn, &spider->need_mons[link_idx]);
     if ((error_num = spider_db_set_names(spider, conn, link_idx)))
-    {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
-      DBUG_RETURN(error_num);
-    }
+      DBUG_RETURN(spider_unlock_after_query(conn, error_num));
     spider_conn_set_timeout_from_share(conn, link_idx,
       spider->wide_handler->trx->thd,
       spider->share);
@@ -13905,19 +13076,9 @@ int spider_mbase_handler::lock_tables(
       str->length(),
       -1,
       &spider->need_mons[link_idx])
-    ) {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      DBUG_RETURN(spider_db_errorno(conn));
-    }
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
+    )
+      DBUG_RETURN(spider_unlock_after_query_1(conn));
+    spider_unlock_after_query(conn, 0);
   }
   if (!conn->table_locked)
   {
@@ -13949,33 +13110,9 @@ int spider_mbase_handler::unlock_tables(
       spider_conn_set_timeout_from_share(conn, link_idx,
         spider->wide_handler->trx->thd,
         spider->share);
-      pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-      pthread_mutex_lock(&conn->mta_conn_mutex);
-      SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      conn->need_mon = &spider->need_mons[link_idx];
-      DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = TRUE;
-      conn->mta_conn_mutex_unlock_later = TRUE;
-      if (spider_db_query(
-        conn,
-        str->ptr(),
-        str->length(),
-        -1,
-        &spider->need_mons[link_idx])
-      ) {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        DBUG_RETURN(spider_db_errorno(conn));
-      }
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+      DBUG_RETURN(spider_db_query_with_lock(
+                    conn, str->ptr(), str->length(),
+                    &spider->need_mons[link_idx]));
     }
   }
   DBUG_RETURN(0);
@@ -13995,24 +13132,9 @@ int spider_mbase_handler::disable_keys(
   {
     DBUG_RETURN(error_num);
   }
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = &spider->need_mons[link_idx];
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
+  spider_lock_before_query(conn, &spider->need_mons[link_idx]);
   if ((error_num = spider_db_set_names(spider, conn, link_idx)))
-  {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
-    DBUG_RETURN(error_num);
-  }
+    goto unlock;
   spider_conn_set_timeout_from_share(conn, link_idx,
     spider->wide_handler->trx->thd,
     share);
@@ -14022,21 +13144,10 @@ int spider_mbase_handler::disable_keys(
     str->length(),
     -1,
     &spider->need_mons[link_idx])
-  ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
+  )
     error_num = spider_db_errorno(conn);
-    DBUG_RETURN(error_num);
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+unlock:
+  DBUG_RETURN(spider_unlock_after_query(conn, error_num));
 }
 
 int spider_mbase_handler::enable_keys(
@@ -14053,24 +13164,9 @@ int spider_mbase_handler::enable_keys(
   {
     DBUG_RETURN(error_num);
   }
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = &spider->need_mons[link_idx];
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
+  spider_lock_before_query(conn, &spider->need_mons[link_idx]);
   if ((error_num = spider_db_set_names(spider, conn, link_idx)))
-  {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
-    DBUG_RETURN(error_num);
-  }
+    goto unlock;
   spider_conn_set_timeout_from_share(conn, link_idx,
     spider->wide_handler->trx->thd,
     share);
@@ -14080,21 +13176,10 @@ int spider_mbase_handler::enable_keys(
     str->length(),
     -1,
     &spider->need_mons[link_idx])
-  ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
+  )
     error_num = spider_db_errorno(conn);
-    DBUG_RETURN(error_num);
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+unlock:
+  DBUG_RETURN(spider_unlock_after_query(conn, error_num));
 }
 
 int spider_mbase_handler::check_table(
@@ -14112,24 +13197,9 @@ int spider_mbase_handler::check_table(
   {
     DBUG_RETURN(error_num);
   }
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = &spider->need_mons[link_idx];
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
+  spider_lock_before_query(conn, &spider->need_mons[link_idx]);
   if ((error_num = spider_db_set_names(spider, conn, link_idx)))
-  {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
-    DBUG_RETURN(error_num);
-  }
+    goto unlock;
   spider_conn_set_timeout_from_share(conn, link_idx,
     spider->wide_handler->trx->thd,
     share);
@@ -14140,20 +13210,10 @@ int spider_mbase_handler::check_table(
     -1,
     &spider->need_mons[link_idx])
   ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
     error_num = spider_db_errorno(conn);
-    DBUG_RETURN(error_num);
   }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+unlock:
+  DBUG_RETURN(spider_unlock_after_query(conn, error_num));
 }
 
 int spider_mbase_handler::repair_table(
@@ -14171,24 +13231,9 @@ int spider_mbase_handler::repair_table(
   {
     DBUG_RETURN(error_num);
   }
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = &spider->need_mons[link_idx];
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
+  spider_lock_before_query(conn, &spider->need_mons[link_idx]);
   if ((error_num = spider_db_set_names(spider, conn, link_idx)))
-  {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
-    DBUG_RETURN(error_num);
-  }
+    goto unlock;
   spider_conn_set_timeout_from_share(conn, link_idx,
     spider->wide_handler->trx->thd,
     share);
@@ -14199,20 +13244,10 @@ int spider_mbase_handler::repair_table(
     -1,
     &spider->need_mons[link_idx])
   ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
     error_num = spider_db_errorno(conn);
-    DBUG_RETURN(error_num);
   }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+unlock:
+  DBUG_RETURN(spider_unlock_after_query(conn, error_num));
 }
 
 int spider_mbase_handler::analyze_table(
@@ -14229,48 +13264,18 @@ int spider_mbase_handler::analyze_table(
   {
     DBUG_RETURN(error_num);
   }
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = &spider->need_mons[link_idx];
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
-  if ((error_num = spider_db_set_names(spider, conn, link_idx)))
-  {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
-    DBUG_RETURN(error_num);
-  }
-  spider_conn_set_timeout_from_share(conn, link_idx,
-    spider->wide_handler->trx->thd,
-    share);
-  if (spider_db_query(
-    conn,
-    str->ptr(),
-    str->length(),
-    -1,
-    &spider->need_mons[link_idx])
-  ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    error_num = spider_db_errorno(conn);
-    DBUG_RETURN(error_num);
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+  spider_lock_before_query(conn, &spider->need_mons[link_idx]);
+    error_num = spider_db_set_names(spider, conn, link_idx);
+    if (!error_num)
+    {
+      spider_conn_set_timeout_from_share(conn, link_idx,
+                                         spider->wide_handler->trx->thd,
+                                         share);
+      if (spider_db_query(conn, str->ptr(), str->length(), -1,
+                          &spider->need_mons[link_idx]))
+        error_num = spider_db_errorno(conn);
+    }
+  DBUG_RETURN(spider_unlock_after_query(conn, error_num));
 }
 
 int spider_mbase_handler::optimize_table(
@@ -14287,24 +13292,9 @@ int spider_mbase_handler::optimize_table(
   {
     DBUG_RETURN(error_num);
   }
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = &spider->need_mons[link_idx];
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
+  spider_lock_before_query(conn, &spider->need_mons[link_idx]);
   if ((error_num = spider_db_set_names(spider, conn, link_idx)))
-  {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
-    DBUG_RETURN(error_num);
-  }
+    goto unlock;
   spider_conn_set_timeout_from_share(conn, link_idx,
     spider->wide_handler->trx->thd,
     share);
@@ -14315,20 +13305,10 @@ int spider_mbase_handler::optimize_table(
     -1,
     &spider->need_mons[link_idx])
   ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
     error_num = spider_db_errorno(conn);
-    DBUG_RETURN(error_num);
   }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+unlock:
+  DBUG_RETURN(spider_unlock_after_query(conn, error_num));
 }
 
 int spider_mbase_handler::flush_tables(
@@ -14349,77 +13329,23 @@ int spider_mbase_handler::flush_tables(
   spider_conn_set_timeout_from_share(conn, link_idx,
     spider->wide_handler->trx->thd,
     share);
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = &spider->need_mons[link_idx];
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
-  if (spider_db_query(
-    conn,
-    str->ptr(),
-    str->length(),
-    -1,
-    &spider->need_mons[link_idx])
-  ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    error_num = spider_db_errorno(conn);
-    DBUG_RETURN(error_num);
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+  DBUG_RETURN(spider_db_query_with_lock(
+                conn, str->ptr(), str->length(), &spider->need_mons[link_idx]));
 }
 
 int spider_mbase_handler::flush_logs(
   SPIDER_CONN *conn,
   int link_idx
 ) {
-  int error_num;
   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->wide_handler->trx->thd,
     share);
-  pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-  pthread_mutex_lock(&conn->mta_conn_mutex);
-  SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  conn->need_mon = &spider->need_mons[link_idx];
-  DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = TRUE;
-  conn->mta_conn_mutex_unlock_later = TRUE;
-  if (spider_db_query(
-    conn,
-    SPIDER_SQL_FLUSH_LOGS_STR,
-    SPIDER_SQL_FLUSH_LOGS_LEN,
-    -1,
-    &spider->need_mons[link_idx])
-  ) {
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    error_num = spider_db_errorno(conn);
-    DBUG_RETURN(error_num);
-  }
-  DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-  DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-  conn->mta_conn_mutex_lock_already = FALSE;
-  conn->mta_conn_mutex_unlock_later = FALSE;
-  SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-  pthread_mutex_unlock(&conn->mta_conn_mutex);
-  DBUG_RETURN(0);
+  DBUG_RETURN(spider_db_query_with_lock(
+                conn, SPIDER_SQL_FLUSH_LOGS_STR,
+                SPIDER_SQL_FLUSH_LOGS_LEN, &spider->need_mons[link_idx]));
 }
 
 int spider_mbase_handler::sync_from_clone_source(
diff --git a/storage/spider/spd_direct_sql.cc b/storage/spider/spd_direct_sql.cc
index ba7ef98dc41..352cba6f536 100644
--- a/storage/spider/spd_direct_sql.cc
+++ b/storage/spider/spd_direct_sql.cc
@@ -17,7 +17,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "sql_class.h"
@@ -490,7 +489,6 @@ SPIDER_CONN *spider_udf_direct_sql_create_conn(
   DBUG_RETURN(conn);
 
 error:
-  DBUG_ASSERT(!conn->mta_conn_mutex_file_pos.file_name);
 error_too_many_ipport_count:
   spider_conn_done(conn);
 error_conn_init:
diff --git a/storage/spider/spd_environ.h b/storage/spider/spd_environ.h
deleted file mode 100644
index ccdc7009f9a..00000000000
--- a/storage/spider/spd_environ.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/* Copyright (C) 2008-2020 Kentoku Shiba
-   Copyright (C) 2017-2020 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
-  the Free Software Foundation; version 2 of the License.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */
-
-/*
-  Define functionality offered by MySQL or MariaDB
-*/
-
-#ifndef SPD_ENVIRON_INCLUDED
-
-#define SPIDER_NET_HAS_THD
-#define HANDLER_HAS_TOP_TABLE_FIELDS
-#define PARTITION_HAS_GET_PART_SPEC
-#define HA_EXTRA_HAS_STARTING_ORDERED_INDEX_SCAN
-#define HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT
-#define SPIDER_UPDATE_ROW_HAS_CONST_NEW_DATA
-#endif /* SPD_ENVIRON_INCLUDED */
diff --git a/storage/spider/spd_group_by_handler.cc b/storage/spider/spd_group_by_handler.cc
index 6236a7b974a..2a38c03cca8 100644
--- a/storage/spider/spd_group_by_handler.cc
+++ b/storage/spider/spd_group_by_handler.cc
@@ -17,7 +17,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "sql_class.h"
@@ -1181,27 +1180,15 @@ static int spider_send_query(
       }
     } else
     {
-      pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
       if ((error_num = dbton_hdl->set_sql_for_exec(
              SPIDER_SQL_TYPE_SELECT_SQL, link_idx, link_idx_chain)))
         DBUG_RETURN(error_num);
-      pthread_mutex_lock(&conn->mta_conn_mutex);
-      SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      conn->need_mon = &spider->need_mons[link_idx];
-      DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = TRUE;
-      conn->mta_conn_mutex_unlock_later = TRUE;
+      spider_lock_before_query(conn, &spider->need_mons[link_idx]);
       if ((error_num = spider_db_set_names(spider, conn,
         link_idx)))
       if ((error_num = spider_db_set_names(spider, conn, link_idx)))
       {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
+        spider_unlock_after_query(conn, 0);
         if (spider->need_mons[link_idx])
           error_num = fields->ping_table_mon_from_table(link_idx_chain);
         if ((error_num = spider->check_error_mode_eof(error_num)) ==
@@ -1219,11 +1206,7 @@ static int spider_send_query(
         spider->result_list.quick_mode,
         &spider->need_mons[link_idx]))
       {
-        DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-        DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-        conn->mta_conn_mutex_lock_already = FALSE;
-        conn->mta_conn_mutex_unlock_later = FALSE;
-        error_num = spider_db_errorno(conn);
+        error_num= spider_unlock_after_query_1(conn);
         if (spider->need_mons[link_idx])
           error_num = fields->ping_table_mon_from_table(link_idx_chain);
         if ((error_num = spider->check_error_mode_eof(error_num)) ==
@@ -1235,13 +1218,9 @@ static int spider_send_query(
         DBUG_RETURN(error_num);
       }
       spider->connection_ids[link_idx] = conn->connection_id;
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
       if (fields->is_first_link_ok_chain(link_idx_chain))
       {
-        if ((error_num = spider_db_store_result(spider, link_idx, table)))
+        if ((error_num = spider_unlock_after_query_2(conn, spider, link_idx, table)))
         {
           if (error_num != HA_ERR_END_OF_FILE && spider->need_mons[link_idx])
             error_num = fields->ping_table_mon_from_table(link_idx_chain);
@@ -1258,8 +1237,7 @@ static int spider_send_query(
       } else
       {
         spider_db_discard_result(spider, link_idx, conn);
-        SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-        pthread_mutex_unlock(&conn->mta_conn_mutex);
+        spider_unlock_after_query(conn, 0);
       }
     }
   }
diff --git a/storage/spider/spd_i_s.cc b/storage/spider/spd_i_s.cc
index 8ae88102e81..4aaa017cb02 100644
--- a/storage/spider/spd_i_s.cc
+++ b/storage/spider/spd_i_s.cc
@@ -17,7 +17,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "sql_class.h"
diff --git a/storage/spider/spd_include.h b/storage/spider/spd_include.h
index 3a6a714cca9..c9b00d33da0 100644
--- a/storage/spider/spd_include.h
+++ b/storage/spider/spd_include.h
@@ -87,8 +87,6 @@
 
 #define SPIDER_ENGINE_CONDITION_PUSHDOWN_IS_ALWAYS_ON
 
-#define SPIDER_Item_args_arg_count_IS_PROTECTED
-
 #define SPIDER_Item_func_conv_charset_conv_charset collation.collation
 
 #define SPIDER_WITHOUT_HA_STATISTIC_INCREMENT
@@ -454,11 +452,6 @@ enum spider_malloc_id {
 #define SPIDER_CONN_RESTORE_DASTATUS_AND_RESET_TMP_ERROR_NUM \
   if (thd && conn->error_mode) {SPIDER_RESTORE_DASTATUS; tmp_error_num = 0;}
 
-#define SPIDER_SET_FILE_POS(A) \
-  {(A)->thd = current_thd; (A)->func_name = __func__; (A)->file_name = __FILE__; (A)->line_no = __LINE__;}
-#define SPIDER_CLEAR_FILE_POS(A) \
-  {DBUG_PRINT("info", ("spider thd=%p func_name=%s file_name=%s line_no=%lu", (A)->thd, (A)->func_name ? (A)->func_name : "NULL", (A)->file_name ? (A)->file_name : "NULL", (A)->line_no)); (A)->thd = NULL; (A)->func_name = NULL; (A)->file_name = NULL; (A)->line_no = 0;}
-
 class ha_spider;
 typedef struct st_spider_share SPIDER_SHARE;
 typedef struct st_spider_table_mon_list SPIDER_TABLE_MON_LIST;
@@ -480,14 +473,6 @@ typedef struct st_spider_thread
   volatile SPIDER_SHARE *queue_last;
 } SPIDER_THREAD;
 
-typedef struct st_spider_file_pos
-{
-  THD                *thd;
-  const char         *func_name;
-  const char         *file_name;
-  ulong              line_no;
-} SPIDER_FILE_POS;
-
 typedef struct st_spider_link_for_hash
 {
   ha_spider          *spider;
@@ -616,7 +601,6 @@ typedef struct st_spider_conn
   pthread_mutex_t    mta_conn_mutex;
   volatile bool      mta_conn_mutex_lock_already;
   volatile bool      mta_conn_mutex_unlock_later;
-  SPIDER_FILE_POS    mta_conn_mutex_file_pos;
   uint               join_trx;
   int                trx_isolation;
   bool               semi_trx_isolation_chk;
diff --git a/storage/spider/spd_malloc.cc b/storage/spider/spd_malloc.cc
index 245ecd6c600..0a591bedb4e 100644
--- a/storage/spider/spd_malloc.cc
+++ b/storage/spider/spd_malloc.cc
@@ -17,7 +17,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "sql_class.h"
diff --git a/storage/spider/spd_param.cc b/storage/spider/spd_param.cc
index f05c08de12b..bfe6afc400e 100644
--- a/storage/spider/spd_param.cc
+++ b/storage/spider/spd_param.cc
@@ -37,7 +37,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "sql_class.h"
diff --git a/storage/spider/spd_ping_table.cc b/storage/spider/spd_ping_table.cc
index 2597150d7aa..a2b432a300f 100644
--- a/storage/spider/spd_ping_table.cc
+++ b/storage/spider/spd_ping_table.cc
@@ -17,7 +17,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "sql_class.h"
diff --git a/storage/spider/spd_sys_table.cc b/storage/spider/spd_sys_table.cc
index 5cbae605ca5..df04f40fc80 100644
--- a/storage/spider/spd_sys_table.cc
+++ b/storage/spider/spd_sys_table.cc
@@ -16,7 +16,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "sql_class.h"
diff --git a/storage/spider/spd_table.cc b/storage/spider/spd_table.cc
index 735b4eb44df..8391b5451a5 100644
--- a/storage/spider/spd_table.cc
+++ b/storage/spider/spd_table.cc
@@ -17,7 +17,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "my_getopt.h"
@@ -6006,22 +6005,10 @@ int spider_open_all_tables(
     }
     conn->error_mode &= spider_param_error_read_mode(thd, 0);
     conn->error_mode &= spider_param_error_write_mode(thd, 0);
-    pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
-    pthread_mutex_lock(&conn->mta_conn_mutex);
-    SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    conn->need_mon = &mon_val;
-    DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = TRUE;
-    conn->mta_conn_mutex_unlock_later = TRUE;
+    spider_lock_before_query(conn, &mon_val);
     if ((error_num = spider_db_before_query(conn, &mon_val)))
     {
-      DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-      DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-      conn->mta_conn_mutex_lock_already = FALSE;
-      conn->mta_conn_mutex_unlock_later = FALSE;
-      SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-      pthread_mutex_unlock(&conn->mta_conn_mutex);
+      spider_unlock_after_query(conn, 0);
       spider_sys_index_end(table_tables);
       spider_sys_close_table(thd, &open_tables_backup);
       spider_free_tmp_dbton_share(&tmp_share);
@@ -6029,12 +6016,7 @@ int spider_open_all_tables(
       free_root(&mem_root, MYF(0));
       DBUG_RETURN(error_num);
     }
-    DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
-    DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
-    conn->mta_conn_mutex_lock_already = FALSE;
-    conn->mta_conn_mutex_unlock_later = FALSE;
-    SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
-    pthread_mutex_unlock(&conn->mta_conn_mutex);
+    spider_unlock_after_query(conn, 0);
 
     if (lock && spider_param_use_snapshot_with_flush_tables(thd) == 2)
     {
diff --git a/storage/spider/spd_trx.cc b/storage/spider/spd_trx.cc
index 37d955c71b6..4da38110631 100644
--- a/storage/spider/spd_trx.cc
+++ b/storage/spider/spd_trx.cc
@@ -17,7 +17,6 @@
 #define MYSQL_SERVER 1
 #include <my_global.h>
 #include "mysql_version.h"
-#include "spd_environ.h"
 #include "sql_priv.h"
 #include "probes_mysql.h"
 #include "sql_class.h"
diff --git a/storage/spider/spd_udf.cc b/storage/spider/spd_udf.cc
index 13a9b41f7e2..511f0d0083a 100644
--- a/storage/spider/spd_udf.cc
+++ b/storage/spider/spd_udf.cc
@@ -15,7 +15,6 @@
 
 #define MYSQL_SERVER 1
 #include <my_global.h>
-#include "spd_environ.h"
 #include "mysql.h"
 #include "spd_udf.h"
 
diff --git a/unittest/sql/my_apc-t.cc b/unittest/sql/my_apc-t.cc
index e3f8293ffcb..83f894bedc5 100644
--- a/unittest/sql/my_apc-t.cc
+++ b/unittest/sql/my_apc-t.cc
@@ -190,6 +190,7 @@ int main(int args, char **argv)
   pthread_t request_thr[N_THREADS];
   int i;
 
+  my_mutex_init();
   my_thread_global_init();
 
   mysql_mutex_init(0, &apc_counters_mutex, MY_MUTEX_INIT_FAST);