diff --git a/storage/tianchi/ctc_meta_data.cc b/storage/tianchi/ctc_meta_data.cc
index db39c84ba26c886042c9214959e2633d37d855d9..f93bc15bd3037c7073086963d537ea931a9a90a9 100644
--- a/storage/tianchi/ctc_meta_data.cc
+++ b/storage/tianchi/ctc_meta_data.cc
@@ -55,6 +55,8 @@
 #include "sql/sql_reload.h"
 #include "mysql_com.h"
 
+#include "sql/transaction.h"
+
 using namespace std;
 
 extern uint32_t tse_instance_id;
@@ -70,7 +72,9 @@ class Release_all_ctc_explicit_locks : public MDL_release_locks_visitor {
     const MDL_key *mdl_key = ticket->get_key();
     tse_log_system("[TSE_MDL_THD]: Release ticket info, db_name:%s, name:%s, namespace:%d, ticket_type:%d",
       mdl_key->db_name(), mdl_key->name(), mdl_key->mdl_namespace(), ticket->get_type());
-    return ticket->get_type() == MDL_EXCLUSIVE;
+    return ticket->get_type() == MDL_EXCLUSIVE ||
+           ((ticket->get_type() == MDL_SHARED_READ_ONLY || ticket->get_type() == MDL_SHARED_NO_READ_WRITE) &&
+           mdl_key->mdl_namespace() == MDL_key::TABLE);
   }
 };
  
@@ -497,6 +501,15 @@ static void tse_init_mdl_request(tse_lock_table_info *lock_info, MDL_request *md
   }
   return;
 }
+
+static void tse_init_mdl_request(tse_lock_table_info *lock_info, MDL_request *mdl_request, MDL_key::enum_mdl_namespace tse_mdl_namespace) {
+  MDL_key mdl_key;
+  dd::String_type schema_name = dd::String_type(lock_info->db_name);
+  dd::String_type name = dd::String_type(lock_info->table_name);
+  MDL_REQUEST_INIT(mdl_request, tse_mdl_namespace, lock_info->db_name, lock_info->table_name,
+                   (enum_mdl_type)lock_info->mdl_namespace, MDL_EXPLICIT);
+  return;
+}
  
 int tse_mdl_lock_thd(tianchi_handler_t *tch, tse_lock_table_info *lock_info, int *err_code) {
   bool is_same_node = (tch->inst_id == tse_instance_id);
@@ -568,6 +581,57 @@ void ctc_mdl_unlock_thd_by_ticket(THD* thd, MDL_request *tse_release_request) {
   }
 }
 
