diff --git a/storage/tianchi/ha_tse.cc b/storage/tianchi/ha_tse.cc
index d5b4c00c83ee7b1f1f9200483dbe8b3e55d42b1f..d77befe0fb2698f55e45dd6768cdc90d6676c0c1 100644
--- a/storage/tianchi/ha_tse.cc
+++ b/storage/tianchi/ha_tse.cc
@@ -1621,7 +1621,7 @@ static int tse_commit(handlerton *hton, THD *thd, bool commit_trx) {
   thd_sess_ctx_s *sess_ctx = (thd_sess_ctx_s *)thd_get_ha_data(thd, hton);
   assert(sess_ctx != nullptr);
 
-  if (will_commit && (sess_ctx->is_tse_trx_begin || is_ddl_sql_cmd(thd->lex->sql_command))) {
+  if (will_commit) {
     commit_preprocess(thd, &tch);
     attachable_trx_update_pre_addr(tse_hton, thd, &tch, true);
 
@@ -1691,7 +1691,7 @@ static int tse_rollback(handlerton *hton, THD *thd, bool rollback_trx) {
   thd_sess_ctx_s *sess_ctx = (thd_sess_ctx_s *)thd_get_ha_data(thd, hton);
   assert(sess_ctx != nullptr);
 
-  if (will_rollback && (sess_ctx->is_tse_trx_begin || is_ddl_sql_cmd(thd->lex->sql_command))) {
+  if (will_rollback) {
     int32_t total_csize = sess_ctx->cursors_map->size();
     if (sess_ctx->invalid_cursors != nullptr) {
       total_csize += sess_ctx->invalid_cursors->size();
@@ -1748,16 +1748,7 @@ static int tse_close_connect(handlerton *hton, THD *thd) {
   local_tch.thd_id = tch.thd_id;
   local_tch.is_broadcast = tch.is_broadcast;
 
-  assert(sess_ctx != nullptr);
-  int32 total_csize = sess_ctx->cursors_map->size();
-  if (sess_ctx->invalid_cursors != nullptr) {
-    total_csize += sess_ctx->invalid_cursors->size();
-  }
-  uint64_t *cursors = (uint64_t *)tse_alloc_buf(&tch, sizeof(uint64_t) * total_csize);
-  assert((total_csize == 0) ^ (cursors != nullptr));
-  ctc_copy_cursors_to_free(sess_ctx, cursors, 0);
-  int ret = tse_close_session(&local_tch, cursors, total_csize);
-  tse_free_buf(&tch, (uint8_t *)cursors);
+  int ret = tse_close_session(&local_tch);
   release_sess_ctx(sess_ctx, hton, thd);
   return convert_tse_error_code_to_mysql((ct_errno_t)ret);
 }
@@ -4125,21 +4116,25 @@ int ha_tse::start_stmt(THD *thd, thr_lock_type) {
     return 0;
   }
 
+  uint32_t lock_wait_timeout = THDVAR(thd, lock_wait_timeout);
   uint32_t autocommit = !thd->in_multi_stmt_transaction_mode();
-  if (!(m_select_lock != lock_mode::EXCLUSIVE_LOCK && tse_command_type_read(thd->query_plan.get_command()))) {
-    uint32_t lock_wait_timeout = THDVAR(thd, lock_wait_timeout);
-    int isolation_level = isolation_level_to_cantian(thd_get_trx_isolation(thd));
-    tianchi_trx_context_t trx_context = {isolation_level, autocommit, lock_wait_timeout, m_select_lock == lock_mode::EXCLUSIVE_LOCK};
-    bool is_mysql_local = user_var_set(thd, "ctc_ddl_local_enabled");
-    ct_errno_t ret = (ct_errno_t)tse_trx_begin(&m_tch, trx_context, is_mysql_local);
-    check_error_code_to_mysql(ha_thd(), &ret);
-    update_sess_ctx_by_tch(m_tch, tse_hton, thd);
-    if (ret != CT_SUCCESS) {
-      tse_log_error("start trx failed with error code: %d", ret);
-      return convert_tse_error_code_to_mysql(ret);
-    }
-    sess_ctx->is_tse_trx_begin = 1;
+  int isolation_level = isolation_level_to_cantian(thd_get_trx_isolation(thd));
+  
+  tianchi_trx_context_t trx_context = {isolation_level, autocommit, lock_wait_timeout, m_select_lock == lock_mode::EXCLUSIVE_LOCK};
+  
+  bool is_mysql_local = user_var_set(thd, "ctc_ddl_local_enabled");
+  ct_errno_t ret = (ct_errno_t)tse_trx_begin(&m_tch, trx_context, is_mysql_local);
+  
+  check_error_code_to_mysql(ha_thd(), &ret);
+
+  update_sess_ctx_by_tch(m_tch, tse_hton, thd);
+  
+  if (ret != CT_SUCCESS) {
+    tse_log_error("start trx failed with error code: %d", ret);
+    return convert_tse_error_code_to_mysql(ret);
   }
+  
+  sess_ctx->is_tse_trx_begin = 1;
   if (!autocommit) {
     trans_register_ha(thd, true, ht, nullptr);
   }
diff --git a/storage/tianchi/ha_tsepart.cc b/storage/tianchi/ha_tsepart.cc
index f687505fb62867a326b3c52bd25f640d86631cb7..e1049fd1d5eb32c336054172fea4e4bcbd9e1440 100644
--- a/storage/tianchi/ha_tsepart.cc
+++ b/storage/tianchi/ha_tsepart.cc
@@ -1031,12 +1031,8 @@ void ha_tsepart::free_cbo_stats() {
       return;
   }
 
-  uint32_t part_num = m_is_sub_partitioned ? table->part_info->num_parts * table->part_info->num_subparts : 
-                      table->part_info->num_parts;
-    for (uint i = 0; i < part_num; i++) {
-    my_free(m_part_share->cbo_stats->tse_cbo_stats_part_table[i].columns);
-    m_part_share->cbo_stats->tse_cbo_stats_part_table[i].columns = nullptr;
-  }
+  my_free(m_part_share->cbo_stats->tse_cbo_stats_part_table[0].columns);
+  m_part_share->cbo_stats->tse_cbo_stats_part_table[0].columns = nullptr;
   my_free(m_part_share->cbo_stats->tse_cbo_stats_part_table);
   m_part_share->cbo_stats->tse_cbo_stats_part_table = nullptr;
   my_free(m_part_share->cbo_stats);
diff --git a/storage/tianchi/srv_mq_msg.h b/storage/tianchi/srv_mq_msg.h
index 6a3c82049265a47801189d18ca92484360d4a92c..d160605b4753f125eef4cae88e53dfee16bc3b11 100644
--- a/storage/tianchi/srv_mq_msg.h
+++ b/storage/tianchi/srv_mq_msg.h
@@ -46,8 +46,6 @@ struct register_instance_request {
 struct close_session_request {
     tianchi_handler_t tch;
     int result;
-    int32_t csize;
-    uint64_t *cursors;
 };
 
 struct open_table_request {
diff --git a/storage/tianchi/tse_srv.h b/storage/tianchi/tse_srv.h
index 271481f3dadbfa11960140fbcc47752335d5012b..5d1009de6b86cbba9c7d5b9e28176710b3504da8 100644
--- a/storage/tianchi/tse_srv.h
+++ b/storage/tianchi/tse_srv.h
@@ -515,7 +515,7 @@ int tse_release_inst_id(uint32_t inst_id);
 int tse_open_table(tianchi_handler_t *tch, const char *table_name, const char *user_name);
 int tse_close_table(tianchi_handler_t *tch);
 
-int tse_close_session(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize);
+int tse_close_session(tianchi_handler_t *tch);
 void tse_kill_session(tianchi_handler_t *tch);
 
 uint8_t *tse_alloc_buf(tianchi_handler_t *tch, uint32_t buf_size);
diff --git a/storage/tianchi/tse_srv_mq_stub.cc b/storage/tianchi/tse_srv_mq_stub.cc
index 7f93844f0f493bd4cab1159b6314a09a9da3967e..38dd226a1a1659fc7a64a3d8885c2d17238b5a65 100644
--- a/storage/tianchi/tse_srv_mq_stub.cc
+++ b/storage/tianchi/tse_srv_mq_stub.cc
@@ -70,7 +70,7 @@ int tse_open_table(tianchi_handler_t *tch, const char *table_name, const char *u
   return result;
 }
 
-int tse_close_session(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize) {
+int tse_close_session(tianchi_handler_t *tch) {
   tse_log_note("close session");
   void *shm_inst = get_one_shm_inst(tch);
   close_session_request *req = (close_session_request*)alloc_share_mem(shm_inst, sizeof(close_session_request));
@@ -79,8 +79,7 @@ int tse_close_session(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize)
     return ERR_ALLOC_MEMORY;
   }
   req->tch = *tch;
-  req->csize = csize;
-  req->cursors = cursors;
+
   int result = ERR_CONNECTION_FAILED;
   int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_CLOSE_SESSION, req, tch->msg_buf);
   *tch = req->tch;
@@ -741,38 +740,62 @@ int tse_analyze_table(tianchi_handler_t *tch, const char *db_name, const char *t
 }
 
 int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats) {
-  void *shm_inst = get_one_shm_inst(tch);
-  get_cbo_stats_request *req = (get_cbo_stats_request*)alloc_share_mem(shm_inst, sizeof(get_cbo_stats_request));
+  void *shm_inst_4_req = get_one_shm_inst(tch);
+  get_cbo_stats_request *req = (get_cbo_stats_request*)alloc_share_mem(shm_inst_4_req, sizeof(get_cbo_stats_request));
 
   if (req == NULL) {
-    tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(get_cbo_stats_request));
+    tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst_4_req, sizeof(get_cbo_stats_request));
     return ERR_ALLOC_MEMORY;
   }
-
-  req->stats = (tianchi_cbo_stats_t *)alloc_share_mem(shm_inst, sizeof(tianchi_cbo_stats_t));
+  void *shm_inst_4_stats = get_one_shm_inst(tch);
+  req->stats = (tianchi_cbo_stats_t *)alloc_share_mem(shm_inst_4_stats, sizeof(tianchi_cbo_stats_t));
   if (req->stats == NULL) {
-    tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(get_cbo_stats_request));
+    tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst_4_stats, sizeof(tianchi_cbo_stats_t));
+    free_share_mem(shm_inst_4_req, req);
     return ERR_ALLOC_MEMORY;
   }
 
   bool is_part_table = stats->tse_cbo_stats_part_table != nullptr ? true : false;
   req->stats->msg_len = stats->msg_len;
+  req->stats->part_cnt = stats->part_cnt;
+  void *shm_inst_4_columns = get_one_shm_inst(tch);
+  void *shm_inst_4_part_table = get_one_shm_inst(tch);
+  tse_cbo_stats_column_t* part_columns;
   if (!is_part_table) {
-    req->stats->tse_cbo_stats_table.columns = (tse_cbo_stats_column_t*)alloc_share_mem(shm_inst, req->stats->msg_len);
+    req->stats->tse_cbo_stats_table.columns = (tse_cbo_stats_column_t*)alloc_share_mem(shm_inst_4_columns, req->stats->msg_len);
+    if (req->stats->tse_cbo_stats_table.columns == NULL) {
+      tse_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_columns, req->stats->msg_len);
+      free_share_mem(shm_inst_4_stats, req->stats);
+      free_share_mem(shm_inst_4_req, req);
+      return ERR_ALLOC_MEMORY;
+    }
   } else {
     req->stats->first_partid = stats->first_partid;
     req->stats->num_part_fetch = stats->num_part_fetch;
     req->stats->tse_cbo_stats_part_table = 
-        (tse_cbo_stats_table_t*)alloc_share_mem(shm_inst, stats->num_part_fetch * sizeof(tse_cbo_stats_table_t));  
+        (tse_cbo_stats_table_t*)alloc_share_mem(shm_inst_4_part_table, stats->num_part_fetch * sizeof(tse_cbo_stats_table_t));
+    if (req->stats->tse_cbo_stats_part_table == NULL) {
+      tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst_4_part_table, stats->num_part_fetch * sizeof(tse_cbo_stats_table_t));
+      free_share_mem(shm_inst_4_stats, req->stats);
+      free_share_mem(shm_inst_4_req, req);
+      return ERR_ALLOC_MEMORY;
+    }
+    part_columns = (tse_cbo_stats_column_t*)alloc_share_mem(shm_inst_4_columns, stats->msg_len * stats->num_part_fetch);
+    if (part_columns == NULL) {
+      tse_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_columns, stats->msg_len * stats->num_part_fetch);
+      free_share_mem(shm_inst_4_part_table, req->stats->tse_cbo_stats_part_table);
+      free_share_mem(shm_inst_4_stats, req->stats);
+      free_share_mem(shm_inst_4_req, req);
+      return ERR_ALLOC_MEMORY;
+    }
     for (uint i = 0; i < stats->num_part_fetch; i++) {
-        req->stats->tse_cbo_stats_part_table[i].columns =
-            (tse_cbo_stats_column_t*)alloc_share_mem(shm_inst, stats->msg_len);
+      req->stats->tse_cbo_stats_part_table[i].columns = part_columns + i;
     }
   }
 
   req->tch = *tch;
   int result = ERR_CONNECTION_FAILED;
-  int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_GET_CBO_STATS, req, tch->msg_buf);
+  int ret = tse_mq_deal_func(shm_inst_4_req, TSE_FUNC_TYPE_GET_CBO_STATS, req, tch->msg_buf);
   if (ret == CT_SUCCESS) {
     if (req->result == CT_SUCCESS) {
         if (!is_part_table) {
@@ -791,15 +814,13 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats) {
     result = req->result;
   }
   if (!is_part_table) {
-    free_share_mem(shm_inst, req->stats->tse_cbo_stats_table.columns);
+    free_share_mem(shm_inst_4_columns, req->stats->tse_cbo_stats_table.columns);
   } else {
-    for (uint i = 0; i < stats->num_part_fetch; i++) {
-      free_share_mem(shm_inst, req->stats->tse_cbo_stats_part_table[i].columns);
-    }
-    free_share_mem(shm_inst, req->stats->tse_cbo_stats_part_table);
+    free_share_mem(shm_inst_4_columns, part_columns);
+    free_share_mem(shm_inst_4_part_table, req->stats->tse_cbo_stats_part_table);
   }
-  free_share_mem(shm_inst, req->stats);
-  free_share_mem(shm_inst, req);
+  free_share_mem(shm_inst_4_stats, req->stats);
+  free_share_mem(shm_inst_4_req, req);
   return result;
 }
 
diff --git a/storage/tianchi/tse_util.cc b/storage/tianchi/tse_util.cc
index 6733a03d266ecc62165ee07e2eb8b1982a0df6a8..2c1eb38e1433b0b83cc91150038aa65e3e0d6980 100644
--- a/storage/tianchi/tse_util.cc
+++ b/storage/tianchi/tse_util.cc
@@ -707,34 +707,4 @@ int tse_check_unlock_instance(MYSQL_THD thd) {
   tse_unlock_instance(&is_mysqld_starting, &tch);
   tse_log_system("[TSE_UNLOCK_INSTANCE]: SUCCESS. tse_inst:%u, conn_id:%u", tch.inst_id, tch.thd_id);
   return 0;
-}
-
-bool tse_command_type_read(enum_sql_command cmd) {
-  switch (cmd) {
-    case SQLCOM_SELECT:
-    case SQLCOM_CHECK:
-    case SQLCOM_SHOW_DATABASES:
-    case SQLCOM_SHOW_TABLES:
-    case SQLCOM_SHOW_FIELDS:
-    case SQLCOM_SHOW_KEYS:
-    case SQLCOM_SHOW_VARIABLES:
-    case SQLCOM_SHOW_STATUS:
-    case SQLCOM_SHOW_CREATE:
-    case SQLCOM_SHOW_CHARSETS:
-    case SQLCOM_SHOW_COLLATIONS:
-    case SQLCOM_SHOW_CREATE_DB:
-    case SQLCOM_SHOW_TABLE_STATUS:
-    case SQLCOM_SHOW_TRIGGERS:
-    case SQLCOM_SHOW_CREATE_PROC:
-    case SQLCOM_SHOW_CREATE_FUNC:
-    case SQLCOM_SHOW_STATUS_PROC:
-    case SQLCOM_SHOW_STATUS_FUNC:
-    case SQLCOM_SHOW_CREATE_EVENT:
-    case SQLCOM_SHOW_EVENTS:
-    case SQLCOM_SHOW_CREATE_TRIGGER:
-    case SQLCOM_SHOW_CREATE_USER:
-      return CT_TRUE;
-    default:
-      return CT_FALSE;
-  }
 }
\ No newline at end of file
diff --git a/storage/tianchi/tse_util.h b/storage/tianchi/tse_util.h
index e3e1d00859d84fe486ab95def9b85b9b52b1b2a9..3cad7f24e1ba35b9b7e59abdc7b58c0dfde72745 100644
--- a/storage/tianchi/tse_util.h
+++ b/storage/tianchi/tse_util.h
@@ -36,7 +36,6 @@ static unordered_set<string> mysql_system_db{"information_schema", "mysql", "per
 
 #define TSE_GET_THD_DB_NAME(thd) (thd->db().str == NULL) ? nullptr : const_cast<char *>(thd->db().str)
 
-bool tse_command_type_read(enum_sql_command cmd);
 void tse_split_normalized_name(const char *file_name, char db[], size_t db_buf_len,
                                char name[], size_t name_buf_len, bool *is_tmp_table);
 void tse_copy_name(char to_name[], const char from_name[], size_t to_buf_len);