Add virtual table Query_Response_Time

src/observer/CMakeLists.txt

@@ -6,6 +6,7 @@ ob_set_subtarget(ob_server mysql
   mysql/ob_mysql_request_manager.cpp
   mysql/ob_mysql_result_set.cpp
   mysql/ob_query_driver.cpp
+  mysql/ob_query_response_time.cpp
   mysql/ob_query_retry_ctrl.cpp
   mysql/ob_sync_cmd_driver.cpp
   mysql/ob_sync_plan_driver.cpp
@@ -187,6 +188,7 @@ ob_set_subtarget(ob_server vt
   virtual_table/ob_information_table_constraints_table.cpp
   virtual_table/ob_information_table_privileges_table.cpp
   virtual_table/ob_information_user_privileges_table.cpp
+  virtual_table/ob_information_query_response_time.cpp
   virtual_table/ob_iterate_virtual_table.cpp
   virtual_table/ob_mem_leak_checker_info.cpp
   virtual_table/ob_mysql_db_table.cpp

src/observer/mysql/ob_query_response_time.cpp

+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#include "ob_query_response_time.h"
+#include "observer/omt/ob_tenant_timezone_mgr.h"
+#include "observer/omt/ob_tenant_config_mgr.h"
+
+using namespace oceanbase;
+using namespace oceanbase::common;
+using namespace oceanbase::share::schema;
+
+namespace oceanbase {
+namespace observer {
+
+ObRSTUtility::ObRSTUtility():base_(0)
+{
+    max_dec_value_ = MILLION;
+    for(int i= 0; OB_QRT_POSITIVE_LENGTH > i; ++i)
+        max_dec_value_ *= 10;
+    setup(OB_QRT_DEFAULT_BASE);
+}
+
+ObRSTUtility::~ObRSTUtility()
+{}
+
+int ObRSTUtility::setup(uint base)
+{
+    int ret = OB_SUCCESS;
+    if (base < 2) {
+        ret = OB_INVALID_ARGUMENT;
+    } else if(base != base_) {
+        base_= base;
+        
+        uint64_t value = MILLION;
+        negative_count_= 0;
+        while(value > 0){
+            negative_count_ += 1;
+            value /= base_;
+        }
+        negative_count_ -= 1;
+
+        value = MILLION;
+        positive_count_ = 0;
+        while(value < max_dec_value_){
+            positive_count_ += 1;
+            value *= base_;
+        }
+        bound_count_ = negative_count_ + positive_count_;
+
+        value = MILLION;
+        for(uint i = 0; i < negative_count_; ++i) {
+            value /= base_;
+            bound_[negative_count_ - i - 1] = value;
+        }
+
+        value = MILLION;
+        for(uint i = 0; i < positive_count_; ++i) {
+            bound_[negative_count_ + i] = value;
+            value *= base_;
+        }
+    }
+    return 0;
+}
+
+ObRSTTimeCollector::ObRSTTimeCollector():mutex_()
+{
+    flush();
+}
+ObRSTTimeCollector::~ObRSTTimeCollector()
+{}
+
+int ObRSTTimeCollector::flush()
+{
+    for(int i = 0; i < OB_QRT_OVERALL_COUNT + 1; i++) {
+        count_[i] = 0;
+        total_[i] = 0;
+    }
+    return 0;
+}
+
+int ObRSTTimeCollector::collect(uint64_t time)
+{
+    int i = 0;
+    for(int count = utility_.bound_count(); count > i; ++i) {
+        if(utility_.bound(i) > time) {
+            count_[i]++;
+            total_[i] += time;
+            break;
+        }
+    }
+    return 0;
+}
+
+ObRSTCollector::ObRSTCollector():inited_(false)
+{}
+
+ObRSTCollector::~ObRSTCollector(){
+    inited_ = false;
+    collector_map_.clear();
+}
+
+ObRSTCollector& ObRSTCollector::get_instance(){
+    static ObRSTCollector collector_instance_;
+    if (!collector_instance_.inited_){
+        collector_instance_.init();
+    }
+    return collector_instance_;
+}
+
+int ObRSTCollector::init()
+{
+  int ret = OB_SUCCESS;
+  if (inited_){
+    ret = OB_INIT_TWICE;
+  } else if (!collector_map_.created() &&
+        OB_FAIL(collector_map_.create(
+            common::OB_MAX_SERVER_TENANT_CNT, ObModIds::OB_HASH_BUCKET, ObModIds::OB_HASH_NODE))) {
+      ret = OB_NOT_INIT;
+      SQL_ENG_LOG(WARN, "create time collector map failed", K(ret));
+    } else {
+        inited_ = true;
+    } 
+  return ret;
+}
+
+int ObRSTCollector::collect_query_response_time(uint64_t tenant_id, uint64_t time){
+    int ret = OB_SUCCESS;
+    omt::ObTenantConfigGuard tenant_config(TENANT_CONF(tenant_id));
+    if(tenant_config->query_response_time_stats){
+        ObRSTTimeCollector* time_collector;
+        if (OB_FAIL(ret = collector_map_.get_refactored(tenant_id, time_collector))){
+          SERVER_LOG(WARN, "time collector of the tenant does not exist", K(tenant_id), K(time), K(ret));
+        } else {
+            lib::ObMutexGuard guard(time_collector->mutex_);
+            if(OB_FAIL(ret = time_collector->collect(time))){
+                SERVER_LOG(WARN, "time collector of the tenant collect time failed", K(tenant_id), K(time), K(ret));
+            }
+        }
+    }
+    return ret;
+}
+
+int ObRSTCollector::flush_query_response_time(uint64_t tenant_id,const ObString& is_enable) {
+    int ret = OB_SUCCESS;
+    bool is_enable_value = false;
+    bool is_valid = false;
+    is_enable_value = ObConfigBoolParser::get(is_enable.ptr(), is_valid);
+    omt::ObTenantConfigGuard tenant_config(TENANT_CONF(tenant_id));
+    if (!is_valid) {
+        ret = OB_INVALID_ARGUMENT;
+        SERVER_LOG(WARN, "invalid bool str", K(ret), K(is_enable), K(tenant_id));
+    } else if (is_enable_value) {
+        ObRSTTimeCollector* time_collector;
+        if (OB_FAIL(ret = collector_map_.get_refactored(tenant_id, time_collector))){
+            SERVER_LOG(WARN, "time collector of the tenant does not exist", K(ret), K(tenant_id));
+        } else {
+            lib::ObMutexGuard guard(time_collector->mutex_);
+            if (OB_FAIL(ret = time_collector->setup(tenant_config->query_response_time_range_base))){
+                SERVER_LOG(WARN, "time collector of the tenant set range base failed", K(ret), K(tenant_id));
+            } else if (OB_FAIL(ret = time_collector->flush())){
+                SERVER_LOG(WARN, "time collector of the tenant flush failed", K(ret), K(tenant_id));
+            } 
+        }    
+    }
+    return ret;
+}
+
+int ObRSTCollector::enable_query_response_time(uint64_t tenant_id){
+    int ret = OB_SUCCESS;
+    if (OB_FAIL(ret = collector_map_.set_refactored(tenant_id, new ObRSTTimeCollector()))) {
+        if (OB_HASH_EXIST == ret) {
+            ret = OB_ERR_ALREADY_EXISTS;
+        }
+    }
+    return ret;
+}
+
+int ObRSTCollector::free_query_response_time(uint64_t tenant_id){
+    int ret = OB_SUCCESS;
+    if (OB_FAIL(collector_map_.erase_refactored(tenant_id))) {
+        SERVER_LOG(WARN,"erase the time collector failed", K(tenant_id));
+    }
+    return ret;
+}
+
+int ObRSTCollector::control_query_response_time(uint64_t tenant_id, const ObString& is_enable){
+    int ret = OB_SUCCESS;
+    bool is_enable_value = false;
+    bool is_valid = false;
+    is_enable_value = ObConfigBoolParser::get(is_enable.ptr(), is_valid);
+    if (is_enable_value) {
+        if (OB_FAIL(ret = enable_query_response_time(tenant_id))){
+            SERVER_LOG(WARN, "enable the query response time failed", K(ret),K(tenant_id));
+        }
+    } else if (OB_FAIL(ret = free_query_response_time(tenant_id))){
+        SERVER_LOG(WARN, "free the query response time failed", K(ret),K(tenant_id));
+    }
+    return ret;
+}
+
+}  // namespace observer
+}  // namespace oceanbase

src/observer/mysql/ob_query_response_time.h

+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OB_QUERY_RESPONSE_TIME_
+#define OB_QUERY_RESPONSE_TIME_
+
+#include "share/ob_define.h"
+#include "lib/charset/ob_charset.h"
+#include "lib/string/ob_string.h"
+namespace oceanbase {
+
+namespace share {
+namespace schema {
+class ObTableSchema;
+class ObDatabaseSchema;
+
+}  // namespace schema
+}  // namespace share
+
+namespace observer {
+
+static const int32_t OB_QRT_POSITIVE_LENGTH = 7;
+static const int32_t OB_QRT_NEGATIVE_LENGTH = 7;
+
+// Defaute query reqponse time range base
+static const uint32_t OB_QRT_DEFAULT_BASE = 10;
+
+static const int32_t OB_QRT_POSITIVE_COUNT = (int32_t)(3.32192809 * OB_QRT_POSITIVE_LENGTH);
+static const int32_t OB_QRT_NEGATIVE_COUNT = (int32_t)(3.32192809 * OB_QRT_NEGATIVE_LENGTH);
+static const int32_t OB_QRT_OVERALL_COUNT = (int32_t)(OB_QRT_POSITIVE_COUNT + 1 + OB_QRT_NEGATIVE_COUNT);
+
+static const uint64_t MILLION = (uint64_t)(1000 * 1000);
+
+const char* const QUERY_RESPPONSE_TIME_STATS = "query_response_time_stats";
+const char* const QUERY_RESPPONSE_TIME_FLUSH = "query_response_time_flush";
+
+class ObRSTUtility {
+public:
+  ObRSTUtility();
+  virtual ~ObRSTUtility();
+  int setup(uint base);
+
+  uint base() const {return base_;};
+  uint negative_count() const { return negative_count_; };
+  uint positive_count() const { return positive_count_; };
+  uint bound_count()const { return bound_count_; };
+  uint64_t max_dec_value() const { return max_dec_value_; };
+  uint64_t bound(uint index) const { return bound_[index]; };
+
+private:
+  uint base_;
+  uint negative_count_;
+  uint positive_count_;
+  uint bound_count_;
+  uint64_t max_dec_value_; 
+  uint64_t bound_[OB_QRT_OVERALL_COUNT];
+};
+
+class ObRSTTimeCollector {
+public:
+
+  ObRSTUtility utility_;
+  lib::ObMutex mutex_;
+  uint32_t count_[OB_QRT_OVERALL_COUNT];
+  uint64_t total_[OB_QRT_OVERALL_COUNT];
+
+public:
+  ObRSTTimeCollector();
+  ~ObRSTTimeCollector();
+  int setup(uint base) {return utility_.setup(base);};
+  uint32_t count(uint index) {return count_[index];};
+  uint64_t total(uint index) {return total_[index];};
+  uint bound_count() {return utility_.bound_count();}
+  uint64_t bound(uint index) {return utility_.bound(index);}
+  void print_time(char* buffer, std::size_t buffer_size, const char* format, uint64_t value);
+  int flush();
+  int collect(uint64_t time);
+};
+
+class ObRSTCollector{
+public:
+  static ObRSTCollector& get_instance();
+  common::hash::ObHashMap<uint64_t /*tenant id*/, ObRSTTimeCollector*> collector_map_;
+  int init();
+  int control_query_response_time(uint64_t tenant_id, const ObString& is_enable);
+  int flush_query_response_time(uint64_t tenant_id, const ObString& is_enable);
+  int collect_query_response_time(uint64_t tenant_id_, uint64_t time);
+
+private:
+  ObRSTCollector();
+  ~ObRSTCollector();
+  bool inited_;
+  int free_query_response_time(uint64_t tenant_id);
+  int enable_query_response_time(uint64_t tenant_id);
+};
+
+}  // namespace observer
+}  // namespace oceanbase
+#endif /* OB_QUERY_RESPONSE_TIME_ */
+//// end of header file

src/observer/mysql/obmp_query.cpp

@@ -704,6 +704,7 @@ OB_INLINE int ObMPQuery::do_process(
     }
     // some statistics must be recorded for plan stat
     // even though sql audit disabled
+    audit_record.tenant_id_=session.get_effective_tenant_id();
     update_audit_info(total_wait_desc, audit_record);
     // Tetry:
     // 1. rs.open fail
@@ -982,6 +983,7 @@ int ObMPQuery::is_readonly_stmt(ObMySQLResultSet& result, bool& is_readonly)
     case stmt::T_SHOW_PRIVILEGES:
     case stmt::T_SHOW_RESTORE_PREVIEW:
     case stmt::T_SHOW_GRANTS:
+    case stmt::T_SHOW_QUERY_RESPONSE_TIME:
     case stmt::T_SHOW_RECYCLEBIN:
     case stmt::T_USE_DATABASE:
     case stmt::T_START_TRANS:

src/observer/mysql/obmp_stmt_execute.cpp

@@ -772,6 +772,7 @@ int ObMPStmtExecute::do_process(
         if (OB_NOT_NULL(plan_ctx)) {
           audit_record.consistency_level_ = plan_ctx->get_consistency_level();
         }
+        audit_record.tenant_id_=session.get_effective_tenant_id();
         audit_record.update_stage_stat();
       }
       // update v$sql statistics

src/observer/mysql/obmp_stmt_prepare.cpp

@@ -471,6 +471,7 @@ int ObMPStmtPrepare::do_process(
     audit_record.exec_record_.wait_time_end_ = total_wait_desc.time_waited_;
     audit_record.exec_record_.wait_count_end_ = total_wait_desc.total_waits_;
     audit_record.ps_stmt_id_ = result.get_statement_id();
+    audit_record.tenant_id_ = session.get_effective_tenant_id();
     audit_record.update_stage_stat();
     bool need_retry = (THIS_THWORKER.need_retry() || RETRY_TYPE_NONE != retry_ctrl_.get_retry_type());
     ObSQLUtils::handle_audit_record(need_retry, EXECUTE_PS_PREPARE, session, result.get_exec_context());

src/observer/mysql/obmp_stmt_send_long_data.cpp

@@ -263,6 +263,7 @@ int ObMPStmtSendLongData::do_process(ObSQLSessionInfo &session)
     audit_record.exec_record_.wait_time_end_ = total_wait_desc.time_waited_;
     audit_record.exec_record_.wait_count_end_ = total_wait_desc.total_waits_;
     audit_record.ps_stmt_id_ = stmt_id_;
+    audit_record.tenant_id_=session.get_effective_tenant_id();
     audit_record.update_stage_stat();
     // ObSQLUtils::handle_audit_record(false, EXECUTE_PS_EXECUTE,
     //     session, ctx_);

src/observer/ob_inner_sql_connection.cpp

@@ -613,6 +613,7 @@ int ObInnerSQLConnection::process_record(ObInnerSQLResult& res, sql::ObSQLSessio
     table_row_count_list = &(plan_ctx->get_table_row_count_list());
   }
 
+  audit_record.tenant_id_ = session.get_effective_tenant_id();
   audit_record.update_stage_stat();
 
   // update v$sql statistics

src/observer/virtual_table/ob_information_query_response_time.cpp

+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#include "ob_information_query_response_time.h"
+#include "lib/container/ob_array_serialization.h"
+#include "share/schema/ob_schema_getter_guard.h"
+#include "share/schema/ob_table_schema.h"
+#include "share/schema/ob_schema_utils.h"
+#include "observer/ob_server_struct.h"
+#include "observer/ob_server.h"
+#include "observer/omt/ob_tenant_timezone_mgr.h"
+
+using namespace oceanbase::common;
+using namespace oceanbase::share::schema;
+
+namespace oceanbase {
+namespace observer {
+ObInfoSchemaQueryResponseTimeTable::ObInfoSchemaQueryResponseTimeTable()
+ : ObVirtualTableScannerIterator(), 
+ addr_(NULL),
+ ipstr_(),
+ port_(0),
+ tenant_id_(OB_INVALID_ID),
+ collector_iter_(),
+ utility_iter_(0)
+{
+}
+
+ObInfoSchemaQueryResponseTimeTable::~ObInfoSchemaQueryResponseTimeTable()
+{
+  reset();
+}
+
+void ObInfoSchemaQueryResponseTimeTable::reset()
+{
+  ObVirtualTableScannerIterator::reset();
+  addr_ = NULL;
+  port_ = 0;
+  ipstr_.reset();
+  tenant_id_ = OB_INVALID_ID;
+  collector_iter_ = common::hash::ObHashMap<uint64_t, ObRSTTimeCollector*>::iterator();
+  utility_iter_ = 0;
+}
+
+int ObInfoSchemaQueryResponseTimeTable::set_ip(common::ObAddr* addr)
+{
+  int ret = OB_SUCCESS;
+  char ipbuf[common::OB_IP_STR_BUFF];
+  if (NULL == addr) {
+    ret = OB_ENTRY_NOT_EXIST;
+  } else if (!addr_->ip_to_string(ipbuf, sizeof(ipbuf))) {
+    SERVER_LOG(ERROR, "ip to string failed");
+    ret = OB_ERR_UNEXPECTED;
+  } else {
+    ipstr_ = ObString::make_string(ipbuf);
+    if (OB_FAIL(ob_write_string(*allocator_, ipstr_, ipstr_))) {
+      SERVER_LOG(WARN, "failed to write string", K(ret));
+    }
+    port_ = addr_->get_port();
+  }
+  return ret;
+}
+
+int ObInfoSchemaQueryResponseTimeTable::inner_open()
+{
+  int ret = OB_SUCCESS;
+  auto& collector = ObRSTCollector::get_instance();
+  if(0 == collector.collector_map_.size()){
+    SERVER_LOG(WARN, "query response time size is 0");
+  } else {
+    collector_iter_ = collector.collector_map_.begin();
+    if (OB_FAIL(ret = set_ip(addr_))) {
+      SERVER_LOG(WARN, "can't get ip", K(ret));
+    }
+  }
+  return ret;
+}
+
+int ObInfoSchemaQueryResponseTimeTable::inner_get_next_row(common::ObNewRow*& row)
+{
+  int ret = OB_SUCCESS;
+
+  ObObj* cells = cur_row_.cells_;
+  if (OB_UNLIKELY(NULL == allocator_)) {
+    ret = OB_NOT_INIT;
+    SERVER_LOG(WARN, "allocator is NULL", K(ret));
+  } else if (OB_UNLIKELY(NULL == schema_guard_)) {
+    ret = OB_NOT_INIT;
+    SERVER_LOG(WARN, "schema manager is NULL", K(ret));
+  } else if(0 == ObRSTCollector::get_instance().collector_map_.size()){
+      ret = OB_ITER_END;
+      SERVER_LOG(WARN, "query response time size is 0");
+  } else if (collector_iter_ == ObRSTCollector::get_instance().collector_map_.end()){
+      ret = OB_ITER_END;
+  } else {
+    const int64_t col_count = output_column_ids_.count();
+    if (OB_SUCC(ret)){
+      uint64_t cell_idx = 0;
+      for (int64_t j = 0; OB_SUCC(ret) && j < col_count; ++j) {
+        uint64_t col_id = output_column_ids_.at(j);
+        switch (col_id){
+          case TENANT_ID:{
+            tenant_id_ = collector_iter_->first;
+            cells[cell_idx].set_int(tenant_id_);
+            break;
+          }
+          case SVR_IP: {
+            cells[cell_idx].set_varchar(ipstr_);
+            break;
+          }
+          case SVR_PORT: {
+            cells[cell_idx].set_int(port_);
+            break;
+          }
+          case QUERY_RESPPONSE_TIME:{
+            cells[cell_idx].set_int(collector_iter_->second->bound(utility_iter_));
+            break;
+          }
+          case COUNT: {
+            cells[cell_idx].set_int(collector_iter_->second->count(utility_iter_));
+            break;
+          }
+          case TOTAL: {
+            cells[cell_idx].set_int(collector_iter_->second->total(utility_iter_));
+            break;
+          }
+          default: {
+            ret = OB_ERR_UNEXPECTED;
+            SERVER_LOG(WARN, "invalid column id", K(ret), K(cell_idx), K(output_column_ids_), K(col_id));
+            break;
+          }
+        }
+
+        if (OB_SUCC(ret)) {
+          cell_idx++;
+        }
+      }
+    }
+
+
+    if (OB_SUCC(ret)) {
+      row = &cur_row_;
+      utility_iter_++;
+      if(utility_iter_ == collector_iter_->second->bound_count()){
+        collector_iter_++;
+        utility_iter_ = 0;
+      }
+    }
+  }
+  return ret;
+}
+
+}  // namespace observer
+}  // namespace oceanbase

src/observer/virtual_table/ob_information_query_response_time.h

+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_OBSERVER_VIRTUAL_TABLE_OB_INFORMATION_QUERY_RESPONSE_TIME_
+#define OCEANBASE_OBSERVER_VIRTUAL_TABLE_OB_INFORMATION_QUERY_RESPONSE_TIME_
+#include "share/ob_virtual_table_scanner_iterator.h"
+#include "share/ob_tenant_mgr.h"
+#include "observer/mysql/ob_query_response_time.h"
+
+namespace oceanbase {
+namespace common {
+class ObObj;
+
+}
+namespace share {
+namespace schema {
+class ObTableSchema;
+class ObDatabaseSchema;
+
+}  // namespace schema
+}  // namespace share
+
+namespace observer {
+
+class ObInfoSchemaQueryResponseTimeTable : public common::ObVirtualTableScannerIterator {
+public:
+  ObInfoSchemaQueryResponseTimeTable();
+  virtual ~ObInfoSchemaQueryResponseTimeTable();
+  virtual int inner_open() override;
+  virtual int inner_get_next_row(common::ObNewRow*& row) override;
+  virtual void reset() override;
+  int set_ip(common::ObAddr* addr);
+  inline void set_addr(common::ObAddr& addr)
+  {
+    addr_ = &addr;
+  }
+  
+private:
+  enum SYS_COLUMN {
+    TENANT_ID = common::OB_APP_MIN_COLUMN_ID,
+    SVR_IP,
+    SVR_PORT,
+    QUERY_RESPPONSE_TIME,
+    COUNT,
+    TOTAL
+  };
+  common::ObAddr* addr_;
+  common::ObString ipstr_;
+  int32_t port_;
+  uint64_t tenant_id_;
+  common::hash::ObHashMap<uint64_t, ObRSTTimeCollector*>::iterator collector_iter_;
+  int32_t utility_iter_;
+};
+
+}  // namespace observer
+}  // namespace oceanbase
+#endif /* OCEANBASE_OBSERVER_VIRTUAL_TABLE_OB_INFORMATION_QUERY_RESPONSE_TIME_ */

src/observer/virtual_table/ob_virtual_table_iterator_factory.cpp

@@ -1677,6 +1677,16 @@ int ObVTIterCreator::create_vt_iter(ObVTableScanParam& params, ObVirtualTableIte
             }
             break;
           }
+            
+          case OB_ALL_VIRTUAL_QUERY_RESPONSE_TIME_TID: {
+            ObInfoSchemaQueryResponseTimeTable* query_response_time_table = NULL;
+            if (OB_SUCC(NEW_VIRTUAL_TABLE(ObInfoSchemaQueryResponseTimeTable, query_response_time_table))) {
+              query_response_time_table->set_addr(addr_);
+              vt_iter = static_cast<ObVirtualTableIterator*>(query_response_time_table);
+            }
+            break;
+          }
+
           case OB_ALL_VIRTUAL_SQL_AUDIT_TID: {
             ObGvSqlAudit* sql_audit_table = NULL;
             if (OB_SUCC(NEW_VIRTUAL_TABLE(ObGvSqlAudit, sql_audit_table))) {

src/share/backup/ob_backup_struct.h

@@ -1475,7 +1475,7 @@ public:
   int64_t piece_id_;
   JobStatus status_;
   share::ObBackupDest backup_dest_;
-  int64_t max_backup_times_;  // -1 表示没有限制
+  int64_t max_backup_times_;  // -1 no limit
   int result_;
   Comment comment_;
   int64_t type_;
@@ -1599,7 +1599,7 @@ public:
   int64_t compatible_;
   int64_t cluster_version_;  // restore tenant cluster version
   ObPhysicalRestoreBackupDestList multi_restore_path_list_;
-  int64_t backup_date_;  //备份的位点，RS只允许从这个位点之后的位点恢复
+  int64_t backup_date_;  //backup base date, RS only backup data after the date
   int64_t restore_schema_version_;
 
   common::ObSArray<share::ObSimpleBackupSetPath>& get_backup_set_path_list()

src/share/inner_table/ob_inner_table_schema.12301_12350.cpp

@@ -24,6 +24,162 @@ using namespace common;
 namespace share
 {
 
+int ObInnerTableSchema::all_virtual_query_response_time_schema(ObTableSchema &table_schema)
+{
+  int ret = OB_SUCCESS;
+  uint64_t column_id = OB_APP_MIN_COLUMN_ID - 1;
+
+  //generated fields:
+  table_schema.set_tenant_id(OB_SYS_TENANT_ID);
+  table_schema.set_tablegroup_id(OB_INVALID_ID);
+  table_schema.set_database_id(combine_id(OB_SYS_TENANT_ID, OB_SYS_DATABASE_ID));
+  table_schema.set_table_id(combine_id(OB_SYS_TENANT_ID, OB_ALL_VIRTUAL_QUERY_RESPONSE_TIME_TID));
+  table_schema.set_rowkey_split_pos(0);
+  table_schema.set_is_use_bloomfilter(false);
+  table_schema.set_progressive_merge_num(0);
+  table_schema.set_rowkey_column_num(0);
+  table_schema.set_load_type(TABLE_LOAD_TYPE_IN_DISK);
+  table_schema.set_table_type(VIRTUAL_TABLE);
+  table_schema.set_index_type(INDEX_TYPE_IS_NOT);
+  table_schema.set_def_type(TABLE_DEF_TYPE_INTERNAL);
+
+  if (OB_SUCC(ret)) {
+    if (OB_FAIL(table_schema.set_table_name(OB_ALL_VIRTUAL_QUERY_RESPONSE_TIME_TNAME))) {
+      LOG_ERROR("fail to set table_name", K(ret));
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_FAIL(table_schema.set_compress_func_name(OB_DEFAULT_COMPRESS_FUNC_NAME))) {
+      LOG_ERROR("fail to set compress_func_name", K(ret));
+    }
+  }
+  table_schema.set_part_level(PARTITION_LEVEL_ZERO);
+  table_schema.set_charset_type(ObCharset::get_default_charset());
+  table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
+  table_schema.set_create_mem_version(1);
+
+  if (OB_SUCC(ret)) {
+    ADD_COLUMN_SCHEMA("tenant_id", //column_name
+      ++column_id, //column_id
+      0, //rowkey_id
+      0, //index_id
+      0, //part_key_pos
+      ObIntType, //column_type
+      CS_TYPE_INVALID, //column_collation_type
+      sizeof(int64_t), //column_length
+      -1, //column_precision
+      -1, //column_scale
+      false, //is_nullable
+      false); //is_autoincrement
+  }
+
+  if (OB_SUCC(ret)) {
+    ADD_COLUMN_SCHEMA("svr_ip", //column_name
+      ++column_id, //column_id
+      0, //rowkey_id
+      0, //index_id
+      1, //part_key_pos
+      ObVarcharType, //column_type
+      CS_TYPE_INVALID, //column_collation_type
+      MAX_IP_ADDR_LENGTH, //column_length
+      -1, //column_precision
+      -1, //column_scale
+      false, //is_nullable
+      false); //is_autoincrement
+  }
+
+  if (OB_SUCC(ret)) {
+    ADD_COLUMN_SCHEMA("svr_port", //column_name
+      ++column_id, //column_id
+      0, //rowkey_id
+      0, //index_id
+      2, //part_key_pos
+      ObIntType, //column_type
+      CS_TYPE_INVALID, //column_collation_type
+      sizeof(int64_t), //column_length
+      -1, //column_precision
+      -1, //column_scale
+      false, //is_nullable
+      false); //is_autoincrement
+  }
+
+  if (OB_SUCC(ret)) {
+    ObObj response_time_default;
+    response_time_default.set_int(0);
+    ADD_COLUMN_SCHEMA_T("response_time", //column_name
+      ++column_id, //column_id
+      0, //rowkey_id
+      0, //index_id
+      0, //part_key_pos
+      ObIntType, //column_type
+      CS_TYPE_INVALID, //column_collation_type
+      sizeof(int64_t), //column_length
+      14, //column_precision
+      0, //column_scale
+      false, //is_nullable
+      false, //is_autoincrement
+      response_time_default,
+      response_time_default); //default_value
+  }
+
+  if (OB_SUCC(ret)) {
+    ObObj count_default;
+    count_default.set_int(0);
+    ADD_COLUMN_SCHEMA_T("count", //column_name
+      ++column_id, //column_id
+      0, //rowkey_id
+      0, //index_id
+      0, //part_key_pos
+      ObIntType, //column_type
+      CS_TYPE_INVALID, //column_collation_type
+      sizeof(int64_t), //column_length
+      14, //column_precision
+      0, //column_scale
+      false, //is_nullable
+      false, //is_autoincrement
+      count_default,
+      count_default); //default_value
+  }
+
+  if (OB_SUCC(ret)) {
+    ObObj total_default;
+    total_default.set_int(0);
+    ADD_COLUMN_SCHEMA_T("total", //column_name
+      ++column_id, //column_id
+      0, //rowkey_id
+      0, //index_id
+      0, //part_key_pos
+      ObIntType, //column_type
+      CS_TYPE_INVALID, //column_collation_type
+      sizeof(int64_t), //column_length
+      14, //column_precision
+      0, //column_scale
+      false, //is_nullable
+      false, //is_autoincrement
+      total_default,
+      total_default); //default_value
+  }
+  if (OB_SUCC(ret)) {
+    table_schema.get_part_option().set_part_func_type(PARTITION_FUNC_TYPE_HASH);
+    if (OB_FAIL(table_schema.get_part_option().set_part_expr("hash (addr_to_partition_id(svr_ip, svr_port))"))) {
+      LOG_WARN("set_part_expr failed", K(ret));
+    }
+    table_schema.get_part_option().set_part_num(65536);
+    table_schema.set_part_level(PARTITION_LEVEL_ONE);
+  }
+  table_schema.set_index_using_type(USING_HASH);
+  table_schema.set_row_store_type(FLAT_ROW_STORE);
+  table_schema.set_store_format(OB_STORE_FORMAT_COMPACT_MYSQL);
+  table_schema.set_progressive_merge_round(1);
+  table_schema.set_storage_format_version(3);
+
+  table_schema.set_max_used_column_id(column_id);
+  table_schema.get_part_option().set_max_used_part_id(table_schema.get_part_option().get_part_num() - 1);
+  table_schema.get_part_option().set_partition_cnt_within_partition_table(OB_ALL_CORE_TABLE_TID == common::extract_pure_id(table_schema.get_table_id()) ? 1 : 0);
+  return ret;
+}
+
 int ObInnerTableSchema::all_virtual_kv_ttl_task_schema(ObTableSchema &table_schema)
 {
   int ret = OB_SUCCESS;

src/share/inner_table/ob_inner_table_schema.21301_21350.cpp

@@ -128,6 +128,58 @@ int ObInnerTableSchema::dba_ob_kv_ttl_task_history_schema(ObTableSchema &table_s
   return ret;
 }
 
+int ObInnerTableSchema::query_response_time_schema(ObTableSchema &table_schema)
+{
+  int ret = OB_SUCCESS;
+  uint64_t column_id = OB_APP_MIN_COLUMN_ID - 1;
+
+  //generated fields:
+  table_schema.set_tenant_id(OB_SYS_TENANT_ID);
+  table_schema.set_tablegroup_id(combine_id(OB_SYS_TENANT_ID, OB_SYS_TABLEGROUP_ID));
+  table_schema.set_database_id(combine_id(OB_SYS_TENANT_ID, OB_INFORMATION_SCHEMA_ID));
+  table_schema.set_table_id(combine_id(OB_SYS_TENANT_ID, OB_QUERY_RESPONSE_TIME_TID));
+  table_schema.set_rowkey_split_pos(0);
+  table_schema.set_is_use_bloomfilter(false);
+  table_schema.set_progressive_merge_num(0);
+  table_schema.set_rowkey_column_num(0);
+  table_schema.set_load_type(TABLE_LOAD_TYPE_IN_DISK);
+  table_schema.set_table_type(SYSTEM_VIEW);
+  table_schema.set_index_type(INDEX_TYPE_IS_NOT);
+  table_schema.set_def_type(TABLE_DEF_TYPE_INTERNAL);
+
+  if (OB_SUCC(ret)) {
+    if (OB_FAIL(table_schema.set_table_name(OB_QUERY_RESPONSE_TIME_TNAME))) {
+      LOG_ERROR("fail to set table_name", K(ret));
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_FAIL(table_schema.set_compress_func_name(OB_DEFAULT_COMPRESS_FUNC_NAME))) {
+      LOG_ERROR("fail to set compress_func_name", K(ret));
+    }
+  }
+  table_schema.set_part_level(PARTITION_LEVEL_ZERO);
+  table_schema.set_charset_type(ObCharset::get_default_charset());
+  table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
+  table_schema.set_create_mem_version(1);
+
+  if (OB_SUCC(ret)) {
+    if (OB_FAIL(table_schema.set_view_definition(R"__(select response_time as RESPONSE_TIME,                    count as COUNT,                    total as TOTAL                    from oceanbase.__all_virtual_query_response_time                    where is_serving_tenant(svr_ip, svr_port, effective_tenant_id()) and                    tenant_id = effective_tenant_id() )__"))) {
+      LOG_ERROR("fail to set view_definition", K(ret));
+    }
+  }
+  table_schema.set_index_using_type(USING_BTREE);
+  table_schema.set_row_store_type(FLAT_ROW_STORE);
+  table_schema.set_store_format(OB_STORE_FORMAT_COMPACT_MYSQL);
+  table_schema.set_progressive_merge_round(1);
+  table_schema.set_storage_format_version(3);
+
+  table_schema.set_max_used_column_id(column_id);
+  table_schema.get_part_option().set_max_used_part_id(table_schema.get_part_option().get_part_num() - 1);
+  table_schema.get_part_option().set_partition_cnt_within_partition_table(OB_ALL_CORE_TABLE_TID == common::extract_pure_id(table_schema.get_table_id()) ? 1 : 0);
+  return ret;
+}
+
 int ObInnerTableSchema::cdb_ob_kv_ttl_tasks_schema(ObTableSchema &table_schema)
 {
   int ret = OB_SUCCESS;

src/share/inner_table/ob_inner_table_schema.h

@@ -767,6 +767,7 @@ public:
   static int all_virtual_backup_backupset_task_schema(share::schema::ObTableSchema &table_schema);
   static int all_virtual_pg_backup_backupset_task_schema(share::schema::ObTableSchema &table_schema);
   static int all_virtual_global_transaction_schema(share::schema::ObTableSchema &table_schema);
+  static int all_virtual_query_response_time_schema(share::schema::ObTableSchema &table_schema);
   static int all_virtual_kv_ttl_task_schema(share::schema::ObTableSchema &table_schema);
   static int all_virtual_kv_ttl_task_history_schema(share::schema::ObTableSchema &table_schema);
   static int all_virtual_table_agent_schema(share::schema::ObTableSchema &table_schema);
@@ -1081,6 +1082,7 @@ public:
   static int column_privileges_schema(share::schema::ObTableSchema &table_schema);
   static int dba_ob_kv_ttl_tasks_schema(share::schema::ObTableSchema &table_schema);
   static int dba_ob_kv_ttl_task_history_schema(share::schema::ObTableSchema &table_schema);
+  static int query_response_time_schema(share::schema::ObTableSchema &table_schema);
   static int cdb_ob_kv_ttl_tasks_schema(share::schema::ObTableSchema &table_schema);
   static int cdb_ob_kv_ttl_task_history_schema(share::schema::ObTableSchema &table_schema);
   static int dba_synonyms_schema(share::schema::ObTableSchema &table_schema);
@@ -1807,6 +1809,7 @@ const schema_create_func virtual_table_schema_creators [] = {
   ObInnerTableSchema::all_virtual_backup_backupset_task_schema,
   ObInnerTableSchema::all_virtual_pg_backup_backupset_task_schema,
   ObInnerTableSchema::all_virtual_global_transaction_schema,
+  ObInnerTableSchema::all_virtual_query_response_time_schema,
   ObInnerTableSchema::all_virtual_kv_ttl_task_schema,
   ObInnerTableSchema::all_virtual_kv_ttl_task_history_schema,
   ObInnerTableSchema::all_virtual_table_agent_schema,
@@ -2142,6 +2145,7 @@ const schema_create_func sys_view_schema_creators [] = {
   ObInnerTableSchema::column_privileges_schema,
   ObInnerTableSchema::dba_ob_kv_ttl_tasks_schema,
   ObInnerTableSchema::dba_ob_kv_ttl_task_history_schema,
+  ObInnerTableSchema::query_response_time_schema,
   ObInnerTableSchema::cdb_ob_kv_ttl_tasks_schema,
   ObInnerTableSchema::cdb_ob_kv_ttl_task_history_schema,
   ObInnerTableSchema::dba_synonyms_schema,
@@ -2834,6 +2838,7 @@ const uint64_t tenant_space_tables [] = {
   OB_COLUMN_PRIVILEGES_TID,
   OB_DBA_OB_KV_TTL_TASKS_TID,
   OB_DBA_OB_KV_TTL_TASK_HISTORY_TID,
+  OB_QUERY_RESPONSE_TIME_TID,
   OB_DBA_SYNONYMS_TID,
   OB_DBA_OBJECTS_TID,
   OB_ALL_OBJECTS_TID,
@@ -3696,6 +3701,7 @@ const char* const tenant_space_table_names [] = {
   OB_COLUMN_PRIVILEGES_TNAME,
   OB_DBA_OB_KV_TTL_TASKS_TNAME,
   OB_DBA_OB_KV_TTL_TASK_HISTORY_TNAME,
+  OB_QUERY_RESPONSE_TIME_TNAME,
   OB_DBA_SYNONYMS_TNAME,
   OB_DBA_OBJECTS_TNAME,
   OB_ALL_OBJECTS_TNAME,
@@ -4078,11 +4084,11 @@ static inline bool is_only_rs_virtual_table(const uint64_t tid)
 
 const int64_t OB_CORE_TABLE_COUNT = 5;
 const int64_t OB_SYS_TABLE_COUNT = 189;
-const int64_t OB_VIRTUAL_TABLE_COUNT = 465;
-const int64_t OB_SYS_VIEW_COUNT = 364;
-const int64_t OB_SYS_TENANT_TABLE_COUNT = 1024;
+const int64_t OB_VIRTUAL_TABLE_COUNT = 466;
+const int64_t OB_SYS_VIEW_COUNT = 365;
+const int64_t OB_SYS_TENANT_TABLE_COUNT = 1026;
 const int64_t OB_CORE_SCHEMA_VERSION = 1;
-const int64_t OB_BOOTSTRAP_SCHEMA_VERSION = 1027;
+const int64_t OB_BOOTSTRAP_SCHEMA_VERSION = 1029;
 
 } // end namespace share
 } // end namespace oceanbase

src/share/inner_table/ob_inner_table_schema_constants.h

@@ -500,6 +500,7 @@ const uint64_t OB_ALL_VIRTUAL_BACKUPSET_HISTORY_MGR_TID = 12201; // "__all_virtu
 const uint64_t OB_ALL_VIRTUAL_BACKUP_BACKUPSET_TASK_TID = 12202; // "__all_virtual_backup_backupset_task"
 const uint64_t OB_ALL_VIRTUAL_PG_BACKUP_BACKUPSET_TASK_TID = 12203; // "__all_virtual_pg_backup_backupset_task"
 const uint64_t OB_ALL_VIRTUAL_GLOBAL_TRANSACTION_TID = 12206; // "__all_virtual_global_transaction"
+const uint64_t OB_ALL_VIRTUAL_QUERY_RESPONSE_TIME_TID = 12325; // "__all_virtual_query_response_time"
 const uint64_t OB_ALL_VIRTUAL_KV_TTL_TASK_TID = 12326; // "__all_virtual_kv_ttl_task"
 const uint64_t OB_ALL_VIRTUAL_KV_TTL_TASK_HISTORY_TID = 12327; // "__all_virtual_kv_ttl_task_history"
 const uint64_t OB_ALL_VIRTUAL_TABLE_AGENT_TID = 15001; // "ALL_VIRTUAL_TABLE_AGENT"
@@ -814,6 +815,7 @@ const uint64_t OB_CDB_OB_BACKUP_BACKUP_ARCHIVELOG_TID = 21144; // "CDB_OB_BACKUP
 const uint64_t OB_COLUMN_PRIVILEGES_TID = 21150; // "COLUMN_PRIVILEGES"
 const uint64_t OB_DBA_OB_KV_TTL_TASKS_TID = 21300; // "DBA_OB_KV_TTL_TASKS"
 const uint64_t OB_DBA_OB_KV_TTL_TASK_HISTORY_TID = 21301; // "DBA_OB_KV_TTL_TASK_HISTORY"
+const uint64_t OB_QUERY_RESPONSE_TIME_TID = 21306; // "QUERY_RESPONSE_TIME"
 const uint64_t OB_CDB_OB_KV_TTL_TASKS_TID = 21307; // "CDB_OB_KV_TTL_TASKS"
 const uint64_t OB_CDB_OB_KV_TTL_TASK_HISTORY_TID = 21308; // "CDB_OB_KV_TTL_TASK_HISTORY"
 const uint64_t OB_DBA_SYNONYMS_TID = 25001; // "DBA_SYNONYMS"
@@ -1528,6 +1530,7 @@ const char *const OB_ALL_VIRTUAL_BACKUPSET_HISTORY_MGR_TNAME = "__all_virtual_ba
 const char *const OB_ALL_VIRTUAL_BACKUP_BACKUPSET_TASK_TNAME = "__all_virtual_backup_backupset_task";
 const char *const OB_ALL_VIRTUAL_PG_BACKUP_BACKUPSET_TASK_TNAME = "__all_virtual_pg_backup_backupset_task";
 const char *const OB_ALL_VIRTUAL_GLOBAL_TRANSACTION_TNAME = "__all_virtual_global_transaction";
+const char *const OB_ALL_VIRTUAL_QUERY_RESPONSE_TIME_TNAME = "__all_virtual_query_response_time";
 const char *const OB_ALL_VIRTUAL_KV_TTL_TASK_TNAME = "__all_virtual_kv_ttl_task";
 const char *const OB_ALL_VIRTUAL_KV_TTL_TASK_HISTORY_TNAME = "__all_virtual_kv_ttl_task_history";
 const char *const OB_ALL_VIRTUAL_TABLE_AGENT_TNAME = "ALL_VIRTUAL_TABLE_AGENT";
@@ -1842,6 +1845,7 @@ const char *const OB_CDB_OB_BACKUP_BACKUP_ARCHIVELOG_TNAME = "CDB_OB_BACKUP_BACK
 const char *const OB_COLUMN_PRIVILEGES_TNAME = "COLUMN_PRIVILEGES";
 const char *const OB_DBA_OB_KV_TTL_TASKS_TNAME = "DBA_OB_KV_TTL_TASKS";
 const char *const OB_DBA_OB_KV_TTL_TASK_HISTORY_TNAME = "DBA_OB_KV_TTL_TASK_HISTORY";
+const char *const OB_QUERY_RESPONSE_TIME_TNAME = "QUERY_RESPONSE_TIME";
 const char *const OB_CDB_OB_KV_TTL_TASKS_TNAME = "CDB_OB_KV_TTL_TASKS";
 const char *const OB_CDB_OB_KV_TTL_TASK_HISTORY_TNAME = "CDB_OB_KV_TTL_TASK_HISTORY";
 const char *const OB_DBA_SYNONYMS_TNAME = "DBA_SYNONYMS";

src/share/inner_table/ob_inner_table_schema_def.py

@@ -10214,6 +10214,25 @@ def_table_schema(**gen_iterate_virtual_table_def(
   table_name = '__all_virtual_global_transaction',
   keywords = all_def_keywords['__all_tenant_global_transaction']))
 
+def_table_schema(
+  tablegroup_id='OB_INVALID_ID',
+  table_name='__all_virtual_query_response_time',
+  table_id='12325',
+  table_type='VIRTUAL_TABLE',
+  gm_columns=[],
+  rowkey_columns=[
+  ],
+  normal_columns=[
+    ('tenant_id', 'int', 'false'),
+    ('svr_ip', 'varchar:MAX_IP_ADDR_LENGTH', 'false'),
+    ('svr_port', 'int'),
+    ('response_time', 'bigint:14', 'false', '0'),
+    ('count',  'bigint:14', 'false', '0'),
+    ('total',  'bigint:14', 'false', '0')
+  ],
+  partition_columns=['svr_ip', 'svr_port'],
+)
+
 def_table_schema(**gen_iterate_virtual_table_def(
   table_id = '12326',
   real_tenant_id=True,
@@ -14712,6 +14731,24 @@ def_table_schema(
 """.replace("\n", " ")
 )
 
+def_table_schema(
+  database_id='OB_INFORMATION_SCHEMA_ID',
+  table_name='QUERY_RESPONSE_TIME',
+  table_id='21306',
+  table_type='SYSTEM_VIEW',
+  gm_columns=[],
+  rowkey_columns=[],
+  in_tenant_space=True,
+  view_definition="""select response_time as RESPONSE_TIME,
+                   count as COUNT,
+                   total as TOTAL
+                   from oceanbase.__all_virtual_query_response_time
+                   where is_serving_tenant(svr_ip, svr_port, effective_tenant_id()) and
+                   tenant_id = effective_tenant_id()
+""".replace("\n", " "),
+  normal_columns=[],
+)
+
 def_table_schema(
   table_name      = 'CDB_OB_KV_TTL_TASKS',
   table_id        = '21307',

src/share/parameter/ob_parameter_seed.ipp

@@ -1566,3 +1566,18 @@ DEF_TIME(kv_ttl_history_recycle_interval, OB_TENANT_PARAMETER, "7d", "[1d, 180d]
 DEF_BOOL(enable_kv_ttl, OB_TENANT_PARAMETER, "False",
     "specifies whether ttl task is enbled",
     ObParameterAttr(Section::ROOT_SERVICE, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));
+
+// query response time
+DEF_BOOL(query_response_time_stats, OB_TENANT_PARAMETER, "False",
+    "Enable or disable QUERY_RESPONSE_TIME statistics collecting"
+    "The default value is False. Value: TRUE: turned on FALSE: turned off",
+    ObParameterAttr(Section::TENANT, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));
+DEF_BOOL(query_response_time_flush, OB_TENANT_PARAMETER, "False",
+    "Flush QUERY_RESPONSE_TIME table and re-read query_response_time_range_base"
+    "The default value is False. Value: TRUE: trigger flush FALSE: do not trigger",
+    ObParameterAttr(Section::TENANT, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));
+DEF_INT(query_response_time_range_base, OB_TENANT_PARAMETER, "10", "[2,10000]",
+    "Select base of log for QUERY_RESPONSE_TIME ranges. WARNING: variable change takes affect only after flush."
+    "The default value is False. Value: TRUE: trigger flush FALSE: do not trigger",
+    ObParameterAttr(Section::TENANT, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE)); 
+

src/sql/engine/px/ob_px_task_process.cpp

@@ -206,6 +206,7 @@ int ObPxTaskProcess::process()
         audit_record.exec_record_ = exec_record;
 
         // Accumulated time of update phase
+        audit_record.tenant_id_=session->get_effective_tenant_id();
         audit_record.update_stage_stat();
 
         ObSQLUtils::handle_audit_record(false, EXECUTE_DIST, *session, *arg_.exec_ctx_);

src/sql/executor/ob_executor_rpc_processor.cpp

@@ -308,6 +308,7 @@ int ObDistExecuteBaseP::execute_dist_plan(ObTask& task, ObTaskCompleteEvent& tas
 
           audit_record.exec_timestamp_ = exec_timestamp;
           audit_record.exec_record_ = exec_record;
+          audit_record.tenant_id_=session->get_effective_tenant_id();
 
           audit_record.update_stage_stat();
 
@@ -1323,6 +1324,7 @@ int ObMiniTaskBaseP::execute_mini_plan(ObMiniTask& task, ObMiniTaskResult& resul
 
         audit_record.exec_timestamp_ = exec_timestamp;
         audit_record.exec_record_ = exec_record;
+        audit_record.tenant_id_=session->get_effective_tenant_id();
 
         audit_record.update_stage_stat();
 

src/sql/executor/ob_remote_executor_processor.cpp

@@ -644,6 +644,7 @@ void ObRemoteBaseExecuteP<T>::record_sql_audit_and_plan_stat(const ObPhysicalPla
 
     audit_record.exec_timestamp_ = exec_timestamp;
     audit_record.exec_record_ = exec_record;
+    audit_record.tenant_id_=session->get_effective_tenant_id();
 
     audit_record.update_stage_stat();
 

src/sql/monitor/ob_exec_stat.h

@@ -56,6 +56,8 @@ EVENT_INFO(FUSE_ROW_CACHE_MISS, fuse_row_cache_miss)
 #include "lib/net/ob_addr.h"
 #include "sql/ob_sql_define.h"
 #include "sql/plan_cache/ob_plan_cache_util.h"
+#include "observer/virtual_table/ob_information_query_response_time.h"
+#include "observer/mysql/ob_query_response_time.h"
 namespace oceanbase {
 namespace sql {
 struct ObExecRecord {
@@ -341,6 +343,7 @@ struct ObAuditRecordData {
       EVENT_ADD(SYS_TIME_MODEL_DB_TIME, elapsed_time);
       EVENT_ADD(SYS_TIME_MODEL_DB_CPU, cpu_time);
     }
+    observer::ObRSTCollector::get_instance().collect_query_response_time(tenant_id_,elapsed_time);
   }
 
   bool is_timeout() const

src/sql/ob_sql_partition_location_cache.cpp

@@ -371,6 +371,7 @@ ObSqlPartitionLocationCache::LocationDistributedMode ObSqlPartitionLocationCache
     case OB_ALL_VIRTUAL_SESSTAT_TID:
     case OB_ALL_VIRTUAL_SYSSTAT_TID:
     case OB_ALL_VIRTUAL_STORAGE_STAT_TID:
+    case OB_ALL_VIRTUAL_QUERY_RESPONSE_TIME_TID:
     case OB_ALL_VIRTUAL_DISK_STAT_TID:
     case OB_ALL_VIRTUAL_MEMSTORE_INFO_TID:
     case OB_ALL_VIRTUAL_PARTITION_INFO_TID:

src/sql/parser/non_reserved_keywords_mysql_mode.c

@@ -680,7 +680,8 @@ static const NonReservedKeyword Mysql_none_reserved_keywords[] = {
     {"up", UP},
     {"times", TIMES},
     {"backupround", BACKUPROUND},
-    {"TTL", TTL}};
+    {"TTL", TTL},
+    {"query_response_time",QUERY_RESPONSE_TIME}};
 
 /** https://dev.mysql.com/doc/refman/5.7/en/sql-syntax-prepared-statements.html
  ALTER TABLE

src/sql/parser/ob_item_type.h

@@ -967,6 +967,7 @@ typedef enum ObItemType
   T_SHOW_CREATE_TABLEGROUP,
   T_SHOW_RESTORE_PREVIEW,
   T_SHOW_GRANTS,
+  T_SHOW_QUERY_RESPONSE_TIME,
 
   T_SHOW_LIMIT,
   T_CREATE_USER,

src/sql/parser/sql_parser_mysql_mode.y

@@ -260,7 +260,7 @@ END_P SET_VAR DELIMITER
         PROCESSLIST PROFILE PROFILES PROXY PRECEDING PCTFREE P_ENTITY P_CHUNK PRIMARY_ROOTSERVICE_LIST
         PRIMARY_CLUSTER_ID PUBLIC PROGRESSIVE_MERGE_NUM PREVIEW PS
 
-        QUARTER QUERY QUEUE_TIME QUICK
+        QUARTER QUERY QUERY_RESPONSE_TIME QUEUE_TIME QUICK
 
         REBUILD RECOVER RECYCLE REDO_BUFFER_SIZE REDOFILE REDUNDANT REFRESH REGION RELAY RELAYLOG
         RELAY_LOG_FILE RELAY_LOG_POS RELAY_THREAD RELOAD REMOVE REORGANIZE REPAIR REPEATABLE REPLICA
@@ -9638,6 +9638,10 @@ SHOW opt_full TABLES opt_from_or_in_database_clause opt_show_condition
 {
   malloc_terminal_node($$, result->malloc_pool_, T_SHOW_PRIVILEGES);
 }
+| SHOW QUERY_RESPONSE_TIME
+{
+  malloc_terminal_node($$, result->malloc_pool_, T_SHOW_QUERY_RESPONSE_TIME);
+}
 | SHOW RECYCLEBIN
 {
   malloc_terminal_node($$, result->malloc_pool_, T_SHOW_RECYCLEBIN);
@@ -14099,6 +14103,7 @@ ACCOUNT
 |       P_CHUNK
 |       QUARTER
 |       QUERY %prec KILL_EXPR
+|       QUERY_RESPONSE_TIME
 |       QUEUE_TIME
 |       QUICK
 |       RANK

src/sql/resolver/cmd/ob_alter_system_resolver.cpp

@@ -37,12 +37,14 @@
 #include "sql/resolver/cmd/ob_variable_set_stmt.h"
 #include "observer/ob_server.h"
 #include "rootserver/ob_rs_event_history_table_operator.h"
+#include "observer/mysql/ob_query_response_time.h"
 
 namespace oceanbase {
 using namespace common;
 using namespace obrpc;
 using namespace share;
 using namespace share::schema;
+using namespace observer;
 namespace sql {
 typedef ObAlterSystemResolverUtil Util;
 
@@ -2443,6 +2445,14 @@ int ObSetConfigResolver::resolve(const ParseNode& parse_tree)
                 if (OB_FAIL(check_auto_update_reserved_backup_timestamp(item.value_.str()))) {
                   LOG_WARN("cannot set enable log archive true", K(ret));
                 }
+              } else if (0 == STRCMP(item.name_.ptr(), QUERY_RESPPONSE_TIME_FLUSH)) {
+                if(OB_FAIL(observer::ObRSTCollector::get_instance().flush_query_response_time(item.exec_tenant_id_, item.value_.str()))){
+                  LOG_WARN("set query response time flush", K(ret));
+                }  
+              } else if (0 == STRCMP(item.name_.ptr(), QUERY_RESPPONSE_TIME_STATS)) {
+                if(OB_FAIL(observer::ObRSTCollector::get_instance().control_query_response_time(item.exec_tenant_id_, item.value_.str()))){
+                  LOG_WARN("set query response time stats", K(ret));
+                }  
               }
             }
           }

src/sql/resolver/cmd/ob_show_resolver.cpp

@@ -79,7 +79,7 @@ int ObShowResolver::resolve(const ParseNode& parse_tree)
   if (OB_UNLIKELY(NULL == session_info_ || NULL == params_.allocator_ || NULL == schema_checker_)) {
     ret = OB_NOT_INIT;
     LOG_WARN("data member is not init", K(ret), K(session_info_), K(params_.allocator_), K(schema_checker_));
-  } else if (OB_UNLIKELY(parse_tree.type_ < T_SHOW_TABLES || parse_tree.type_ > T_SHOW_GRANTS) &&
+  } else if (OB_UNLIKELY(parse_tree.type_ < T_SHOW_TABLES || parse_tree.type_ > T_SHOW_QUERY_RESPONSE_TIME) &&
              (parse_tree.type_ != T_SHOW_TRIGGERS)) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("unexpected parse tree type", K(ret), K(parse_tree.type_));
@@ -1103,6 +1103,20 @@ int ObShowResolver::resolve(const ParseNode& parse_tree)
         }
         break;
       }
+      case T_SHOW_QUERY_RESPONSE_TIME: {
+        if (is_oracle_mode) {
+          ret = OB_NOT_SUPPORTED;
+          LOG_WARN("not support show engines in oracle mode", K(ret));
+        } else if (OB_UNLIKELY(parse_tree.num_child_ != 0)) {
+          ret = OB_ERR_UNEXPECTED;
+          LOG_WARN("parse tree is wrong", K(ret), K(parse_tree.num_child_));
+        } else {
+          show_resv_ctx.stmt_type_ = stmt::T_SHOW_QUERY_RESPONSE_TIME;
+          GEN_SQL_STEP_1(ObShowSqlSet::SHOW_QUERY_RESPONSE_TIME);
+          GEN_SQL_STEP_2(ObShowSqlSet::SHOW_QUERY_RESPONSE_TIME, OB_INFORMATION_SCHEMA_NAME, OB_QUERY_RESPONSE_TIME_TNAME);
+        }
+        break;
+      }
       case T_SHOW_RECYCLEBIN: {
         if (OB_UNLIKELY(parse_tree.num_child_ != 0)) {
           ret = OB_ERR_UNEXPECTED;
@@ -2067,6 +2081,8 @@ DEFINE_SHOW_CLAUSE_SET(SHOW_ENGINES, NULL, "SELECT * FROM %s.%s ", NULL, NULL);
 
 DEFINE_SHOW_CLAUSE_SET(SHOW_PRIVILEGES, NULL, "SELECT * FROM %s.%s ", "SELECT * FROM %s.%s ", NULL);
 
+DEFINE_SHOW_CLAUSE_SET(SHOW_QUERY_RESPONSE_TIME, NULL, "SELECT * FROM %s.%s ", NULL, NULL);
+
 DEFINE_SHOW_CLAUSE_SET(SHOW_COLLATION, NULL,
     "SELECT collation AS `Collation`, charset AS `Charset`, id AS `Id`, is_default AS `Default`, is_compiled AS "
     "`Compiled`, sortlen AS `Sortlen` FROM %s.%s ",

src/sql/resolver/cmd/ob_show_resolver.h

@@ -74,6 +74,7 @@ struct ObShowResolver::ObShowSqlSet {
   DECLARE_SHOW_CLAUSE_SET(SHOW_ENGINES);
   DECLARE_SHOW_CLAUSE_SET(SHOW_PRIVILEGES);
   DECLARE_SHOW_CLAUSE_SET(SHOW_GRANTS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_QUERY_RESPONSE_TIME);
   DECLARE_SHOW_CLAUSE_SET(SHOW_PROCESSLIST);
   DECLARE_SHOW_CLAUSE_SET(SHOW_FULL_PROCESSLIST);
   DECLARE_SHOW_CLAUSE_SET(SHOW_SYS_PROCESSLIST);

src/sql/resolver/ob_resolver.cpp

@@ -593,6 +593,7 @@ int ObResolver::resolve(IsPrepared if_prepared, const ParseNode& parse_tree, ObS
       case T_SHOW_CREATE_TABLEGROUP:
       case T_SHOW_TRIGGERS:
       case T_SHOW_RESTORE_PREVIEW:
+      case T_SHOW_QUERY_RESPONSE_TIME:
       case T_SHOW_STATUS: {
         REGISTER_STMT_RESOLVER(Show);
         break;

src/sql/resolver/ob_resolver_utils.cpp

@@ -397,6 +397,7 @@ stmt::StmtType ObResolverUtils::get_stmt_type_by_item_type(const ObItemType item
     SET_STMT_TYPE(T_CREATE_SAVEPOINT);
     SET_STMT_TYPE(T_RELEASE_SAVEPOINT);
     SET_STMT_TYPE(T_ROLLBACK_SAVEPOINT);
+    SET_STMT_TYPE(T_SHOW_QUERY_RESPONSE_TIME);
 #undef SET_STMT_TYPE
     case T_ROLLBACK:
     case T_COMMIT: {

src/sql/resolver/ob_stmt_type.h

@@ -235,6 +235,7 @@ OB_STMT_TYPE_DEF(T_BACKUP_BACKUPSET, get_sys_tenant_alter_system_priv, 228)
 OB_STMT_TYPE_DEF(T_BACKUP_ARCHIVELOG, get_sys_tenant_alter_system_priv, 229)
 OB_STMT_TYPE_DEF(T_ALTER_TRIGGER, no_priv_needed, 230)
 OB_STMT_TYPE_DEF(T_ALTER_USER_PRIMARY_ZONE, get_create_user_privs, 231)
+OB_STMT_TYPE_DEF(T_SHOW_QUERY_RESPONSE_TIME, err_stmt_type_priv, 232)
 
 OB_STMT_TYPE_DEF(T_ENABLE_SQL_THROTTLE, no_priv_needed, 250)
 OB_STMT_TYPE_DEF(T_DISABLE_SQL_THROTTLE, no_priv_needed, 251)

unittest/CMakeLists.txt

@@ -7,7 +7,7 @@ function(ob_unittest case)
   if (case MATCHES "^test_.*")
     add_test(${case} ${case})
   endif()
-  target_link_libraries(${case} PRIVATE oceanbase gtest gmock)
+  target_link_libraries(${case} PRIVATE oceanbase gtest gmock ${DEP_DIR}/lib/mariadb/libmariadb.so.3)
   disable_pch(${case})
   target_include_directories(${case}
     PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/unittest ${CMAKE_SOURCE_DIR}/deps/oblib/unittest ${DEP_DIR}/include)

unittest/observer/CMakeLists.txt

@@ -6,3 +6,4 @@ ob_unittest(test_token_calcer omt/test_token_calcer.cpp)
 ob_unittest(test_information_schema)
 ob_unittest(test_tableapi tableapi/test_tableapi.cpp)
 ob_unittest(test_hbaseapi hbaseapi/test_hfilter_parser.cpp)
+ob_unittest(test_query_response_time mysql/test_query_response_time.cpp)

unittest/observer/mysql/test_query_response_time.cpp

+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#include <gtest/gtest.h>
+#include "lib/utility/ob_test_util.h"
+#include "observer/mysql/ob_query_response_time.h"
+
+using namespace oceanbase::common;
+using namespace oceanbase::observer;
+
+class TestQueryRsponseTime: public ::testing::Test
+{
+public:
+  TestQueryRsponseTime();
+  virtual ~TestQueryRsponseTime();
+  virtual void SetUp();
+  virtual void TearDown();
+private:
+  // disallow copy
+  DISALLOW_COPY_AND_ASSIGN(TestQueryRsponseTime);
+protected:
+  // function members
+};
+
+TestQueryRsponseTime::TestQueryRsponseTime()
+{
+}
+
+TestQueryRsponseTime::~TestQueryRsponseTime()
+{
+}
+
+void TestQueryRsponseTime::SetUp()
+{
+}
+
+void TestQueryRsponseTime::TearDown()
+{
+}
+
+TEST_F(TestQueryRsponseTime, basic_test){
+    ObRSTTimeCollector time_collector;
+    time_collector.setup(10);
+    ASSERT_EQ(100,time_collector.bound(2));
+    ASSERT_EQ(13,time_collector.bound_count());
+    time_collector.collect(5);
+    time_collector.collect(50);
+    ASSERT_EQ(1,time_collector.count(1));
+    ASSERT_EQ(5,time_collector.total(1));
+    ASSERT_EQ(1,time_collector.count(2));
+    ASSERT_EQ(50,time_collector.total(2));
+    time_collector.flush();
+    ASSERT_EQ(0,time_collector.count(1));
+    ASSERT_EQ(0,time_collector.total(1));
+    ASSERT_EQ(0,time_collector.count(2));
+    ASSERT_EQ(0,time_collector.total(2));
+    time_collector.setup(100);
+    ASSERT_EQ(100,time_collector.bound(1));
+    ASSERT_EQ(7,time_collector.bound_count());
+    time_collector.collect(5);
+    time_collector.collect(50);
+    ASSERT_EQ(2,time_collector.count(1));
+    ASSERT_EQ(55,time_collector.total(1));
+    ASSERT_EQ(0,time_collector.count(2));
+    ASSERT_EQ(0,time_collector.total(2));
+}
+
+int main(int argc, char** argv)
+{
+  oceanbase::common::ObLogger::get_logger().set_log_level("INFO");
+  OB_LOGGER.set_log_level("INFO");
+  OB_LOGGER.set_file_name("test_ob_query_response_time.log", true);
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}