+void tse_mdl_unlock_tables_thd(tianchi_handler_t *tch) {
+  bool is_same_node = (tch->inst_id == tse_instance_id);
+  uint64_t mdl_thd_key = tse_get_conn_key(tch->inst_id, tch->thd_id, true);
+
+  if (is_same_node) {
+    return;
+  }
+
+  auto iter = g_tse_mdl_thd_map.find(mdl_thd_key);
+  if (iter == g_tse_mdl_thd_map.end()) {
+    return;
+  }
+  THD* thd = iter->second;
+  assert(thd);
+
+  my_thread_init();
+  thd->store_globals();
+
+  lock_guard<mutex> lock(m_tse_mdl_ticket_mutex);
+  auto ticket_map_iter = g_tse_mdl_ticket_maps.find(thd);
+  if (ticket_map_iter == g_tse_mdl_ticket_maps.end()) {
+    return;
+  }
+
+  map<string, MDL_ticket *> *tse_mdl_ticket_map = ticket_map_iter->second;
+  if (tse_mdl_ticket_map == nullptr) {
+    g_tse_mdl_ticket_maps.erase(thd);
+    return;
+  }
+
+  for (auto iter = tse_mdl_ticket_map->begin(); iter != tse_mdl_ticket_map->end();) {
+    MDL_ticket *ticket = iter->second;
+    if (ticket->get_type() == MDL_SHARED_READ_ONLY || ticket->get_type() == MDL_SHARED_NO_READ_WRITE) {
+      thd->mdl_context.release_lock(ticket);
+      tse_mdl_ticket_map->erase(iter++);
+    } else {
+      iter++;
+    }
+  }
+
+  if (tse_mdl_ticket_map->empty()) {
+    delete tse_mdl_ticket_map;
+    g_tse_mdl_ticket_maps.erase(thd);
+  }
+
+  thd->restore_globals();
+  my_thread_end();
+
+  return;
+}
+
 void tse_mdl_unlock_thd(tianchi_handler_t *tch, tse_lock_table_info *lock_info) {
   bool is_same_node = (tch->inst_id == tse_instance_id);
   uint64_t mdl_thd_key = tse_get_conn_key(tch->inst_id, tch->thd_id, true);
@@ -763,3 +827,44 @@ int ctc_set_sys_var(tse_ddl_broadcast_request *broadcast_req) {
   
   return ret;
 }
+
+int tse_ddl_execute_lock_tables_by_req(tianchi_handler_t *tch, tse_lock_table_info *lock_info, int *err_code) {
+  bool is_same_node = (tch->inst_id == tse_instance_id);
+  uint64_t mdl_thd_key = tse_get_conn_key(tch->inst_id, tch->thd_id, true);
+ 
+  if (is_same_node) {
+    return false;
+  }
+ 
+  THD *thd = nullptr;
+  ctc_init_thd(&thd, mdl_thd_key);
+ 
+  MDL_request tse_mdl_request;
+  tse_init_mdl_request(lock_info, &tse_mdl_request, MDL_key::TABLE);
+ 
+  if (thd->mdl_context.acquire_lock(&tse_mdl_request, 10)) {
+    *err_code = ER_LOCK_WAIT_TIMEOUT;
+    tse_log_error("[TSE_MDL_LOCK]:Get mdl lock fail. namespace:%d, db_name:%s, table_name:%s",
+                  lock_info->mdl_namespace, lock_info->db_name, lock_info->table_name);
+    return true;
+  }
+
+  lock_guard<mutex> lock(m_tse_mdl_ticket_mutex);
+  auto iter = g_tse_mdl_ticket_maps.find(thd);
+  map<string, MDL_ticket *> *tse_mdl_ticket_map = nullptr;
+  if (iter == g_tse_mdl_ticket_maps.end()) {
+    tse_mdl_ticket_map = new map<string, MDL_ticket *>;
+    g_tse_mdl_ticket_maps[thd] = tse_mdl_ticket_map;
+  } else {
+    tse_mdl_ticket_map = g_tse_mdl_ticket_maps[thd];
+  }
+  string mdl_ticket_key;
+  mdl_ticket_key.assign(((const char*)(tse_mdl_request.key.ptr())), tse_mdl_request.key.length());
+  assert(mdl_ticket_key.length() > 0);
+  tse_mdl_ticket_map->insert(map<string, MDL_ticket *>::value_type(mdl_ticket_key, tse_mdl_request.ticket));
+
+  thd->restore_globals();
+  my_thread_end();
+
+  return false;
+}
\ No newline at end of file
diff --git a/storage/tianchi/ctc_meta_data.h b/storage/tianchi/ctc_meta_data.h
index f4c383ec68b03f09ec615ee7346c815098b3ad38..2da8adf4982a4853ca14f14a7e403ada22948abd 100644
--- a/storage/tianchi/ctc_meta_data.h
+++ b/storage/tianchi/ctc_meta_data.h
@@ -29,6 +29,8 @@ int close_tse_mdl_thd(uint32_t thd_id, uint32_t mysql_inst_id);
 int tse_mdl_lock_thd(tianchi_handler_t *tch, tse_lock_table_info *lock_info, int *err_code);
 void tse_mdl_unlock_thd(tianchi_handler_t *tch, tse_lock_table_info *lock_info);
 int ctc_set_sys_var(tse_ddl_broadcast_request *broadcast_req);
+int tse_ddl_execute_lock_tables_by_req(tianchi_handler_t *tch, tse_lock_table_info *lock_info, int *err_code);
+void tse_mdl_unlock_tables_thd(tianchi_handler_t *tch);
 
 #pragma GCC visibility pop
 
diff --git a/storage/tianchi/ha_tse.cc b/storage/tianchi/ha_tse.cc
index 07e70b2ed56883553a5f388a6b4d9a86b790807d..d013587c91bdb0a4f181bdf7385f7881daf2aaf2 100644
--- a/storage/tianchi/ha_tse.cc
+++ b/storage/tianchi/ha_tse.cc
@@ -5225,7 +5225,7 @@ int ha_tse::initialize_cbo_stats()
     tse_log_error("alloc shm mem failed, m_share->cbo_stats size(%lu)", sizeof(tianchi_cbo_stats_t));
     return ERR_ALLOC_MEMORY;
   }
-  *m_share->cbo_stats = {0, 0, 0, 0, 0, 0, 0, nullptr, nullptr, nullptr};
+  *m_share->cbo_stats = {0, 0, 0, 0, 0, nullptr, nullptr, nullptr};
 
   m_share->cbo_stats->tse_cbo_stats_table.columns =
     (tse_cbo_stats_column_t*)my_malloc(PSI_NOT_INSTRUMENTED, table->s->fields * sizeof(tse_cbo_stats_column_t), MYF(MY_WME));
@@ -5260,7 +5260,7 @@ int ha_tse::get_cbo_stats_4share()
       }
     }
     update_member_tch(m_tch, tse_hton, thd);
-    ret = tse_get_cbo_stats(&m_tch, m_share->cbo_stats, 0, 0);
+    ret = tse_get_cbo_stats(&m_tch, m_share->cbo_stats, &m_share->cbo_stats->tse_cbo_stats_table, 0, 0);
     update_sess_ctx_by_tch(m_tch, tse_hton, thd);
     if (ret == CT_SUCCESS && m_share->cbo_stats->is_updated) {
       m_share->need_fetch_cbo = false;
diff --git a/storage/tianchi/ha_tsepart.cc b/storage/tianchi/ha_tsepart.cc
index 0a93cb3c0e13c88d821e7055cfeb3dbcff93d47f..d93889bde7ea28836ddbbae78c6a2be64e32a002 100644
--- a/storage/tianchi/ha_tsepart.cc
+++ b/storage/tianchi/ha_tsepart.cc
@@ -973,7 +973,7 @@ int ha_tsepart::initialize_cbo_stats() {
       tse_log_error("alloc shm mem failed, m_part_share->cbo_stats size(%lu)", sizeof(tianchi_cbo_stats_t));
       return ERR_ALLOC_MEMORY;
     }
-    *m_part_share->cbo_stats = {0, 0, 0, 0, 0, 0, 0, nullptr, nullptr, nullptr};
+    *m_part_share->cbo_stats = {0, 0, 0, 0, 0, nullptr, nullptr, nullptr};
 
     m_part_share->cbo_stats->part_cnt = part_num;
 
@@ -1013,7 +1013,6 @@ int ha_tsepart::get_cbo_stats_4share()
         return ret;
       }
     }
-    update_member_tch(m_tch, get_tse_hton(), thd);
 
     uint32_t data_size = m_part_share->cbo_stats->msg_len;
     uint32_t part_cnt = m_part_share->cbo_stats->part_cnt;
@@ -1021,9 +1020,10 @@ int ha_tsepart::get_cbo_stats_4share()
     uint32_t fetch_times = part_cnt / num_part_fetch;
     uint32_t first_partid = 0;
 
-
     for (uint32_t i = 0; i<fetch_times; i++) {
-      ret = tse_get_cbo_stats(&m_tch, m_part_share->cbo_stats, first_partid, num_part_fetch);
+      update_member_tch(m_tch, get_tse_hton(), thd);
+      ret = tse_get_cbo_stats(&m_tch, m_part_share->cbo_stats, &m_part_share->cbo_stats->tse_cbo_stats_part_table[first_partid], first_partid, num_part_fetch);
+      update_sess_ctx_by_tch(m_tch, get_tse_hton(), thd);
       if (ret != CT_SUCCESS) {
         return ret;
       }
@@ -1031,8 +1031,12 @@ int ha_tsepart::get_cbo_stats_4share()
     }
 
     num_part_fetch = part_cnt - first_partid;
-    ret = tse_get_cbo_stats(&m_tch, m_part_share->cbo_stats, first_partid, num_part_fetch);
-    update_sess_ctx_by_tch(m_tch, get_tse_hton(), thd);
+    if (num_part_fetch > 0) {
+      update_member_tch(m_tch, get_tse_hton(), thd);
+      ret = tse_get_cbo_stats(&m_tch, m_part_share->cbo_stats, &m_part_share->cbo_stats->tse_cbo_stats_part_table[first_partid], first_partid, num_part_fetch);
+      update_sess_ctx_by_tch(m_tch, get_tse_hton(), thd);
+    }
+    
     if (ret == CT_SUCCESS && m_part_share->cbo_stats->is_updated) {
       m_part_share->need_fetch_cbo = false;
       tse_index_stats_update(table, m_part_share->cbo_stats);
diff --git a/storage/tianchi/srv_mq_msg.h b/storage/tianchi/srv_mq_msg.h
index 04fa7880e558bc641fae95ce1619404e39a9ade0..8508c5466989acd7d79516bcf33df5e7595bb829 100644
--- a/storage/tianchi/srv_mq_msg.h
+++ b/storage/tianchi/srv_mq_msg.h
@@ -339,6 +339,9 @@ struct get_cbo_stats_request {
     int result;
     tianchi_handler_t tch;
     tianchi_cbo_stats_t *stats;
+    tse_cbo_stats_table_t *tse_cbo_stats_table;
+    uint16_t first_partid;
+    uint16_t num_part_fetch;
 };
 
 struct get_serial_val_request {
diff --git a/storage/tianchi/tse_ddl_rewriter_plugin.cc b/storage/tianchi/tse_ddl_rewriter_plugin.cc
index 82978d91406978bf0d90b7c062cdd25a71fcfdfc..4aa9269b53a0addef75e0954f9cd729b08724b26 100644
--- a/storage/tianchi/tse_ddl_rewriter_plugin.cc
+++ b/storage/tianchi/tse_ddl_rewriter_plugin.cc
@@ -706,6 +706,89 @@ static int tse_read_only_ddl(string &, MYSQL_THD thd, bool &need_forward) {
   return 0;
 }
 
+int tse_lock_table_pre(THD* thd, vector<MDL_ticket*>& ticket_list);
+void tse_lock_table_post(THD* thd, vector<MDL_ticket*>& ticket_list);
+
+static int tse_lock_tables_ddl(string &, MYSQL_THD thd, bool &) {
+  TABLE_LIST *tables = thd->lex->query_tables;
+  int ret = 0;
+
+  vector<MDL_ticket*> ticket_list;
+  int pre_lock_ret = tse_lock_table_pre(thd, ticket_list);
+  if (pre_lock_ret != 0) {
+    tse_lock_table_post(thd, ticket_list);
+    my_printf_error(ER_LOCK_WAIT_TIMEOUT, "[TSE_DDL_REWRITE]: LOCK TABLE FAILED", MYF(0));
+    return ER_LOCK_WAIT_TIMEOUT;
+  }
+
+  for (TABLE_LIST *table = tables; table != NULL; table = table->next_global) {
+    tianchi_handler_t tch;
+    tch.inst_id = tse_instance_id;
+    handlerton* hton = get_tse_hton();
+
+    TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch));
+    int32_t mdl_type = 0;
+    auto desc_type = table->lock_descriptor().type;
+    if (desc_type >= TL_READ_DEFAULT && desc_type <= TL_READ_NO_INSERT) {
+      mdl_type = (int32_t)MDL_SHARED_READ_ONLY;
+    } else if (desc_type >= TL_WRITE_ALLOW_WRITE && desc_type <= TL_WRITE_ONLY) {
+      mdl_type = (int32_t)MDL_SHARED_NO_READ_WRITE;
+    } else {
+      continue;
+    }
+    tse_lock_table_info lock_info = {{0}, {0}, {0}, {0}, SQLCOM_LOCK_TABLES,
+                                     mdl_type};
+    FILL_USER_INFO_WITH_THD(lock_info, thd);
+    strncpy(lock_info.db_name, table->db, SMALL_RECORD_SIZE);
+    strncpy(lock_info.table_name, table->table_name, SMALL_RECORD_SIZE);
+    int err_code = 0;
+    ret = tse_lock_table(&tch, lock_info.db_name, &lock_info, &err_code);
+    if (ret != 0) {
+      break;
+    }
+  }
+
+  tse_lock_table_post(thd, ticket_list);
+
+  if (ret != 0) {
+    for (TABLE_LIST *table = tables; table != NULL; table = table->next_global) {
+      tianchi_handler_t tch;
+      tch.inst_id = tse_instance_id;
+      handlerton* hton = get_tse_hton();
+
+      TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch));
+      tse_lock_table_info lock_info = {{0}, {0}, {0}, {0}, SQLCOM_LOCK_TABLES,
+                                      (int32_t)TL_UNLOCK};
+      FILL_USER_INFO_WITH_THD(lock_info, thd);
+      strncpy(lock_info.db_name, table->db, SMALL_RECORD_SIZE);
+      strncpy(lock_info.table_name, table->table_name, SMALL_RECORD_SIZE);
+      ret = tse_unlock_table(&tch, tse_instance_id, &lock_info);
+      if (ret != 0) {
+        tse_log_error("[TSE_DDL_REWRITE]:unlock table failed, table:%s.%s", lock_info.db_name, lock_info.table_name);
+      }
+    }
+  }
+  return ret;
+}
+
+static int tse_unlock_tables_ddl(string &, MYSQL_THD thd, bool &) {
+  int ret = 0;
+
+  tianchi_handler_t tch;
+  tch.inst_id = tse_instance_id;
+  handlerton* hton = get_tse_hton();
+
+  TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch));
+
+  tse_lock_table_info lock_info = {{0}, {0}, {0}, {0}, SQLCOM_UNLOCK_TABLES, 0};
+
+  FILL_USER_INFO_WITH_THD(lock_info, thd);
+
+  ret = tse_unlock_table(&tch, tse_instance_id, &lock_info);
+
+  return ret;
+}
+
 typedef struct ddl_broadcast_cmd_s
 {
   bool need_select_db;  // 需要指定数据库
@@ -753,8 +836,8 @@ static unordered_map<enum enum_sql_command, ddl_broadcast_cmd>
     {SQLCOM_SET_OPTION, {true, tse_check_set_opt}},
 
     // Locking, broadcast
-    {SQLCOM_LOCK_TABLES, {true, NULL}},
-    {SQLCOM_UNLOCK_TABLES, {true, NULL}},
+    {SQLCOM_LOCK_TABLES, {true, tse_lock_tables_ddl}},
+    {SQLCOM_UNLOCK_TABLES, {true, tse_unlock_tables_ddl}},
     {SQLCOM_LOCK_INSTANCE, {false, NULL}},
     {SQLCOM_UNLOCK_INSTANCE, {false, NULL}},
 
diff --git a/storage/tianchi/tse_mysql_proxy.cc b/storage/tianchi/tse_mysql_proxy.cc
index 178f6743089f42c0aa55821612b88aa35b839549..5ff835a545a7f12285b101d6268dc39032d07684 100644
--- a/storage/tianchi/tse_mysql_proxy.cc
+++ b/storage/tianchi/tse_mysql_proxy.cc
@@ -508,7 +508,11 @@ int32_t tse_check_table_exist(MYSQL *curr_conn_proxy, const char *db_name, const
 __attribute__((visibility("default"))) int tse_ddl_execute_lock_tables(tianchi_handler_t *tch, char *db_name, tse_lock_table_info *lock_info, int *err_code) {
 
   if (IS_METADATA_NORMALIZATION()) {
-    if (tse_mdl_lock_thd(tch, lock_info, err_code)) {
+    if (lock_info->sql_type == SQLCOM_LOCK_TABLES) {
+      if (tse_ddl_execute_lock_tables_by_req(tch, lock_info, err_code)) {
+        return *err_code;
+      }
+    } else if (tse_mdl_lock_thd(tch, lock_info, err_code)) {
       return *err_code;
     }
     return 0;
@@ -599,6 +603,9 @@ __attribute__((visibility("default"))) int tse_ddl_execute_unlock_tables(tianchi
  {
   if (IS_METADATA_NORMALIZATION()) {
     UNUSED_PARAM(mysql_inst_id);
+    if (lock_info->sql_type == SQLCOM_UNLOCK_TABLES) {
+      tse_mdl_unlock_tables_thd(tch);
+    }
     tse_mdl_unlock_thd(tch, lock_info);
     return 0;
   }
diff --git a/storage/tianchi/tse_srv.h b/storage/tianchi/tse_srv.h
index 1922adb1f909fc6056e8dfde6476a260a84ab026..e50340643954dd2d614557494dd7450f2b1d8006 100644
--- a/storage/tianchi/tse_srv.h
+++ b/storage/tianchi/tse_srv.h
@@ -152,8 +152,6 @@ typedef struct {
  * expand this struct if need more cbo stats
  */
 typedef struct {
-    uint16_t first_partid;
-    uint16_t num_part_fetch;
     uint32_t part_cnt;
     uint32_t msg_len;
     uint32_t key_len;
@@ -554,7 +552,7 @@ int tse_srv_release_savepoint(tianchi_handler_t *tch, const char *name);
 
 /* Optimizer Related Interface */
 int tse_analyze_table(tianchi_handler_t *tch, const char *db_name, const char *table_name, double sampling_ratio);
-int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, uint32_t first_partid, uint32_t num_part_fetch);
+int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cbo_stats_table_t *tse_cbo_stats_table, uint32_t first_partid, uint32_t num_part_fetch);
 int tse_get_index_name(tianchi_handler_t *tch, char *index_name);
 
 /* Datatype Related Interface */
diff --git a/storage/tianchi/tse_srv_mq_stub.cc b/storage/tianchi/tse_srv_mq_stub.cc
index 4d2d98d874bd8027d84d4905fee0cafaf661c1cf..834b3e4db01f7e915285dfbfad3e2a862e0c9006 100644
--- a/storage/tianchi/tse_srv_mq_stub.cc
+++ b/storage/tianchi/tse_srv_mq_stub.cc
@@ -740,7 +740,7 @@ int tse_analyze_table(tianchi_handler_t *tch, const char *db_name, const char *t
   return result;
 }
 
-int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, uint32_t first_partid, uint32_t num_part_fetch) {
+int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cbo_stats_table_t *tse_cbo_stats_table, uint32_t first_partid, uint32_t num_part_fetch) {
   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));
 
@@ -759,34 +759,36 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, uint32
   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;
+  req->first_partid = first_partid;
+  req->num_part_fetch = num_part_fetch;
   void *shm_inst_4_columns = get_one_shm_inst(tch);
   void *shm_inst_4_keys = get_one_shm_inst(tch);
-  void *shm_inst_4_part_table = get_one_shm_inst(tch);
+  void *shm_inst_4_table = get_one_shm_inst(tch);
   tse_cbo_stats_column_t* part_columns;
   uint32_t *part_ndv_keys;
   if (!is_part_table) {
-    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) {
+    req->tse_cbo_stats_table = 
+        (tse_cbo_stats_table_t*)alloc_share_mem(shm_inst_4_table, sizeof(tse_cbo_stats_table_t));
+    req->tse_cbo_stats_table->columns = (tse_cbo_stats_column_t*)alloc_share_mem(shm_inst_4_columns, req->stats->msg_len);
+    if (req->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;
     }
-    req->stats->tse_cbo_stats_table.ndv_keys = (uint32_t*)alloc_share_mem(shm_inst_4_keys, stats->key_len);
-    if (req->stats->tse_cbo_stats_table.ndv_keys == NULL) {
+    req->tse_cbo_stats_table->ndv_keys = (uint32_t*)alloc_share_mem(shm_inst_4_keys, stats->key_len);
+    if (req->tse_cbo_stats_table->ndv_keys == NULL) {
       tse_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_keys, stats->key_len);
-      free_share_mem(shm_inst_4_columns, req->stats->tse_cbo_stats_table.columns);
+      free_share_mem(shm_inst_4_columns, req->tse_cbo_stats_table->columns);
       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 = first_partid;
-    req->stats->num_part_fetch = num_part_fetch;
-    req->stats->tse_cbo_stats_part_table = 
-        (tse_cbo_stats_table_t*)alloc_share_mem(shm_inst_4_part_table, 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, num_part_fetch * sizeof(tse_cbo_stats_table_t));
+    req->tse_cbo_stats_table = 
+        (tse_cbo_stats_table_t*)alloc_share_mem(shm_inst_4_table, num_part_fetch * sizeof(tse_cbo_stats_table_t));
+    if (req->tse_cbo_stats_table == NULL) {
+      tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst_4_table, 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;
@@ -794,7 +796,7 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, uint32
     part_columns = (tse_cbo_stats_column_t*)alloc_share_mem(shm_inst_4_columns, stats->msg_len * 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 * num_part_fetch);
-      free_share_mem(shm_inst_4_part_table, req->stats->tse_cbo_stats_part_table);
+      free_share_mem(shm_inst_4_table, req->tse_cbo_stats_table);
       free_share_mem(shm_inst_4_stats, req->stats);
       free_share_mem(shm_inst_4_req, req);
       return ERR_ALLOC_MEMORY;
@@ -803,14 +805,14 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, uint32
     if (part_ndv_keys == NULL) {
       tse_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_keys, stats->key_len * num_part_fetch);
       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_4_table, req->tse_cbo_stats_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 < num_part_fetch; i++) {
-      req->stats->tse_cbo_stats_part_table[i].columns = part_columns + i * (stats->msg_len / sizeof(tse_cbo_stats_column_t));
-      req->stats->tse_cbo_stats_part_table[i].ndv_keys = part_ndv_keys + i * (stats->key_len / sizeof(uint32_t));
+      req->tse_cbo_stats_table[i].columns = part_columns + i * (stats->msg_len / sizeof(tse_cbo_stats_column_t));
+      req->tse_cbo_stats_table[i].ndv_keys = part_ndv_keys + i * (stats->key_len / sizeof(uint32_t));
     }
   }
 
@@ -819,31 +821,31 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, uint32
   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) {
+      stats->is_updated = req->stats->is_updated;
         if (!is_part_table) {
             *tch = req->tch;
-            memcpy(stats->tse_cbo_stats_table.columns, req->stats->tse_cbo_stats_table.columns, stats->msg_len);
-            memcpy(stats->tse_cbo_stats_table.ndv_keys, req->stats->tse_cbo_stats_table.ndv_keys, stats->key_len);
-            stats->is_updated = req->stats->is_updated;
-            stats->tse_cbo_stats_table.estimate_rows = req->stats->tse_cbo_stats_table.estimate_rows;
+            memcpy(tse_cbo_stats_table->columns, req->tse_cbo_stats_table->columns, stats->msg_len);
+            memcpy(tse_cbo_stats_table->ndv_keys, req->tse_cbo_stats_table->ndv_keys, stats->key_len);
+            
+            tse_cbo_stats_table->estimate_rows = req->tse_cbo_stats_table->estimate_rows;
         } else {
-          stats->is_updated = req->stats->is_updated;
           for (uint i = 0; i < num_part_fetch; i++) {
-            stats->tse_cbo_stats_part_table[i+first_partid].estimate_rows = req->stats->tse_cbo_stats_part_table[i].estimate_rows;
-            memcpy(stats->tse_cbo_stats_part_table[i+first_partid].columns, req->stats->tse_cbo_stats_part_table[i].columns, stats->msg_len);
-            memcpy(stats->tse_cbo_stats_part_table[i+first_partid].ndv_keys, req->stats->tse_cbo_stats_part_table[i].ndv_keys, stats->key_len);
+            tse_cbo_stats_table[i].estimate_rows = req->tse_cbo_stats_table[i].estimate_rows;
+            memcpy(tse_cbo_stats_table[i].columns, req->tse_cbo_stats_table[i].columns, stats->msg_len);
+            memcpy(tse_cbo_stats_table[i].ndv_keys, req->tse_cbo_stats_table[i].ndv_keys, stats->key_len);
           }
         }
     }
     result = req->result;
   }
   if (!is_part_table) {
-    free_share_mem(shm_inst_4_columns, req->stats->tse_cbo_stats_table.columns);
-    free_share_mem(shm_inst_4_keys, req->stats->tse_cbo_stats_table.ndv_keys);
+    free_share_mem(shm_inst_4_columns, req->tse_cbo_stats_table->columns);
+    free_share_mem(shm_inst_4_keys, req->tse_cbo_stats_table->ndv_keys);
   } else {
     free_share_mem(shm_inst_4_columns, part_columns);
     free_share_mem(shm_inst_4_keys, part_ndv_keys);
-    free_share_mem(shm_inst_4_part_table, req->stats->tse_cbo_stats_part_table);
   }
+  free_share_mem(shm_inst_4_table, req->tse_cbo_stats_table);
   free_share_mem(shm_inst_4_stats, req->stats);
   free_share_mem(shm_inst_4_req, req);
   return result;