diff --git a/deps/oblib/src/lib/ob_define.h b/deps/oblib/src/lib/ob_define.h index c419f29d52..07b47a36b5 100644 --- a/deps/oblib/src/lib/ob_define.h +++ b/deps/oblib/src/lib/ob_define.h @@ -1973,6 +1973,10 @@ const int64_t OB_MAX_CONTEXT_VALUE_LENGTH = 4000; const int64_t OB_MAX_CONTEXT_CLIENT_IDENTIFIER_LENGTH = 65; const int64_t OB_MAX_CONTEXT_CLIENT_IDENTIFIER_LENGTH_IN_SESSION = 64; +// Resource limit calculator +const int64_t MAX_RESOURCE_NAME_LEN = 128; +const int64_t MAX_CONSTRAINT_NAME_LEN = 128; + // log row value options const char *const OB_LOG_ROW_VALUE_PARTIAL_LOB = "partial_lob"; const char *const OB_LOG_ROW_VALUE_PARTIAL_JSON = "partial_json"; diff --git a/deps/oblib/src/rpc/obrpc/ob_rpc_packet_list.h b/deps/oblib/src/rpc/obrpc/ob_rpc_packet_list.h index 997d34ec71..8e0e2045e1 100644 --- a/deps/oblib/src/rpc/obrpc/ob_rpc_packet_list.h +++ b/deps/oblib/src/rpc/obrpc/ob_rpc_packet_list.h @@ -1142,8 +1142,8 @@ PCODE_DEF(OB_TRIM_KEY_LIST, 0x1618) // PCODE_DEF(OB_GAIS_NEXT_SEQUENCE_REQUEST, 0x1621) // resource limit calculator -// PCODE_DEF(OB_CAL_UNIT_PHY_RESOURCE, 0x1622) -// PCODE_DEF(OB_CAL_STANDBY_TENANT_PHY_RESOURCE, 0x1623) +PCODE_DEF(OB_CAL_UNIT_PHY_RESOURCE, 0x1622) +PCODE_DEF(OB_CAL_STANDBY_TENANT_PHY_RESOURCE, 0x1623) //PCODE_DEF(OB_UPDATE_MVIEW_REFERENCE_TABLE_STATUS, 0x1624) diff --git a/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp b/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp index 6e1b5e2b7a..0e78ad71d2 100644 --- a/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp +++ b/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp @@ -1694,6 +1694,34 @@ TEST_F(TestTenantMetaMemMgr, test_tablet_gc_queue) ASSERT_TRUE(gc_queue.is_empty()); } +TEST_F(TestTenantMetaMemMgr, test_show_limit) +{ + auto *calculator = MTL(ObTenantMetaMemMgr*)->get_t3m_limit_calculator(); + ASSERT_NE(nullptr, calculator); + + const int64_t DEFAULT_TABLET_CNT_PER_GB = ObTenantMetaMemMgr::DEFAULT_TABLET_CNT_PER_GB; + + const int64_t before_tenant_mem = lib::get_tenant_memory_limit(MTL_ID()); + const int64_t this_case_tenant_mem = 1 * 1024 * 1024 * 1024; /* 1GB */ + lib::set_tenant_memory_limit(MTL_ID(), this_case_tenant_mem); + + omt::ObTenantConfigGuard tenant_config(TENANT_CONF(MTL_ID())); + const int64_t config_tablet_per_gb = tenant_config.is_valid() ? + tenant_config->_max_tablet_cnt_per_gb : + DEFAULT_TABLET_CNT_PER_GB; + + share::ObResoureConstraintValue result; + ASSERT_EQ(OB_SUCCESS, calculator->get_resource_constraint_value(result)); + int64_t config_res = 0; + result.get_type_value(CONFIGURATION_CONSTRAINT, config_res); + int64_t memory_res = 0; + result.get_type_value(MEMORY_CONSTRAINT, memory_res); + ASSERT_EQ(20000, config_res); + ASSERT_EQ(20480, memory_res); + + lib::set_tenant_memory_limit(MTL_ID(), before_tenant_mem); +} + } // end namespace storage } // end namespace oceanbase diff --git a/src/observer/CMakeLists.txt b/src/observer/CMakeLists.txt index 9097e6c5e5..00dfc00e97 100644 --- a/src/observer/CMakeLists.txt +++ b/src/observer/CMakeLists.txt @@ -408,6 +408,8 @@ ob_set_subtarget(ob_server virtual_table virtual_table/ob_all_virtual_cgroup_config.cpp virtual_table/ob_virtual_flt_config.cpp virtual_table/ob_all_virtual_kv_connection.cpp + virtual_table/ob_all_virtual_tenant_resource_limit.cpp + virtual_table/ob_all_virtual_tenant_resource_limit_detail.cpp virtual_table/ob_all_virtual_activity_metrics.cpp virtual_table/ob_all_virtual_checkpoint_diagnose_info.cpp virtual_table/ob_all_virtual_checkpoint_diagnose_memtable_info.cpp diff --git a/src/observer/ob_rpc_processor_simple.cpp b/src/observer/ob_rpc_processor_simple.cpp index 8af9c7f442..7d69d22ecb 100644 --- a/src/observer/ob_rpc_processor_simple.cpp +++ b/src/observer/ob_rpc_processor_simple.cpp @@ -51,6 +51,7 @@ #include "storage/tx/ob_trans_service.h" #include "storage/ob_tablet_autoinc_seq_rpc_handler.h" #include "share/ob_tablet_autoincrement_service.h" +#include "share/resource_limit_calculator/ob_resource_limit_calculator.h"//ObUserResourceCalculateArg #include "share/sequence/ob_sequence_cache.h" #include "logservice/ob_log_service.h" #include "logservice/ob_log_handler.h" @@ -2675,6 +2676,30 @@ int ObRpcGetLSSyncScnP::process() return ret; } +int ObRpcGetTenantResP::process() +{ + int ret = OB_SUCCESS; + ObResourceLimitCalculator *cal = nullptr; + ObUserResourceCalculateArg res_arg; + const uint64_t tenant_id = arg_.get_tenant_id(); + if (OB_UNLIKELY(tenant_id != MTL_ID())) { + ret = OB_ERR_UNEXPECTED; + LOG_ERROR("ObRpcStartTransferTaskP::process tenant not match", KR(ret), K_(arg)); + } else if (OB_UNLIKELY(!arg_.is_valid())) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid arg", KR(ret), K_(arg)); + } else if (OB_ISNULL(cal = MTL(ObResourceLimitCalculator*))) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("cal is null", KR(ret), K_(arg)); + } else if (OB_FAIL(cal->get_tenant_logical_resource(res_arg))) { + LOG_WARN("failed to get tenant logical resource", KR(ret), K_(arg)); + } else if (OB_FAIL(result_.init(GCTX.self_addr(), res_arg))) { + LOG_WARN("failed to init result", KR(ret), K(res_arg)); + } + return ret; + +} + int ObForceSetLSAsSingleReplicaP::process() { int ret = OB_SUCCESS; @@ -3172,5 +3197,15 @@ int ObForceDumpServerUsageP::process() } else {} return ret; } + +int ObResourceLimitCalculatorP::process() +{ + int ret = OB_SUCCESS; + if (OB_FAIL(MTL(ObResourceLimitCalculator *)->get_tenant_min_phy_resource_value(result_))) { + LOG_WARN("get physical resource needed by unit failed", K(ret)); + } + return ret; +} + } // end of namespace observer } // end of namespace oceanbase diff --git a/src/observer/ob_rpc_processor_simple.h b/src/observer/ob_rpc_processor_simple.h index b4d4f2f6c2..6ada68d4d0 100644 --- a/src/observer/ob_rpc_processor_simple.h +++ b/src/observer/ob_rpc_processor_simple.h @@ -237,6 +237,7 @@ OB_DEFINE_PROCESSOR_S(Srv, OB_CHECK_BACKUP_DEST_CONNECTIVITY, ObRpcCheckBackupDe OB_DEFINE_PROCESSOR_S(Srv, OB_GET_LS_ACCESS_MODE, ObRpcGetLSAccessModeP); OB_DEFINE_PROCESSOR_S(Srv, OB_CHANGE_LS_ACCESS_MODE, ObRpcChangeLSAccessModeP); OB_DEFINE_PROCESSOR_S(Srv, OB_GET_LS_SYNC_SCN, ObRpcGetLSSyncScnP); +OB_DEFINE_PROCESSOR_S(Srv, OB_CAL_STANDBY_TENANT_PHY_RESOURCE, ObRpcGetTenantResP); OB_DEFINE_PROCESSOR_S(Srv, OB_LOG_FORCE_SET_LS_AS_SINGLE_REPLICA, ObForceSetLSAsSingleReplicaP); #ifdef OB_BUILD_SPM OB_DEFINE_PROCESSOR_S(Srv, OB_SERVER_ACCEPT_PLAN_BASELINE, ObServerAcceptPlanBaselineP); @@ -272,6 +273,7 @@ OB_DEFINE_PROCESSOR_S(Srv, OB_TABLET_LOCATION_BROADCAST, ObTabletLocationReceive OB_DEFINE_PROCESSOR_S(Srv, OB_CANCEL_GATHER_STATS, ObCancelGatherStatsP); OB_DEFINE_PROCESSOR_OBADMIN(Srv, OB_LOG_FORCE_SET_TENANT_LOG_DISK, ObForceSetTenantLogDiskP); OB_DEFINE_PROCESSOR_OBADMIN(Srv, OB_FORCE_DUMP_SERVER_USAGE, ObForceDumpServerUsageP); +OB_DEFINE_PROCESSOR_S(Srv, OB_CAL_UNIT_PHY_RESOURCE, ObResourceLimitCalculatorP); OB_DEFINE_PROCESSOR_S(Srv, OB_CHECK_AND_CANCEL_DDL_COMPLEMENT_DAG, ObRpcCheckandCancelDDLComplementDagP); OB_DEFINE_PROCESSOR_S(Srv, OB_KILL_CLIENT_SESSION, ObKillClientSessionP); diff --git a/src/observer/ob_srv_xlator_partition.cpp b/src/observer/ob_srv_xlator_partition.cpp index 51b5f82548..57d97c1bbb 100644 --- a/src/observer/ob_srv_xlator_partition.cpp +++ b/src/observer/ob_srv_xlator_partition.cpp @@ -298,6 +298,7 @@ void oceanbase::observer::init_srv_xlator_for_others(ObSrvRpcXlator *xlator) { RPC_PROCESSOR(ObNetEndpointRegisterP, gctx_); RPC_PROCESSOR(ObNetEndpointPredictIngressP, gctx_); RPC_PROCESSOR(ObNetEndpointSetIngressP, gctx_); + RPC_PROCESSOR(ObRpcGetTenantResP, gctx_); // session info verification RPC_PROCESSOR(ObSessInfoVerificationP, gctx_); @@ -316,6 +317,8 @@ void oceanbase::observer::init_srv_xlator_for_others(ObSrvRpcXlator *xlator) { RPC_PROCESSOR(ObKillClientSessionP, gctx_); // client session create time RPC_PROCESSOR(ObClientSessionConnectTimeP, gctx_); + // limit calculator + RPC_PROCESSOR(ObResourceLimitCalculatorP, gctx_); // ddl RPC_PROCESSOR(ObRpcCheckandCancelDDLComplementDagP, gctx_); diff --git a/src/observer/omt/ob_multi_tenant.cpp b/src/observer/omt/ob_multi_tenant.cpp index 57f5ea94a1..f3d3593119 100644 --- a/src/observer/omt/ob_multi_tenant.cpp +++ b/src/observer/omt/ob_multi_tenant.cpp @@ -161,6 +161,7 @@ #include "storage/tenant_snapshot/ob_tenant_snapshot_service.h" #include "share/index_usage/ob_index_usage_info_mgr.h" #include "rootserver/mview/ob_mview_maintenance_service.h" +#include "share/resource_limit_calculator/ob_resource_limit_calculator.h" #include "storage/checkpoint/ob_checkpoint_diagnose.h" using namespace oceanbase; @@ -575,6 +576,7 @@ int ObMultiTenant::init(ObAddr myaddr, MTL_BIND2(mtl_new_default, ObIndexUsageInfoMgr::mtl_init, mtl_start_default, mtl_stop_default, mtl_wait_default, mtl_destroy_default); MTL_BIND2(mtl_new_default, storage::ObTabletMemtableMgrPool::mtl_init, nullptr, nullptr, nullptr, mtl_destroy_default); MTL_BIND2(mtl_new_default, rootserver::ObMViewMaintenanceService::mtl_init, mtl_start_default, mtl_stop_default, mtl_wait_default, mtl_destroy_default); + MTL_BIND2(mtl_new_default, ObResourceLimitCalculator::mtl_init, nullptr, nullptr, nullptr, mtl_destroy_default); MTL_BIND2(mtl_new_default, ObCheckpointDiagnoseMgr::mtl_init, nullptr, nullptr, nullptr, mtl_destroy_default); #ifdef OB_BUILD_DBLINK MTL_BIND2(common::sqlclient::ObTenantDblinkKeeper::mtl_new, common::sqlclient::ObTenantDblinkKeeper::mtl_init, nullptr, nullptr, nullptr, common::sqlclient::ObTenantDblinkKeeper::mtl_destroy); diff --git a/src/observer/virtual_table/ob_all_virtual_tenant_resource_limit.cpp b/src/observer/virtual_table/ob_all_virtual_tenant_resource_limit.cpp new file mode 100644 index 0000000000..c172d20906 --- /dev/null +++ b/src/observer/virtual_table/ob_all_virtual_tenant_resource_limit.cpp @@ -0,0 +1,162 @@ +/** + * Copyright (c) 2024 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. + */ + +#define USING_LOG_PREFIX SERVER + +#include "observer/virtual_table/ob_all_virtual_tenant_resource_limit.h" +#include "share/resource_limit_calculator/ob_resource_limit_calculator.h" + +using namespace oceanbase::common; +using namespace oceanbase::storage; +using namespace oceanbase::share; +namespace oceanbase +{ +namespace observer +{ + +ObResourceLimitTable::ObResourceLimitTable() + : ObVirtualTableScannerIterator(), + addr_(), + iter_() +{ +} + +ObResourceLimitTable::~ObResourceLimitTable() +{ + reset(); +} + +void ObResourceLimitTable::reset() +{ + // Note that cross-tenant resources must be released by ObMultiTenantOperator, it should be called at first. + omt::ObMultiTenantOperator::reset(); + addr_.reset(); + ObVirtualTableScannerIterator::reset(); +} + +int ObResourceLimitTable::set_addr(common::ObAddr &addr) +{ + int ret = OB_SUCCESS; + addr_ = addr; + if (!addr_.ip_to_string(ip_buf_, sizeof(ip_buf_))) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("get ip buffer failed", K(ret), K(addr_)); + } + return ret; +} + +void ObResourceLimitTable::release_last_tenant() +{ + iter_.reset(); +} + +int ObResourceLimitTable::inner_get_next_row(ObNewRow *&row) +{ + int ret = OB_SUCCESS; + if (OB_FAIL(execute(row))) { + LOG_WARN("execute fail", K(ret)); + } + return ret; +} + +bool ObResourceLimitTable::is_need_process(uint64_t tenant_id) +{ + if (is_sys_tenant(effective_tenant_id_) || tenant_id == effective_tenant_id_) { + return true; + } + return false; +} + +int ObResourceLimitTable::get_next_resource_info_(ObResourceInfo &info) +{ + int ret = OB_SUCCESS; + if (!iter_.is_ready() + && OB_FAIL(iter_.set_ready())) { + LOG_WARN("iterator is not ready", K(ret)); + } else if (OB_FAIL(iter_.get_next(info))) { + if (OB_ITER_END != ret) { + LOG_WARN("get next resource info failed", K(ret)); + } + } + return ret; +} + +int ObResourceLimitTable::process_curr_tenant(ObNewRow *&row) +{ + int ret = OB_SUCCESS; + ObResourceInfo info; + if (NULL == allocator_) { + ret = OB_NOT_INIT; + LOG_WARN("allocator_ shouldn't be NULL", K(allocator_), K(ret)); + } else if (FALSE_IT(start_to_read_ = true)) { + } else if (OB_FAIL(get_next_resource_info_(info))) { + if (OB_ITER_END != ret) { + LOG_WARN("get_next_resource_info failed", K(ret)); + } + } else { + const int64_t col_count = output_column_ids_.count(); + for (int64_t i = 0; OB_SUCC(ret) && i < col_count; ++i) { + uint64_t col_id = output_column_ids_.at(i); + switch (col_id) { + case SVR_IP: + cur_row_.cells_[i].set_varchar(ip_buf_); + cur_row_.cells_[i].set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset())); + break; + case SVR_PORT: + cur_row_.cells_[i].set_int(addr_.get_port()); + break; + case TENANT_ID: + cur_row_.cells_[i].set_int(MTL_ID()); + break; + case ZONE: + cur_row_.cells_[i].set_varchar(GCONF.zone); + cur_row_.cells_[i].set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset())); + break; + case RESOURCE_NAME: { + cur_row_.cells_[i].set_varchar(get_logic_res_type_name(iter_.get_curr_type())); + cur_row_.cells_[i].set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset())); + break; + } + case CURRENT_UTILIZATION: { + cur_row_.cells_[i].set_int(info.curr_utilization_); + break; + } + case MAX_UTILIZATION: + cur_row_.cells_[i].set_int(info.max_utilization_); + break; + case RSERVED_VALUE: + cur_row_.cells_[i].set_int(info.reserved_value_); + break; + case LIMIT_VALUE: + cur_row_.cells_[i].set_int(info.min_constraint_value_); + break; + case EFFECTIVE_LIMIT_TYPE: + cur_row_.cells_[i].set_varchar(get_constraint_type_name(info.min_constraint_type_)); + cur_row_.cells_[i].set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset())); + break; + default: + ret = OB_ERR_UNEXPECTED; + LOG_WARN("invalid col_id", K(ret), K(col_id)); + break; + } + } + } + if (OB_SUCC(ret)) { + row = &cur_row_; + } + return ret; +} + + + +} // end namespace observer +} // end namespace oceanbase diff --git a/src/observer/virtual_table/ob_all_virtual_tenant_resource_limit.h b/src/observer/virtual_table/ob_all_virtual_tenant_resource_limit.h new file mode 100644 index 0000000000..bf645ca235 --- /dev/null +++ b/src/observer/virtual_table/ob_all_virtual_tenant_resource_limit.h @@ -0,0 +1,68 @@ +/** + * Copyright (c) 2024 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_ALL_VIRTUAL_OB_TENANT_RESOURCE_LIMIT_H_ +#define OB_ALL_VIRTUAL_OB_TENANT_RESOURCE_LIMIT_H_ + +#include "observer/omt/ob_multi_tenant_operator.h" +#include "share/ob_virtual_table_scanner_iterator.h" +#include "share/resource_limit_calculator/ob_resource_limit_calculator.h" + +namespace oceanbase +{ +namespace share +{ +class ObResourceInfo; +} + +namespace observer +{ +class ObResourceLimitTable : public common::ObVirtualTableScannerIterator, + public omt::ObMultiTenantOperator +{ +public: + ObResourceLimitTable(); + virtual ~ObResourceLimitTable(); +public: + virtual int inner_get_next_row(common::ObNewRow *&row); + virtual void reset(); + int set_addr(common::ObAddr &addr); + enum COLUMN_NAME + { + SVR_IP = common::OB_APP_MIN_COLUMN_ID, + SVR_PORT, + TENANT_ID, + ZONE, + RESOURCE_NAME, + CURRENT_UTILIZATION, + MAX_UTILIZATION, + RSERVED_VALUE, + LIMIT_VALUE, + EFFECTIVE_LIMIT_TYPE + }; +private: + virtual bool is_need_process(uint64_t tenant_id) override; + virtual int process_curr_tenant(common::ObNewRow *&row) override; + virtual void release_last_tenant() override; + int get_next_resource_info_(share::ObResourceInfo &info); +private: + common::ObAddr addr_; + char ip_buf_[common::OB_IP_STR_BUFF]; + share::ObLogicResourceStatIterator iter_; +private: + DISALLOW_COPY_AND_ASSIGN(ObResourceLimitTable); +}; + +} // end namespace observer +} // end namespace oceanbase + +#endif diff --git a/src/observer/virtual_table/ob_all_virtual_tenant_resource_limit_detail.cpp b/src/observer/virtual_table/ob_all_virtual_tenant_resource_limit_detail.cpp new file mode 100644 index 0000000000..c4e154cf73 --- /dev/null +++ b/src/observer/virtual_table/ob_all_virtual_tenant_resource_limit_detail.cpp @@ -0,0 +1,169 @@ +/** + * Copyright (c) 2024 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. + */ + +#define USING_LOG_PREFIX SERVER + +#include "observer/virtual_table/ob_all_virtual_tenant_resource_limit_detail.h" +#include "share/resource_limit_calculator/ob_resource_limit_calculator.h" + +using namespace oceanbase::common; +using namespace oceanbase::storage; +using namespace oceanbase::share; +namespace oceanbase +{ +namespace observer +{ + +ObResourceLimitDetailTable::ObResourceLimitDetailTable() + : ObVirtualTableScannerIterator(), + addr_(), + iter_(), + constraint_iter_() +{ +} + +ObResourceLimitDetailTable::~ObResourceLimitDetailTable() +{ + reset(); +} + +void ObResourceLimitDetailTable::reset() +{ + // Note that cross-tenant resources must be released by ObMultiTenantOperator, it should be called at first. + omt::ObMultiTenantOperator::reset(); + addr_.reset(); + ObVirtualTableScannerIterator::reset(); +} + +int ObResourceLimitDetailTable::set_addr(common::ObAddr &addr) +{ + int ret = OB_SUCCESS; + addr_ = addr; + if (!addr_.ip_to_string(ip_buf_, sizeof(ip_buf_))) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("get ip buffer failed", K(ret), K(addr_)); + } + return ret; +} + +void ObResourceLimitDetailTable::release_last_tenant() +{ + constraint_iter_.reset(); + iter_.reset(); +} + +int ObResourceLimitDetailTable::inner_get_next_row(ObNewRow *&row) +{ + int ret = OB_SUCCESS; + if (OB_FAIL(execute(row))) { + LOG_WARN("execute fail", K(ret)); + } + return ret; +} + +bool ObResourceLimitDetailTable::is_need_process(uint64_t tenant_id) +{ + if (is_sys_tenant(effective_tenant_id_) || tenant_id == effective_tenant_id_) { + return true; + } + return false; +} + +int ObResourceLimitDetailTable::get_next_resource_limit_val_(int64_t &val) +{ + int ret = OB_SUCCESS; + bool iter_next_res = false; + while (OB_SUCC(ret)) { + if (!iter_.is_ready() + && OB_FAIL(iter_.set_ready())) { + LOG_WARN("iterator is not ready", K(ret)); + } else if ((iter_.get_curr_type() == 0 || iter_next_res) + && OB_FAIL(iter_.get_next_type())) { + if (OB_ITER_END != ret) { + LOG_WARN("get next resource type failed", K(ret), K(iter_.get_curr_type())); + } + } else if (!constraint_iter_.is_ready() + && OB_FAIL(constraint_iter_.set_ready(iter_.get_curr_type()))) { + LOG_WARN("constraint iterator is not ready", K(ret), K(iter_.get_curr_type())); + } else if (OB_FAIL(constraint_iter_.get_next(val))) { + if (OB_ITER_END != ret) { + LOG_WARN("get next constraint value failed", K(ret), K(constraint_iter_.get_curr_type())); + } else { + // iter next resource + constraint_iter_.reset(); + iter_next_res = true; + ret = OB_SUCCESS; + } + } else { + // get succeed + break; + } + } + return ret; +} + +int ObResourceLimitDetailTable::process_curr_tenant(ObNewRow *&row) +{ + int ret = OB_SUCCESS; + int64_t limit_value; + if (NULL == allocator_) { + ret = OB_NOT_INIT; + LOG_WARN("allocator_ shouldn't be NULL", K(allocator_), K(ret)); + } else if (FALSE_IT(start_to_read_ = true)) { + } else if (OB_FAIL(get_next_resource_limit_val_(limit_value))) { + if (OB_ITER_END != ret) { + LOG_WARN("get_next_resource_info failed", K(ret)); + } + } else { + const int64_t col_count = output_column_ids_.count(); + for (int64_t i = 0; OB_SUCC(ret) && i < col_count; ++i) { + uint64_t col_id = output_column_ids_.at(i); + switch (col_id) { + case SVR_IP: + cur_row_.cells_[i].set_varchar(ip_buf_); + cur_row_.cells_[i].set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset())); + break; + case SVR_PORT: + cur_row_.cells_[i].set_int(addr_.get_port()); + break; + case TENANT_ID: + cur_row_.cells_[i].set_int(MTL_ID()); + break; + case RESOURCE_NAME: { + cur_row_.cells_[i].set_varchar(get_logic_res_type_name(iter_.get_curr_type())); + cur_row_.cells_[i].set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset())); + break; + } + case LIMIT_TYPE: + cur_row_.cells_[i].set_varchar(get_constraint_type_name(constraint_iter_.get_curr_type())); + cur_row_.cells_[i].set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset())); + break; + case LIMIT_VALUE: + cur_row_.cells_[i].set_int(limit_value); + break; + default: + ret = OB_ERR_UNEXPECTED; + LOG_WARN("invalid col_id", K(ret), K(col_id)); + break; + } + } + } + if (OB_SUCC(ret)) { + row = &cur_row_; + } + return ret; +} + + + +} // end namespace observer +} // end namespace oceanbase diff --git a/src/observer/virtual_table/ob_all_virtual_tenant_resource_limit_detail.h b/src/observer/virtual_table/ob_all_virtual_tenant_resource_limit_detail.h new file mode 100644 index 0000000000..7b2d9d93a7 --- /dev/null +++ b/src/observer/virtual_table/ob_all_virtual_tenant_resource_limit_detail.h @@ -0,0 +1,66 @@ +/** + * Copyright (c) 2024 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_ALL_VIRTUAL_OB_TENANT_RESOURCE_LIMIT_DETAIL_H_ +#define OB_ALL_VIRTUAL_OB_TENANT_RESOURCE_LIMIT_DETAIL_H_ + +#include "observer/omt/ob_multi_tenant_operator.h" +#include "share/ob_virtual_table_scanner_iterator.h" +#include "share/resource_limit_calculator/ob_resource_limit_calculator.h" + +namespace oceanbase +{ +namespace share +{ +class ObResourceInfo; +} + +namespace observer +{ +class ObResourceLimitDetailTable + : public common::ObVirtualTableScannerIterator, + public omt::ObMultiTenantOperator +{ +public: + ObResourceLimitDetailTable(); + virtual ~ObResourceLimitDetailTable(); +public: + virtual int inner_get_next_row(common::ObNewRow *&row); + virtual void reset(); + int set_addr(common::ObAddr &addr); + enum COLUMN_NAME + { + SVR_IP = common::OB_APP_MIN_COLUMN_ID, + SVR_PORT, + TENANT_ID, + RESOURCE_NAME, + LIMIT_TYPE, + LIMIT_VALUE, + }; +private: + virtual bool is_need_process(uint64_t tenant_id) override; + virtual int process_curr_tenant(common::ObNewRow *&row) override; + virtual void release_last_tenant() override; + int get_next_resource_limit_val_(int64_t &val); +private: + common::ObAddr addr_; + char ip_buf_[common::OB_IP_STR_BUFF]; + share::ObLogicResourceStatIterator iter_; + share::ObResourceConstraintIterator constraint_iter_; +private: + DISALLOW_COPY_AND_ASSIGN(ObResourceLimitDetailTable); +}; + +} // end namespace observer +} // end namespace oceanbase + +#endif diff --git a/src/observer/virtual_table/ob_virtual_table_iterator_factory.cpp b/src/observer/virtual_table/ob_virtual_table_iterator_factory.cpp index b82c65ae75..476eba5922 100644 --- a/src/observer/virtual_table/ob_virtual_table_iterator_factory.cpp +++ b/src/observer/virtual_table/ob_virtual_table_iterator_factory.cpp @@ -224,6 +224,8 @@ #include "observer/virtual_table/ob_tenant_show_restore_preview.h" #include "observer/virtual_table/ob_all_virtual_kv_connection.h" #include "observer/virtual_table/ob_tenant_show_restore_preview.h" +#include "observer/virtual_table/ob_all_virtual_tenant_resource_limit.h" +#include "observer/virtual_table/ob_all_virtual_tenant_resource_limit_detail.h" #include "observer/virtual_table/ob_all_virtual_tracepoint_info.h" #include "observer/virtual_table/ob_all_virtual_nic_info.h" #include "observer/virtual_table/ob_all_virtual_sys_variable_default_value.h" @@ -2631,6 +2633,30 @@ int ObVTIterCreator::create_vt_iter(ObVTableScanParam ¶ms, } break; } + case OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_TID: { + ObResourceLimitTable *all_virtual_resource_limit = NULL; + if (OB_SUCC(NEW_VIRTUAL_TABLE(ObResourceLimitTable, + all_virtual_resource_limit))) { + vt_iter = static_cast(all_virtual_resource_limit); + if (OB_FAIL(all_virtual_resource_limit->set_addr(addr_))) + { + LOG_WARN("set addr failed", K(ret), K(addr_)); + } + } + break; + } + case OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_TID: { + ObResourceLimitDetailTable *all_virtual_resource_limit_detail = NULL; + if (OB_SUCC(NEW_VIRTUAL_TABLE(ObResourceLimitDetailTable, + all_virtual_resource_limit_detail))) { + vt_iter = static_cast(all_virtual_resource_limit_detail); + if (OB_FAIL(all_virtual_resource_limit_detail->set_addr(addr_))) + { + LOG_WARN("set addr failed", K(ret), K(addr_)); + } + } + break; + } case OB_ALL_VIRTUAL_DATA_ACTIVITY_METRICS_TID: { ObAllVirtualActivityMetric *all_virtual_activity_metrics = NULL; if (OB_FAIL(NEW_VIRTUAL_TABLE(ObAllVirtualActivityMetric, all_virtual_activity_metrics))) { diff --git a/src/pl/CMakeLists.txt b/src/pl/CMakeLists.txt index ac0220798d..b9afdc0375 100644 --- a/src/pl/CMakeLists.txt +++ b/src/pl/CMakeLists.txt @@ -58,6 +58,7 @@ ob_set_subtarget(ob_pl sys_package sys_package/ob_dbms_workload_repository.cpp sys_package/ob_pl_dbms_resource_manager.cpp sys_package/ob_pl_dbms_trusted_certificate_manager.cpp + sys_package/ob_dbms_limit_calculator_mysql.cpp ) ob_set_subtarget(ob_pl dblink diff --git a/src/pl/ob_pl_interface_pragma.h b/src/pl/ob_pl_interface_pragma.h index e221c06ab5..da614c5e67 100644 --- a/src/pl/ob_pl_interface_pragma.h +++ b/src/pl/ob_pl_interface_pragma.h @@ -70,6 +70,7 @@ #include "pl/sys_package/ob_dbms_mview_mysql.h" #include "pl/sys_package/ob_dbms_mview_stats_mysql.h" #include "pl/sys_package/ob_pl_dbms_trusted_certificate_manager.h" +#include "pl/sys_package/ob_dbms_limit_calculator_mysql.h" #ifdef INTERFACE_DEF INTERFACE_DEF(INTERFACE_START, "TEST", (ObPLInterfaceImpl::call)) @@ -757,6 +758,13 @@ INTERFACE_DEF(INTERFACE_DBMS_DELETE_TRUSTED_CERTIFICATE, "DELETE_TRUSTED_CERTIFICATE", (ObPlDBMSTrustedCertificateManager::delete_trusted_certificate)) INTERFACE_DEF(INTERFACE_DBMS_UPDATE_TRUSTED_CERTIFICATE, "UPDATE_TRUSTED_CERTIFICATE", (ObPlDBMSTrustedCertificateManager::update_trusted_certificate)) // end of end of dbms_workload_repository + + // start of dbms_ob_limit_calculator + INTERFACE_DEF(INTERFACE_DBMS_OB_LIMIT_CALCULATOR_PHY_RES_CALCULATE_BY_LOGIC_RES, "PHY_RES_CALCULATE_BY_LOGIC_RES", (ObDBMSLimitCalculator::phy_res_calculate_by_logic_res)) + INTERFACE_DEF(INTERFACE_DBMS_OB_LIMIT_CALCULATOR_PHY_RES_CALCULATE_BY_UNIT, "PHY_RES_CALCULATE_BY_UNIT", (ObDBMSLimitCalculator::phy_res_calculate_by_unit)) + INTERFACE_DEF(INTERFACE_DBMS_OB_LIMIT_CALCULATOR_PHY_RES_CALCULATE_BY_STADNBY_TENANT, "PHY_RES_CALCULATE_BY_STANDBY_TENANT", (ObDBMSLimitCalculator::phy_res_calculate_by_standby_tenant)) + // end of dbms_ob_limit_calculator + INTERFACE_DEF(INTERFACE_END, "INVALID", (nullptr)) #endif diff --git a/src/pl/ob_pl_package_manager.cpp b/src/pl/ob_pl_package_manager.cpp index a871b7d0fe..a9de39d0e4 100644 --- a/src/pl/ob_pl_package_manager.cpp +++ b/src/pl/ob_pl_package_manager.cpp @@ -282,7 +282,8 @@ static ObSysPackageFile mysql_sys_package_file_table[] = { {"dbms_workload_repository", "dbms_workload_repository_mysql.sql", "dbms_workload_repository_body_mysql.sql"}, {"dbms_mview", "dbms_mview_mysql.sql", "dbms_mview_body_mysql.sql"}, {"dbms_mview_stats", "dbms_mview_stats_mysql.sql", "dbms_mview_stats_body_mysql.sql"}, - {"dbms_trusted_certificate_manager", "dbms_trusted_certificate_manager_mysql.sql", "dbms_trusted_certificate_manager_body_mysql.sql"} + {"dbms_trusted_certificate_manager", "dbms_trusted_certificate_manager_mysql.sql", "dbms_trusted_certificate_manager_body_mysql.sql"}, + {"dbms_ob_limit_calculator", "dbms_ob_limit_calculator_mysql.sql", "dbms_ob_limit_calculator_body_mysql.sql"} }; int ObPLPackageManager::load_sys_package(ObMySQLProxy &sql_proxy, ObString &package_name, ObCompatibilityMode compa_mode) diff --git a/src/pl/sys_package/ob_dbms_limit_calculator_mysql.cpp b/src/pl/sys_package/ob_dbms_limit_calculator_mysql.cpp new file mode 100644 index 0000000000..7a4cff27ab --- /dev/null +++ b/src/pl/sys_package/ob_dbms_limit_calculator_mysql.cpp @@ -0,0 +1,638 @@ +/** + * Copyright (c) 2024 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. + */ + +#define USING_LOG_PREFIX PL +#include "ob_dbms_limit_calculator_mysql.h" +#include "share/ob_errno.h" +#include "lib/utility/ob_macro_utils.h" +#include "lib/utility/utility.h" +#include "share/inner_table/ob_inner_table_schema_constants.h" +#include "share/resource_limit_calculator/ob_resource_limit_calculator.h" +#include "share/ob_unit_table_operator.h" +#include "share/ob_all_server_tracer.h" +#include "share/ob_rpc_struct.h" +#include "rootserver/ob_rs_async_rpc_proxy.h"//ObGetTenantResProxy +#include "share/ls/ob_ls_status_operator.h"//ObLSStatusOperator +#include "share/balance/ob_balance_job_table_operator.h"//balance_job +#include "rootserver/ob_tenant_balance_service.h"//gather_stat_primary_zone_num_and_units + +using namespace oceanbase::common; +using namespace oceanbase::share; +using namespace oceanbase::pl; +using namespace oceanbase::sql; + + +namespace oceanbase +{ +namespace pl +{ +int ObDBMSLimitCalculator::phy_res_calculate_by_logic_res( + sql::ObExecContext &ctx, + sql::ParamStore ¶ms, + common::ObObj &result) +{ + int ret = OB_SUCCESS; + const int64_t MAX_RES_LEN = 512; + char* ptr = NULL; + int64_t pos = 0; + ObString str_arg; + ObUserResourceCalculateArg arg; + ObMinPhyResourceResult res; + const int64_t curr_tenant_id = MTL_ID(); + if (!is_sys_tenant(curr_tenant_id)) { + ret = OB_OP_NOT_ALLOW; + LOG_WARN("only sys tenant can do this", K(ret), K(curr_tenant_id)); + LOG_USER_ERROR(OB_OP_NOT_ALLOW, "Only sys tenant can do this. Operator is"); + } else if (OB_UNLIKELY(2 > params.count())) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("params not valid", KR(ret), K(params)); + } else if (OB_FAIL(params.at(0).get_varchar(str_arg))) { + LOG_WARN("get parameter failed", K(ret)); + } else if (str_arg.empty()) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid argument", K(ret), K(str_arg)); + } else if (OB_ISNULL(ptr = static_cast(ctx.get_allocator().alloc(MAX_RES_LEN)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("allocate memory failed", K(ret), K(MAX_RES_LEN)); + } else if (OB_FAIL(parse_dict_like_args_(to_cstring(str_arg), arg))) { + LOG_WARN("parse argument failed", K(ret)); + } else if (OB_FAIL(MTL(ObResourceLimitCalculator *)->get_tenant_min_phy_resource_value(arg, res))) { + LOG_WARN("get tenant min physical resource needed failed", K(ret)); + } else if (OB_FAIL(get_json_result_(res, ptr, MAX_RES_LEN, pos))) { + LOG_WARN("get json result failed", K(ret), K(res), K(pos)); + } else { + params.at(1).set_varchar(ptr, pos); + LOG_INFO("phy_res_calculate_by_logic_res success", K(arg), K(res), + K(str_arg), K(params.at(0).get_varchar()), K(params.at(1).get_varchar())); + } + return ret; +} + +int ObDBMSLimitCalculator::phy_res_calculate_by_unit( + sql::ObExecContext &ctx, + sql::ParamStore ¶ms, + common::ObObj &result) +{ + int ret = OB_SUCCESS; + ObAddr addr; + int64_t tenant_id = 0; + ObString addr_str; + const int64_t MAX_RES_LEN = 2048; + ObMinPhyResourceResult res; + char* ptr = NULL; + int64_t pos = 0; + int64_t timeout = -1; + const int64_t curr_tenant_id = MTL_ID(); + if (!is_sys_tenant(curr_tenant_id)) { + ret = OB_OP_NOT_ALLOW; + LOG_WARN("only sys tenant can do this", K(ret), K(curr_tenant_id)); + LOG_USER_ERROR(OB_OP_NOT_ALLOW, "Only sys tenant can do this. Operator is"); + } else if (OB_UNLIKELY(3 > params.count())) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("params not valid", KR(ret), K(params)); + } else if (FALSE_IT(tenant_id = params.at(0).get_int())) { + } else if (FALSE_IT(addr_str = params.at(1).get_varchar())) { + } else if (OB_FAIL(addr.parse_from_string(addr_str))) { + LOG_WARN("parse address failed", K(ret), K(addr_str)); + } else if (OB_ISNULL(ptr = static_cast(ctx.get_allocator().alloc(MAX_RES_LEN)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("allocate memory failed", K(ret), K(MAX_RES_LEN)); + } else if (OB_ISNULL(GCTX.srv_rpc_proxy_)) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("rpc_proxy or session is null", K(ret), K(GCTX.srv_rpc_proxy_)); + } else if (0 >= (timeout = THIS_WORKER.get_timeout_remain())) { + ret = OB_TIMEOUT; + LOG_WARN("query timeout is reached", K(ret), K(timeout)); + } else if (OB_FAIL(GCTX.srv_rpc_proxy_->to(addr) + .timeout(timeout) + .by(tenant_id) + .phy_res_calculate_by_unit(tenant_id, res))) { + LOG_WARN("failed to update local stat cache caused by unknow error", + K(ret), K(addr), K(timeout), K(tenant_id)); + // rewrite the error code to make user recheck the argument and retry. + // we should never retry here because there is something error. + ret = OB_INVALID_ARGUMENT; + LOG_USER_ERROR(OB_INVALID_ARGUMENT, "calculate physical resource needed by unit. " + "Please check the tenant id and observer address and retry."); + } else if (OB_FAIL(get_json_result_(tenant_id, addr, res, ptr, MAX_RES_LEN, pos))) { + LOG_WARN("get json result failed", K(ret), K(addr), K(res), K(pos), K(MAX_RES_LEN)); + } else { + params.at(2).set_varchar(ptr, pos); + LOG_INFO("phy_res_calculate_by_unit success", K(params.at(0).get_int()), + K(params.at(1).get_varchar()), K(params.at(2).get_varchar())); + } + return ret; +} + +int ObDBMSLimitCalculator::phy_res_calculate_by_standby_tenant( + sql::ObExecContext &ctx, + sql::ParamStore ¶ms, + common::ObObj &result) +{ + int ret = OB_SUCCESS; + const int64_t curr_tenant_id = MTL_ID(); + if (!is_sys_tenant(curr_tenant_id)) { + ret = OB_OP_NOT_ALLOW; + LOG_WARN("only sys tenant can do this", K(ret), K(curr_tenant_id)); + LOG_USER_ERROR(OB_OP_NOT_ALLOW, "Only sys tenant can do this. Operator is"); + } else if (OB_UNLIKELY(3 > params.count())) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("params not valid", KR(ret), K(params)); + } else { + const uint64_t tenant_id = params.at(0).get_int(); + const int64_t standby_unit_num = params.at(1).get_int(); + ObUserResourceCalculateArg arg; + ObMinPhyResourceResult res; + const int64_t MAX_RES_LEN = 512; + int64_t pos = 0; + char *ptr = NULL; + if (OB_FAIL(cal_tenant_logical_res_for_standby_(tenant_id, standby_unit_num, arg))) { + LOG_WARN("failed to calculate logical resource", KR(tenant_id), K(standby_unit_num)); + } else if (OB_ISNULL(MTL(ObResourceLimitCalculator *))) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("resource limit calculator is null", KR(ret), K(tenant_id)); + } else if (OB_FAIL(MTL(ObResourceLimitCalculator *)->get_tenant_min_phy_resource_value(arg, res))) { + LOG_WARN("get tenant min physical resource needed failed", K(ret), K(arg)); + } else if (OB_ISNULL(ptr = static_cast(ctx.get_allocator().alloc(MAX_RES_LEN)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("allocate memory failed", K(ret), K(MAX_RES_LEN)); + } else if (OB_FAIL(get_json_result_(res, ptr, MAX_RES_LEN, pos))) { + LOG_WARN("get json result failed", K(ret), K(res), K(pos)); + } else { + // params: 0,1,2: primary_tenant_id, standby_tenant_unit_num, res + params.at(2).set_varchar(ptr, pos); + } + LOG_DEBUG("phy_res_calculate_by_standby_tenant", K(params.at(0).get_int()), + K(params.at(1).get_int()), K(params.at(2).get_varchar())); + } + return ret; +} + +int ObDBMSLimitCalculator::cal_tenant_logical_res_for_standby_( + const uint64_t tenant_id, + const int64_t standby_unit_num, + ObUserResourceCalculateArg &arg) +{ + int ret = OB_SUCCESS; + if (OB_UNLIKELY(!is_user_tenant(tenant_id) || 0 >= standby_unit_num)) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid argument", KR(ret), K(tenant_id), K(standby_unit_num)); + LOG_USER_ERROR(OB_INVALID_ARGUMENT, "calculate physical resource needed by standby tenant. " + "The tenant is not a user tenant, or the unit number is invalid. Please recheck it and retry."); + } else { + //first get primary tenant unit_group + ObArray servers; + common::ObArray resources; + int64_t logical_resource_cnt = 0; + if (OB_FAIL(get_tenant_resource_server_for_calc_(tenant_id, servers))) { + LOG_WARN("failed to get tenant resource server", KR(ret), K(tenant_id)); + } else if (OB_FAIL(get_server_resource_info_(servers, tenant_id, resources))) { + //get each unit group logical resource + LOG_WARN("failed to get server resource info", KR(ret), K(servers), K(tenant_id)); + } else if (OB_FAIL(check_server_resource_(tenant_id, resources))) { + LOG_WARN("failed to check and sort resource", KR(ret), K(tenant_id), K(resources)); + } else if (resources.count() != servers.count() || 0 >= resources.count()) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("resource count not match", KR(ret), K(resources), K(servers)); + } else { + logical_resource_cnt = resources.at(0).get_arg().count(); + } + + //calculate max logical resource for standby + if (OB_SUCC(ret)) { + //如果备库的unit_num大于主库的unit_num，那最多备库的一台机器只需要承担主库一台机器的容量 + //小于则向上取整。 + //获取主库机器上最大server_num个数的资源 + int64_t server_num = standby_unit_num >= servers.count() ? 1 + : ceil(double(servers.count()) / standby_unit_num); + int64_t each_server_max_ls_cnt = 0; + int64_t max_ls_cnt = 0; + if (FAILEDx(get_max_ls_count_of_server_(tenant_id, each_server_max_ls_cnt))) { + LOG_WARN("failed to get max ls count of server", KR(ret), K(tenant_id)); + } else { + //需要增加一个系统日志流的个数 + max_ls_cnt = each_server_max_ls_cnt * server_num + 1; + } + //选取每一种逻辑资源的TOP n 相加 + for (int64_t i = 1; OB_SUCC(ret) && i < logical_resource_cnt; ++i) { + int64_t max_value = 0; + if (OB_FAIL(get_max_value_of_logical_res_(i, server_num, resources, max_value))) { + LOG_WARN("failed to get max value of logical res", KR(ret), K(i), K(server_num), K(resources)); + } else if (LOGIC_RESOURCE_LS == i) { + max_value = max(max_value, max_ls_cnt); + } + if (FAILEDx(arg.set_type_value(i, max_value))) { + LOG_WARN("failed to set type value", KR(ret), K(i), K(max_value)); + } else { + LOG_INFO("set type value", K(i), K(max_value), K(server_num), + K(standby_unit_num), K(max_ls_cnt)); + } + }//end for check each resource + } + } + return ret; +} + +int ObDBMSLimitCalculator::get_max_value_of_logical_res_( + const int64_t &logical_type, + const int64_t &server_cnt, + const common::ObIArray &res, + int64_t &max_logical_value) +{ + int ret = OB_SUCCESS; + max_logical_value = 0; + if (OB_UNLIKELY(0 >= logical_type || logical_type >= MAX_LOGIC_RESOURCE + || 0 >= res.count() || 0 >= server_cnt || server_cnt > res.count())) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid argument", KR(ret), K(logical_type), K(server_cnt), K(res)); + } else { + ObArray tmp_logical_resource; + const int64_t primary_server_cnt = res.count(); + for (int64_t j = 0; OB_SUCC(ret) && j < primary_server_cnt; ++j) { + const ObTenantLogicalRes &server_res = res.at(j); + int64_t value = 0; + if (OB_FAIL(server_res.get_arg().get_type_value(logical_type, value))) { + LOG_WARN("failed to get type value", KR(ret), K(logical_type)); + } else if (OB_FAIL(tmp_logical_resource.push_back(value))) { + LOG_WARN("failed to push back", KR(ret), K(value)); + } + }//end for j for get each logical resource of servers + if (OB_SUCC(ret)) { + std::sort(tmp_logical_resource.begin(), tmp_logical_resource.end()); + int64_t index = 0;//下标 + while (OB_SUCC(ret) && index < server_cnt) { + const int64_t logical_index = primary_server_cnt - 1 - index; + if (0 > logical_index || logical_index >= tmp_logical_resource.count()) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("logical index not expected", KR(ret), K(logical_index), + K(primary_server_cnt), K(index), K(tmp_logical_resource)); + } else { + max_logical_value += tmp_logical_resource.at(logical_index); + } + index ++; + }//end while for get max_value + } + } + return ret; +} + +int ObDBMSLimitCalculator::get_tenant_resource_server_for_calc_( + const uint64_t tenant_id, + common::ObIArray &servers) +{ + int ret = OB_SUCCESS; + if (OB_UNLIKELY(!is_user_tenant(tenant_id))) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid argument", KR(ret), K(tenant_id)); + } else if (OB_ISNULL(GCTX.sql_proxy_) || OB_ISNULL(GCTX.server_tracer_)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("ptr is null", KR(ret), KP(GCTX.sql_proxy_), KP(GCTX.server_tracer_)); + } else { + common::ObArray units; + ObArray unit_group_ids; + ObArray server_unit_group_ids; + ObUnitTableOperator unit_op; + if (OB_FAIL(unit_op.init(*GCTX.sql_proxy_))) { + LOG_WARN("failed to init unit op", KR(ret)); + } else if (OB_FAIL(unit_op.get_units_by_tenant(tenant_id, units))) { + LOG_WARN("failed to get tenant units", KR(ret), K(tenant_id)); + } else if (0 == units.count()) { + ret = OB_TENANT_NOT_EXIST; + LOG_WARN("tenant no exist", KR(ret), K(tenant_id)); + } else { + bool is_alive = false; + int64_t trace_time = 0;//no use + for (int64_t i = 0; OB_SUCC(ret) && i < units.count(); ++i) { + const ObUnit &unit = units.at(i); + if (!unit.is_active_status()) { + ret = OB_OP_NOT_ALLOW; + LOG_WARN("unit is deleting, can not calculate resource", KR(ret), K(unit)); + LOG_USER_ERROR(OB_OP_NOT_ALLOW, "Tenant is shrinking units. Operation is"); + } else if (unit.migrate_from_server_.is_valid()) { + //不用来计算，也不报错，后面会校验是否有足够的机器来校验 + LOG_WARN("unit is migrate, can not calculate resource", KR(ret), K(unit)); + } else if (OB_FAIL(GCTX.server_tracer_->is_alive(unit.server_, is_alive, trace_time))) { + LOG_WARN("failed to check server is alive", KR(ret), K(unit)); + } else if (!is_alive) { + LOG_WARN("server is not alive", KR(ret), K(unit)); + } else if (has_exist_in_array(server_unit_group_ids, unit.unit_group_id_)) { + //相同的unit_group_id不去检查了，只挑第一个可用的机器 + } else if (OB_FAIL(server_unit_group_ids.push_back(unit.unit_group_id_))) { + LOG_WARN("failed to push back unit group id", KR(ret), K(unit)); + } else if (OB_FAIL(servers.push_back(unit.server_))) { + LOG_WARN("failed to push back", KR(ret), K(unit)); + } + if (OB_SUCC(ret)) { + if (!has_exist_in_array(unit_group_ids, unit.unit_group_id_)) { + if (OB_FAIL(unit_group_ids.push_back(unit.unit_group_id_))) { + LOG_WARN("failed to push back", KR(ret), K(unit)); + } + } + } + }//end for + if (OB_SUCC(ret) && servers.count() != unit_group_ids.count()) { + ret = OB_OP_NOT_ALLOW; + LOG_WARN("not enough server to calculate resource", KR(ret), K(servers), K(unit_group_ids)); + LOG_USER_ERROR(OB_OP_NOT_ALLOW, "All zones have units in migrating or have inactive servers. Operation is"); + } + } + } + return ret; +} + +int ObDBMSLimitCalculator::get_server_resource_info_( + const common::ObIArray &servers, + const uint64_t tenant_id, + common::ObIArray &resource_res) +{ + int ret = OB_SUCCESS; + ObTimeoutCtx ctx; + if (OB_UNLIKELY(!is_user_tenant(tenant_id) || 0 >= servers.count())) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid argument", KR(ret), K(tenant_id), K(servers)); + } else if (OB_ISNULL(GCTX.srv_rpc_proxy_) || OB_ISNULL(GCTX.server_tracer_)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("ptr is null", KR(ret), KP(GCTX.srv_rpc_proxy_), KP(GCTX.server_tracer_)); + } else if (OB_FAIL(ObShareUtil::set_default_timeout_ctx(ctx, GCONF.rpc_timeout))) { + LOG_WARN("fail to set timeout ctx", KR(ret)); + } else { + rootserver::ObGetTenantResProxy proxy(*GCTX.srv_rpc_proxy_, + &obrpc::ObSrvRpcProxy::get_tenant_logical_resource); + obrpc::ObGetTenantResArg arg(tenant_id); + int tmp_ret = OB_SUCCESS; + ObArray return_code_array; + for (int64_t i = 0; OB_SUCC(ret) && i < servers.count(); ++i) { + const int64_t timeout = ctx.get_timeout(); + const ObAddr& addr = servers.at(i); + if (OB_FAIL(proxy.call(addr, timeout, GCONF.cluster_id, tenant_id, arg))) { + //When constructing the server, the server's status was already checked, + //therefore the RPC is sent here without ignoring the error code + LOG_WARN("failed to send rpc", KR(ret), K(addr), K(timeout), K(tenant_id)); + } + } + if (OB_TMP_FAIL(proxy.wait_all(return_code_array))) { + ret = OB_SUCC(ret) ? tmp_ret : ret; + LOG_WARN("wait all batch result failed", KR(ret), KR(tmp_ret)); + } else if (OB_FAIL(ret)) { + } else if (OB_FAIL(proxy.check_return_cnt(return_code_array.count()))) { + LOG_WARN("fail to check return cnt", KR(ret), "return_cnt", return_code_array.count()); + } else { + for (int64_t i = 0; OB_SUCC(ret) && i < return_code_array.count(); ++i) { + ret = return_code_array.at(i); + const obrpc::ObTenantLogicalRes *res = proxy.get_results().at(i); + if (OB_FAIL(ret)) { + LOG_WARN("send rpc is failed", KR(ret), K(i)); + } else if (OB_ISNULL(res)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("result is null", KR(ret), K(i)); + } else if (OB_FAIL(resource_res.push_back(*res))) { + LOG_WARN("failed to push back", KR(ret), KPC(res)); + } else { + LOG_INFO("success to get server resource", KPC(res)); + } + } + } + } + return ret; +} + +int ObDBMSLimitCalculator::check_server_resource_( + const uint64_t tenant_id, + common::ObIArray &res) +{ + int ret = OB_SUCCESS; + if (OB_UNLIKELY(!is_user_tenant(tenant_id) || 0 >= res.count())) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid argument", KR(ret), K(tenant_id), K(res)); + } else if (OB_ISNULL(GCTX.sql_proxy_) || OB_ISNULL(GCTX.server_tracer_)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("ptr is null", KR(ret), KP(GCTX.sql_proxy_), KP(GCTX.server_tracer_)); + } else { + share::ObBalanceJob balance_job; + int64_t start_time = 0; + int64_t finish_time = 0;//no use + if (OB_FAIL(share::ObBalanceJobTableOperator::get_balance_job(tenant_id, + false, *GCTX.sql_proxy_, balance_job, start_time, finish_time))) { + if (OB_ENTRY_NOT_EXIST == ret) { + ret = OB_SUCCESS; + } else { + LOG_WARN("failed to get balance job", KR(ret), K(tenant_id)); + } + } else { + //当前租户有分区均衡或者日志流均衡任务，计算结果存在不准确的可能性，所以只告警，但是不报错 + ret = OB_OP_NOT_ALLOW; + LOG_WARN("tenant has balance job", KR(ret), K(tenant_id), K(balance_job)); + LOG_USER_WARN(OB_OP_NOT_ALLOW, "Tenant is doing balance job. Operation is"); + } + } + if (OB_SUCC(ret)) { + share::ObLSStatusOperator ls_op; + ObLSStatusInfoArray ls_array; + + if (OB_FAIL(ls_op.get_all_ls_status_by_order(tenant_id, ls_array, *GCTX.sql_proxy_))) { + LOG_WARN("failed to get all ls status", KR(ret), K(tenant_id)); + } else { + //校验日志流个数是匹配的 + int64_t ls_count = 0; + int64_t type = LOGIC_RESOURCE_LS; + for (int64_t i = 0; OB_SUCC(ret) && i < res.count(); ++i) { + const ObTenantLogicalRes &server_res = res.at(i); + int64_t tmp_value = 0; + if (OB_FAIL(server_res.get_arg().get_type_value(type, tmp_value))) { + LOG_WARN("failed to get type value", KR(ret), K(type), K(i), K(server_res)); + } else { + ls_count += tmp_value; + } + }//end for + if (OB_SUCC(ret) && ls_array.count() > ls_count) { + //由于可能存在迁移，创建或者GC中的日志流，这里的内部表和实际的日志流个数 + //都有概率匹配不上，只希望报错的是日志流缺副本的场景，但是没有办法区分 + ret = OB_OP_NOT_ALLOW; + LOG_WARN("ls replica not enough", KR(ret), K(ls_count), K(ls_array), K(res)); + LOG_USER_WARN(OB_OP_NOT_ALLOW, "Insufficient number of LS. Operation is"); + } + } + } + if (OB_OP_NOT_ALLOW == ret) { + //为了保证可用性，在计算不一定准确的时候，告警但是允许执行 + ret = OB_SUCCESS; + } + return ret; +} + +int ObDBMSLimitCalculator::get_max_ls_count_of_server_( + const uint64_t tenant_id, + int64_t &ls_count) +{ + int ret = OB_SUCCESS; + int64_t primary_zone_num = 0; + int64_t unit_group_num = 0; + ObArray unit_group_array; + if (OB_UNLIKELY(!is_user_tenant(tenant_id))) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid argument", KR(ret), K(tenant_id)); + } else if (OB_FAIL(rootserver::ObTenantBalanceService::gather_stat_primary_zone_num_and_units( + tenant_id, primary_zone_num, unit_group_array))) { + LOG_WARN("failed to gather stat of primary zone and unit", KR(ret), K(tenant_id)); + } else { + unit_group_num = unit_group_array.count(); + } + if (OB_SUCC(ret)) { + //假如Unit个数为N，Primary Zone个数为P + //稳态用户日志流个数：U = N*P, + //考虑日志流膨胀场景，分区均衡过程中，每个日志流都会和其他所有日志流进行Transfer，需要生成新日志流. + //这个过程中需要考虑排除掉一个Unit上日志流之间Transfer的场景，因为一个Unit里面日志流之间Transfer不需要生成新的日志流。 + //所以，额外膨胀的日志流个数是： + //1. 每一个日志流会和其他所有日志流（包括自己）生成一个新日志流，得出的结果是：U * U + //2. 第一步的计算结果是有冗余的：每个Unit内部有P个日志流，那么每个日志流在和P个日志流Transfer过程中不会生成新日志流，所以冗余的个数是：U * P + //另外，4.2.3上引入了广播日志流之间的Transfer功能，所以广播日志流也会膨胀。 + //1. 广播日志流之间Transfer不需要生成新日志流 + //2. 广播日志流Transfer到用户日志流，也不需要生成新日志流 + //3. 用户日志流Transfer到广播日志流，需要生成一个新的广播日志流 + //所以，广播日志流膨胀个数等于用户日志流的稳态个数 U + //不考虑系统日志流，一台机器上日志流的总数为 + //U + 1 + 用户日志流膨胀个数 + 广播日志流膨胀个数 = U + 2 + U*U - U*P + U = U*U - U*(P-2) + 1 + //由于广播日志流实际上是在每台机器上都存在的资源，所以最终每台机器上日志流的个数为 + //NPP-PP+2P+1 + ls_count = (unit_group_num - 1) * primary_zone_num * primary_zone_num + 2 * primary_zone_num + 1; + } + return ret; +} + +int ObDBMSLimitCalculator::parse_dict_like_args_( + const char* ptr, + ObUserResourceCalculateArg &arg) +{ + int ret = OB_SUCCESS; + char key[50] = ""; + int64_t value = 0; + // parse the argument like: "ls: 1, tablet: 2, xxxx" + while (OB_SUCC(ret) && sscanf(ptr, "%[^:]: %ld", key, &value) == 2) { + int64_t type = get_logic_res_type_by_name(key); + if (!is_valid_logic_res_type(type)) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid argument", K(ret), K(type), K(key)); + } else if (OB_FAIL(arg.set_type_value(type, value))) { + LOG_WARN("set type value failed", K(ret), K(type), K(value)); + } + while (*ptr != '\0' && *ptr != ',') ptr++; + while (*ptr != '\0' && (*ptr == ' ' || *ptr == ',')) ptr++; + } + return ret; +} + +int ObDBMSLimitCalculator::get_json_result_( + const ObMinPhyResourceResult &res, + char *buf, + const int64_t buf_len, + int64_t &pos) +{ + int ret = OB_SUCCESS; + int64_t i = PHY_RESOURCE_MEMSTORE; + int64_t value = 0; + if (OB_FAIL(res.get_type_value(i, value))) { + LOG_WARN("get_type_value failed", K(ret), K(get_phy_res_type_name(i)), K(value)); + } else if (OB_FAIL(databuff_printf(buf, + buf_len, + pos, + "[{\"physical_resource_name\": \"%s\", \"min_value\": \"%ld\"}", + get_phy_res_type_name(i), + value))) { + LOG_WARN("get result buffer failed", K(ret), K(pos), K(buf_len)); + } else { + // get next type + i++; + for (; OB_SUCC(ret) && i < MAX_PHY_RESOURCE; i++) { + if (OB_FAIL(res.get_type_value(i, value))) { + LOG_WARN("get_type_value failed", K(ret), K(get_phy_res_type_name(i)), K(value)); + } else if (OB_FAIL(databuff_printf(buf, + buf_len, + pos, + ", {\"physical_resource_name\": \"%s\", \"min_value\": \"%ld\"}", + get_phy_res_type_name(i), + value))) { + LOG_WARN("get result buffer failed", K(ret), K(pos), K(buf_len)); + } + } + if (OB_SUCC(ret)) { + if (OB_FAIL(databuff_printf(buf, + buf_len, + pos, + "]"))) { + LOG_WARN("get result buffer failed", K(ret), K(pos), K(buf_len)); + } + } + } + return ret; +} + +int ObDBMSLimitCalculator::get_json_result_( + const int64_t tenant_id, + const ObAddr &addr, + const ObMinPhyResourceResult &res, + char *buf, + const int64_t buf_len, + int64_t &pos) +{ + int ret = OB_SUCCESS; + char ip[MAX_IP_ADDR_LENGTH] = ""; + int64_t port = 0; + int64_t value = 0; + int64_t i = PHY_RESOURCE_MEMSTORE; + if (!addr.ip_to_string(ip, MAX_IP_ADDR_LENGTH)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("get ip string failed", K(ret), K(addr)); + } else if (FALSE_IT(port = addr.get_port())) { + } else if (OB_FAIL(res.get_type_value(i, value))) { + LOG_WARN("get_type_value failed", K(ret), K(get_phy_res_type_name(i)), K(value)); + } else if (OB_FAIL(databuff_printf(buf, + buf_len, + pos, + "[{\"svr_ip\": \"%s\", \"svr_port\": \"%ld\", \"tenant_id\" : \"%ld\", \"physical_resource_name\": \"%s\", \"min_value\": \"%ld\"}", + ip, + port, + tenant_id, + get_phy_res_type_name(i), + value))) { + LOG_WARN("get result buffer failed", K(ret), K(pos), K(buf_len)); + } else { + // get next type + i++; + for (; OB_SUCC(ret) && i < MAX_PHY_RESOURCE; i++) { + if (OB_FAIL(res.get_type_value(i, value))) { + LOG_WARN("get_type_value failed", K(ret), K(get_phy_res_type_name(i)), K(value)); + } else if (OB_FAIL(databuff_printf(buf, + buf_len, + pos, + ", {\"svr_ip\": \"%s\", \"svr_port\": \"%ld\", \"tenant_id\" : \"%ld\", \"physical_resource_name\": \"%s\", \"min_value\": \"%ld\"}", + ip, + port, + tenant_id, + get_phy_res_type_name(i), + value))) { + LOG_WARN("get result buffer failed", K(ret), K(pos), K(buf_len)); + } + } + if (OB_SUCC(ret)) { + if (OB_FAIL(databuff_printf(buf, + buf_len, + pos, + "]"))) { + LOG_WARN("get result buffer failed", K(ret), K(pos), K(buf_len)); + } + } + } + return ret; +} + +} // namespace pl +} // namespace oceanbase diff --git a/src/pl/sys_package/ob_dbms_limit_calculator_mysql.h b/src/pl/sys_package/ob_dbms_limit_calculator_mysql.h new file mode 100644 index 0000000000..d30178cf8e --- /dev/null +++ b/src/pl/sys_package/ob_dbms_limit_calculator_mysql.h @@ -0,0 +1,90 @@ +/** + * Copyright (c) 2024 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_SRC_PL_SYS_PACKAGE_DBMS_LIMIT_CALCULATOR_H_ +#define OCEANBASE_SRC_PL_SYS_PACKAGE_DBMS_LIMIT_CALCULATOR_H_ + +#include "sql/engine/ob_exec_context.h" + +namespace oceanbase +{ +namespace share +{ +struct ObUserResourceCalculateArg; +} +namespace obrpc +{ +struct ObGetTenantResArg; +struct ObTenantLogicalRes; +} +namespace pl +{ + +class ObDBMSLimitCalculator +{ +public: + static int phy_res_calculate_by_logic_res( + sql::ObExecContext &ctx, + sql::ParamStore ¶ms, + common::ObObj &result); + static int phy_res_calculate_by_unit( + sql::ObExecContext &ctx, + sql::ParamStore ¶ms, + common::ObObj &result); + static int phy_res_calculate_by_standby_tenant( + sql::ObExecContext &ctx, + sql::ParamStore ¶ms, + common::ObObj &result); +private: + static int cal_tenant_logical_res_for_standby_( + const uint64_t tenant_id, + const int64_t standby_unit_num, + ObUserResourceCalculateArg &arg); + static int get_tenant_resource_server_for_calc_( + const uint64_t tenant_id, + common::ObIArray &servers); + static int get_server_resource_info_( + const common::ObIArray &servers, + const uint64_t tenant_id, + common::ObIArray &res); + static int check_server_resource_( + const uint64_t tenant_id, + common::ObIArray &res); + static int parse_dict_like_args_( + const char* ptr, + share::ObUserResourceCalculateArg &arg); + static int get_json_result_( + const ObMinPhyResourceResult &res, + char *buf, + const int64_t buf_len, + int64_t &pos); + static int get_json_result_( + const int64_t tenant_id, + const ObAddr &addr, + const ObMinPhyResourceResult &res, + char *buf, + const int64_t buf_len, + int64_t &pos); + static int get_max_ls_count_of_server_( + const uint64_t tenant_id, + int64_t &ls_count); + static int get_max_value_of_logical_res_( + const int64_t &logical_type, + const int64_t &server_cnt, + const common::ObIArray &res, + int64_t &max_logical_value); +}; + +} // namespace pl +} // namespace oceanbase + +#endif diff --git a/src/rootserver/ob_rs_async_rpc_proxy.h b/src/rootserver/ob_rs_async_rpc_proxy.h index 7e2197f8da..b728a26254 100644 --- a/src/rootserver/ob_rs_async_rpc_proxy.h +++ b/src/rootserver/ob_rs_async_rpc_proxy.h @@ -90,6 +90,8 @@ RPC_F(obrpc::OB_TRIM_KEY_LIST, obrpc::ObTrimKeyListArg, obrpc::ObTrimKeyListResu RPC_F(obrpc::OB_INNER_CREATE_TENANT_SNAPSHOT, obrpc::ObInnerCreateTenantSnapshotArg, obrpc::ObInnerCreateTenantSnapshotResult, ObTenantSnapshotCreatorProxy); RPC_F(obrpc::OB_INNER_DROP_TENANT_SNAPSHOT, obrpc::ObInnerDropTenantSnapshotArg, obrpc::ObInnerDropTenantSnapshotResult, ObTenantSnapshotDropperProxy); RPC_F(obrpc::OB_FLUSH_LS_ARCHIVE, obrpc::ObFlushLSArchiveArg, obrpc::Int64, ObFlushLSArchiveProxy); +RPC_F(obrpc::OB_CAL_STANDBY_TENANT_PHY_RESOURCE, obrpc::ObGetTenantResArg, obrpc::ObTenantLogicalRes, ObGetTenantResProxy); + }//end namespace rootserver }//end namespace oceanbase diff --git a/src/share/CMakeLists.txt b/src/share/CMakeLists.txt index 1f07c263b3..d4e8b2d9f8 100644 --- a/src/share/CMakeLists.txt +++ b/src/share/CMakeLists.txt @@ -517,6 +517,10 @@ ob_set_subtarget(ob_share balance balance/ob_balance_task_helper_operator.cpp balance/ob_transfer_partition_task_table_operator.cpp ) +ob_set_subtarget(ob_share resource_limit_calculator + resource_limit_calculator/ob_resource_commmon.cpp + resource_limit_calculator/ob_resource_limit_calculator.cpp +) if (OB_ERRSIM) ob_set_subtarget(ob_share errsim_module diff --git a/src/share/inner_table/ob_inner_table_schema.12451_12500.cpp b/src/share/inner_table/ob_inner_table_schema.12451_12500.cpp index 1c2a13d178..61a537fee0 100644 --- a/src/share/inner_table/ob_inner_table_schema.12451_12500.cpp +++ b/src/share/inner_table/ob_inner_table_schema.12451_12500.cpp @@ -2332,6 +2332,354 @@ int ObInnerTableSchema::all_virtual_tracepoint_info_schema(ObTableSchema &table_ return ret; } +int ObInnerTableSchema::all_virtual_tenant_resource_limit_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(OB_SYS_DATABASE_ID); + table_schema.set_table_id(OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_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_TENANT_RESOURCE_LIMIT_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())); + + 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)) { + 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("zone", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObVarcharType, //column_type + CS_TYPE_INVALID, //column_collation_type + MAX_ZONE_LENGTH, //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("resource_name", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObVarcharType, //column_type + CS_TYPE_INVALID, //column_collation_type + MAX_RESOURCE_NAME_LEN, //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("current_utilization", //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 + 20, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("max_utilization", //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 + 20, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("reserved_value", //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 + 20, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("limit_value", //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 + 20, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("effective_limit_type", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObVarcharType, //column_type + CS_TYPE_INVALID, //column_collation_type + MAX_CONSTRAINT_NAME_LEN, //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false); //is_autoincrement + } + if (OB_SUCC(ret)) { + table_schema.get_part_option().set_part_num(1); + table_schema.set_part_level(PARTITION_LEVEL_ONE); + table_schema.get_part_option().set_part_func_type(PARTITION_FUNC_TYPE_LIST_COLUMNS); + if (OB_FAIL(table_schema.get_part_option().set_part_expr("svr_ip, svr_port"))) { + LOG_WARN("set_part_expr failed", K(ret)); + } else if (OB_FAIL(table_schema.mock_list_partition_array())) { + LOG_WARN("mock list partition array failed", K(ret)); + } + } + table_schema.set_index_using_type(USING_HASH); + table_schema.set_row_store_type(ENCODING_ROW_STORE); + table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); + table_schema.set_progressive_merge_round(1); + table_schema.set_storage_format_version(3); + table_schema.set_tablet_id(0); + + table_schema.set_max_used_column_id(column_id); + return ret; +} + +int ObInnerTableSchema::all_virtual_tenant_resource_limit_detail_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(OB_SYS_DATABASE_ID); + table_schema.set_table_id(OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_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_TENANT_RESOURCE_LIMIT_DETAIL_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())); + + 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)) { + 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("resource_name", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObVarcharType, //column_type + CS_TYPE_INVALID, //column_collation_type + MAX_RESOURCE_NAME_LEN, //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("limit_type", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObVarcharType, //column_type + CS_TYPE_INVALID, //column_collation_type + MAX_CONSTRAINT_NAME_LEN, //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("limit_value", //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 + 20, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + if (OB_SUCC(ret)) { + table_schema.get_part_option().set_part_num(1); + table_schema.set_part_level(PARTITION_LEVEL_ONE); + table_schema.get_part_option().set_part_func_type(PARTITION_FUNC_TYPE_LIST_COLUMNS); + if (OB_FAIL(table_schema.get_part_option().set_part_expr("svr_ip, svr_port"))) { + LOG_WARN("set_part_expr failed", K(ret)); + } else if (OB_FAIL(table_schema.mock_list_partition_array())) { + LOG_WARN("mock list partition array failed", K(ret)); + } + } + table_schema.set_index_using_type(USING_HASH); + table_schema.set_row_store_type(ENCODING_ROW_STORE); + table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); + table_schema.set_progressive_merge_round(1); + table_schema.set_storage_format_version(3); + table_schema.set_tablet_id(0); + + table_schema.set_max_used_column_id(column_id); + return ret; +} + int ObInnerTableSchema::all_virtual_nic_info_schema(ObTableSchema &table_schema) { int ret = OB_SUCCESS; diff --git a/src/share/inner_table/ob_inner_table_schema.15451_15500.cpp b/src/share/inner_table/ob_inner_table_schema.15451_15500.cpp index da1dcfc16f..b2e13d72ea 100644 --- a/src/share/inner_table/ob_inner_table_schema.15451_15500.cpp +++ b/src/share/inner_table/ob_inner_table_schema.15451_15500.cpp @@ -25,6 +25,354 @@ using namespace common; namespace share { +int ObInnerTableSchema::all_virtual_tenant_resource_limit_ora_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(OB_ORA_SYS_DATABASE_ID); + table_schema.set_table_id(OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_ORA_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_TENANT_RESOURCE_LIMIT_ORA_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(ObCollationType::CS_TYPE_UTF8MB4_BIN); + + 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_UTF8MB4_BIN, //column_collation_type + MAX_IP_ADDR_LENGTH, //column_length + 2, //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 + ObNumberType, //column_type + CS_TYPE_INVALID, //column_collation_type + 38, //column_length + 38, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + 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 + ObNumberType, //column_type + CS_TYPE_INVALID, //column_collation_type + 38, //column_length + 38, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("ZONE", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObVarcharType, //column_type + CS_TYPE_UTF8MB4_BIN, //column_collation_type + MAX_ZONE_LENGTH, //column_length + 2, //column_precision + -1, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("RESOURCE_NAME", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObVarcharType, //column_type + CS_TYPE_UTF8MB4_BIN, //column_collation_type + MAX_RESOURCE_NAME_LEN, //column_length + 2, //column_precision + -1, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("CURRENT_UTILIZATION", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObNumberType, //column_type + CS_TYPE_INVALID, //column_collation_type + 38, //column_length + 38, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("MAX_UTILIZATION", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObNumberType, //column_type + CS_TYPE_INVALID, //column_collation_type + 38, //column_length + 38, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("RESERVED_VALUE", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObNumberType, //column_type + CS_TYPE_INVALID, //column_collation_type + 38, //column_length + 38, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("LIMIT_VALUE", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObNumberType, //column_type + CS_TYPE_INVALID, //column_collation_type + 38, //column_length + 38, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("EFFECTIVE_LIMIT_TYPE", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObVarcharType, //column_type + CS_TYPE_UTF8MB4_BIN, //column_collation_type + MAX_CONSTRAINT_NAME_LEN, //column_length + 2, //column_precision + -1, //column_scale + false, //is_nullable + false); //is_autoincrement + } + if (OB_SUCC(ret)) { + table_schema.get_part_option().set_part_num(1); + table_schema.set_part_level(PARTITION_LEVEL_ONE); + table_schema.get_part_option().set_part_func_type(PARTITION_FUNC_TYPE_LIST); + if (OB_FAIL(table_schema.get_part_option().set_part_expr("SVR_IP, SVR_PORT"))) { + LOG_WARN("set_part_expr failed", K(ret)); + } else if (OB_FAIL(table_schema.mock_list_partition_array())) { + LOG_WARN("mock list partition array failed", K(ret)); + } + } + table_schema.set_index_using_type(USING_HASH); + table_schema.set_row_store_type(ENCODING_ROW_STORE); + table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); + table_schema.set_progressive_merge_round(1); + table_schema.set_storage_format_version(3); + table_schema.set_tablet_id(0); + + table_schema.set_max_used_column_id(column_id); + return ret; +} + +int ObInnerTableSchema::all_virtual_tenant_resource_limit_detail_ora_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(OB_ORA_SYS_DATABASE_ID); + table_schema.set_table_id(OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_ORA_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_TENANT_RESOURCE_LIMIT_DETAIL_ORA_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(ObCollationType::CS_TYPE_UTF8MB4_BIN); + + 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_UTF8MB4_BIN, //column_collation_type + MAX_IP_ADDR_LENGTH, //column_length + 2, //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 + ObNumberType, //column_type + CS_TYPE_INVALID, //column_collation_type + 38, //column_length + 38, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + 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 + ObNumberType, //column_type + CS_TYPE_INVALID, //column_collation_type + 38, //column_length + 38, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("RESOURCE_NAME", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObVarcharType, //column_type + CS_TYPE_UTF8MB4_BIN, //column_collation_type + MAX_RESOURCE_NAME_LEN, //column_length + 2, //column_precision + -1, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("LIMIT_TYPE", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObVarcharType, //column_type + CS_TYPE_UTF8MB4_BIN, //column_collation_type + MAX_CONSTRAINT_NAME_LEN, //column_length + 2, //column_precision + -1, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("LIMIT_VALUE", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObNumberType, //column_type + CS_TYPE_INVALID, //column_collation_type + 38, //column_length + 38, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + if (OB_SUCC(ret)) { + table_schema.get_part_option().set_part_num(1); + table_schema.set_part_level(PARTITION_LEVEL_ONE); + table_schema.get_part_option().set_part_func_type(PARTITION_FUNC_TYPE_LIST); + if (OB_FAIL(table_schema.get_part_option().set_part_expr("SVR_IP, SVR_PORT"))) { + LOG_WARN("set_part_expr failed", K(ret)); + } else if (OB_FAIL(table_schema.mock_list_partition_array())) { + LOG_WARN("mock list partition array failed", K(ret)); + } + } + table_schema.set_index_using_type(USING_HASH); + table_schema.set_row_store_type(ENCODING_ROW_STORE); + table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); + table_schema.set_progressive_merge_round(1); + table_schema.set_storage_format_version(3); + table_schema.set_tablet_id(0); + + table_schema.set_max_used_column_id(column_id); + return ret; +} + int ObInnerTableSchema::all_virtual_nic_info_ora_schema(ObTableSchema &table_schema) { int ret = OB_SUCCESS; diff --git a/src/share/inner_table/ob_inner_table_schema.21551_21600.cpp b/src/share/inner_table/ob_inner_table_schema.21551_21600.cpp index 6650ed34ef..b6738ca663 100644 --- a/src/share/inner_table/ob_inner_table_schema.21551_21600.cpp +++ b/src/share/inner_table/ob_inner_table_schema.21551_21600.cpp @@ -25,6 +25,206 @@ using namespace common; namespace share { +int ObInnerTableSchema::gv_ob_tenant_resource_limit_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(OB_SYS_DATABASE_ID); + table_schema.set_table_id(OB_GV_OB_TENANT_RESOURCE_LIMIT_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_GV_OB_TENANT_RESOURCE_LIMIT_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())); + + if (OB_SUCC(ret)) { + if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT svr_ip AS SVR_IP, svr_port AS SVR_PORT, tenant_id AS TENANT_ID, zone AS ZONE, resource_name AS RESOURCE_NAME, current_utilization AS CURRENT_UTILIZATION, max_utilization AS MAX_UTILIZATION, reserved_value AS RESERVED_VALUE, limit_value AS LIMIT_VALUE, effective_limit_type AS EFFECTIVE_LIMIT_TYPE FROM oceanbase.__all_virtual_tenant_resource_limit )__"))) { + LOG_ERROR("fail to set view_definition", K(ret)); + } + } + table_schema.set_index_using_type(USING_BTREE); + table_schema.set_row_store_type(ENCODING_ROW_STORE); + table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); + table_schema.set_progressive_merge_round(1); + table_schema.set_storage_format_version(3); + table_schema.set_tablet_id(0); + + table_schema.set_max_used_column_id(column_id); + return ret; +} + +int ObInnerTableSchema::v_ob_tenant_resource_limit_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(OB_SYS_DATABASE_ID); + table_schema.set_table_id(OB_V_OB_TENANT_RESOURCE_LIMIT_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_V_OB_TENANT_RESOURCE_LIMIT_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())); + + if (OB_SUCC(ret)) { + if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT SVR_IP, SVR_PORT, TENANT_ID, ZONE, RESOURCE_NAME, CURRENT_UTILIZATION, MAX_UTILIZATION, RESERVED_VALUE, LIMIT_VALUE, EFFECTIVE_LIMIT_TYPE FROM oceanbase.GV$OB_TENANT_RESOURCE_LIMIT WHERE SVR_IP=HOST_IP() AND SVR_PORT=RPC_PORT() )__"))) { + LOG_ERROR("fail to set view_definition", K(ret)); + } + } + table_schema.set_index_using_type(USING_BTREE); + table_schema.set_row_store_type(ENCODING_ROW_STORE); + table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); + table_schema.set_progressive_merge_round(1); + table_schema.set_storage_format_version(3); + table_schema.set_tablet_id(0); + + table_schema.set_max_used_column_id(column_id); + return ret; +} + +int ObInnerTableSchema::gv_ob_tenant_resource_limit_detail_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(OB_SYS_DATABASE_ID); + table_schema.set_table_id(OB_GV_OB_TENANT_RESOURCE_LIMIT_DETAIL_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_GV_OB_TENANT_RESOURCE_LIMIT_DETAIL_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())); + + if (OB_SUCC(ret)) { + if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT svr_ip AS SVR_IP, svr_port AS SVR_PORT, tenant_id AS TENANT_ID, resource_name AS RESOURCE_NAME, limit_type AS LIMIT_TYPE, limit_value AS LIMIT_VALUE FROM oceanbase.__all_virtual_tenant_resource_limit_detail )__"))) { + LOG_ERROR("fail to set view_definition", K(ret)); + } + } + table_schema.set_index_using_type(USING_BTREE); + table_schema.set_row_store_type(ENCODING_ROW_STORE); + table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); + table_schema.set_progressive_merge_round(1); + table_schema.set_storage_format_version(3); + table_schema.set_tablet_id(0); + + table_schema.set_max_used_column_id(column_id); + return ret; +} + +int ObInnerTableSchema::v_ob_tenant_resource_limit_detail_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(OB_SYS_DATABASE_ID); + table_schema.set_table_id(OB_V_OB_TENANT_RESOURCE_LIMIT_DETAIL_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_V_OB_TENANT_RESOURCE_LIMIT_DETAIL_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())); + + if (OB_SUCC(ret)) { + if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT SVR_IP, SVR_PORT, TENANT_ID, RESOURCE_NAME, LIMIT_TYPE, LIMIT_VALUE FROM oceanbase.GV$OB_TENANT_RESOURCE_LIMIT_DETAIL WHERE SVR_IP=HOST_IP() AND SVR_PORT=RPC_PORT() )__"))) { + LOG_ERROR("fail to set view_definition", K(ret)); + } + } + table_schema.set_index_using_type(USING_BTREE); + table_schema.set_row_store_type(ENCODING_ROW_STORE); + table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); + table_schema.set_progressive_merge_round(1); + table_schema.set_storage_format_version(3); + table_schema.set_tablet_id(0); + + table_schema.set_max_used_column_id(column_id); + return ret; +} + int ObInnerTableSchema::gv_ob_nic_info_schema(ObTableSchema &table_schema) { int ret = OB_SUCCESS; diff --git a/src/share/inner_table/ob_inner_table_schema.28201_28250.cpp b/src/share/inner_table/ob_inner_table_schema.28201_28250.cpp index db6f10d1ce..b41c24bf8f 100644 --- a/src/share/inner_table/ob_inner_table_schema.28201_28250.cpp +++ b/src/share/inner_table/ob_inner_table_schema.28201_28250.cpp @@ -475,6 +475,206 @@ int ObInnerTableSchema::v_ob_tracepoint_info_ora_schema(ObTableSchema &table_sch return ret; } +int ObInnerTableSchema::gv_ob_tenant_resource_limit_ora_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(OB_ORA_SYS_DATABASE_ID); + table_schema.set_table_id(OB_GV_OB_TENANT_RESOURCE_LIMIT_ORA_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_GV_OB_TENANT_RESOURCE_LIMIT_ORA_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())); + + if (OB_SUCC(ret)) { + if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT SVR_IP, SVR_PORT, TENANT_ID, ZONE, RESOURCE_NAME, CURRENT_UTILIZATION, MAX_UTILIZATION, RESERVED_VALUE, LIMIT_VALUE, EFFECTIVE_LIMIT_TYPE FROM SYS.ALL_VIRTUAL_TENANT_RESOURCE_LIMIT )__"))) { + LOG_ERROR("fail to set view_definition", K(ret)); + } + } + table_schema.set_index_using_type(USING_BTREE); + table_schema.set_row_store_type(ENCODING_ROW_STORE); + table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); + table_schema.set_progressive_merge_round(1); + table_schema.set_storage_format_version(3); + table_schema.set_tablet_id(0); + + table_schema.set_max_used_column_id(column_id); + return ret; +} + +int ObInnerTableSchema::v_ob_tenant_resource_limit_ora_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(OB_ORA_SYS_DATABASE_ID); + table_schema.set_table_id(OB_V_OB_TENANT_RESOURCE_LIMIT_ORA_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_V_OB_TENANT_RESOURCE_LIMIT_ORA_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())); + + if (OB_SUCC(ret)) { + if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT SVR_IP, SVR_PORT, TENANT_ID, ZONE, RESOURCE_NAME, CURRENT_UTILIZATION, MAX_UTILIZATION, RESERVED_VALUE, LIMIT_VALUE, EFFECTIVE_LIMIT_TYPE FROM SYS.GV$OB_TENANT_RESOURCE_LIMIT WHERE SVR_IP=HOST_IP() AND SVR_PORT=RPC_PORT() )__"))) { + LOG_ERROR("fail to set view_definition", K(ret)); + } + } + table_schema.set_index_using_type(USING_BTREE); + table_schema.set_row_store_type(ENCODING_ROW_STORE); + table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); + table_schema.set_progressive_merge_round(1); + table_schema.set_storage_format_version(3); + table_schema.set_tablet_id(0); + + table_schema.set_max_used_column_id(column_id); + return ret; +} + +int ObInnerTableSchema::gv_ob_tenant_resource_limit_detail_ora_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(OB_ORA_SYS_DATABASE_ID); + table_schema.set_table_id(OB_GV_OB_TENANT_RESOURCE_LIMIT_DETAIL_ORA_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_GV_OB_TENANT_RESOURCE_LIMIT_DETAIL_ORA_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())); + + if (OB_SUCC(ret)) { + if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT SVR_IP, SVR_PORT, TENANT_ID, RESOURCE_NAME, LIMIT_TYPE, LIMIT_VALUE FROM SYS.ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL )__"))) { + LOG_ERROR("fail to set view_definition", K(ret)); + } + } + table_schema.set_index_using_type(USING_BTREE); + table_schema.set_row_store_type(ENCODING_ROW_STORE); + table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); + table_schema.set_progressive_merge_round(1); + table_schema.set_storage_format_version(3); + table_schema.set_tablet_id(0); + + table_schema.set_max_used_column_id(column_id); + return ret; +} + +int ObInnerTableSchema::v_ob_tenant_resource_limit_detail_ora_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(OB_ORA_SYS_DATABASE_ID); + table_schema.set_table_id(OB_V_OB_TENANT_RESOURCE_LIMIT_DETAIL_ORA_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_V_OB_TENANT_RESOURCE_LIMIT_DETAIL_ORA_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())); + + if (OB_SUCC(ret)) { + if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT SVR_IP, SVR_PORT, TENANT_ID, RESOURCE_NAME, LIMIT_TYPE, LIMIT_VALUE FROM SYS.GV$OB_TENANT_RESOURCE_LIMIT_DETAIL WHERE SVR_IP=HOST_IP() AND SVR_PORT=RPC_PORT() )__"))) { + LOG_ERROR("fail to set view_definition", K(ret)); + } + } + table_schema.set_index_using_type(USING_BTREE); + table_schema.set_row_store_type(ENCODING_ROW_STORE); + table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); + table_schema.set_progressive_merge_round(1); + table_schema.set_storage_format_version(3); + table_schema.set_tablet_id(0); + + table_schema.set_max_used_column_id(column_id); + return ret; +} + int ObInnerTableSchema::gv_ob_nic_info_ora_schema(ObTableSchema &table_schema) { int ret = OB_SUCCESS; diff --git a/src/share/inner_table/ob_inner_table_schema.h b/src/share/inner_table/ob_inner_table_schema.h index 7aaa39752a..dfcaf8cb7e 100644 --- a/src/share/inner_table/ob_inner_table_schema.h +++ b/src/share/inner_table/ob_inner_table_schema.h @@ -1023,6 +1023,8 @@ public: static int all_virtual_tenant_snapshot_ls_replica_history_schema(share::schema::ObTableSchema &table_schema); static int enabled_roles_schema(share::schema::ObTableSchema &table_schema); static int all_virtual_tracepoint_info_schema(share::schema::ObTableSchema &table_schema); + static int all_virtual_tenant_resource_limit_schema(share::schema::ObTableSchema &table_schema); + static int all_virtual_tenant_resource_limit_detail_schema(share::schema::ObTableSchema &table_schema); static int all_virtual_nic_info_schema(share::schema::ObTableSchema &table_schema); static int all_virtual_sql_audit_ora_schema(share::schema::ObTableSchema &table_schema); static int all_virtual_plan_stat_ora_schema(share::schema::ObTableSchema &table_schema); @@ -1290,6 +1292,8 @@ public: static int all_virtual_ls_snapshot_ora_schema(share::schema::ObTableSchema &table_schema); static int all_virtual_index_usage_info_real_agent_ora_schema(share::schema::ObTableSchema &table_schema); static int all_virtual_tracepoint_info_ora_schema(share::schema::ObTableSchema &table_schema); + static int all_virtual_tenant_resource_limit_ora_schema(share::schema::ObTableSchema &table_schema); + static int all_virtual_tenant_resource_limit_detail_ora_schema(share::schema::ObTableSchema &table_schema); static int all_virtual_nic_info_ora_schema(share::schema::ObTableSchema &table_schema); static int gv_ob_plan_cache_stat_schema(share::schema::ObTableSchema &table_schema); static int gv_ob_plan_cache_plan_stat_schema(share::schema::ObTableSchema &table_schema); @@ -1700,6 +1704,10 @@ public: static int dba_mvref_stmt_stats_schema(share::schema::ObTableSchema &table_schema); static int gv_ob_tracepoint_info_schema(share::schema::ObTableSchema &table_schema); static int v_ob_tracepoint_info_schema(share::schema::ObTableSchema &table_schema); + static int gv_ob_tenant_resource_limit_schema(share::schema::ObTableSchema &table_schema); + static int v_ob_tenant_resource_limit_schema(share::schema::ObTableSchema &table_schema); + static int gv_ob_tenant_resource_limit_detail_schema(share::schema::ObTableSchema &table_schema); + static int v_ob_tenant_resource_limit_detail_schema(share::schema::ObTableSchema &table_schema); static int gv_ob_nic_info_schema(share::schema::ObTableSchema &table_schema); static int v_ob_nic_info_schema(share::schema::ObTableSchema &table_schema); static int dba_synonyms_schema(share::schema::ObTableSchema &table_schema); @@ -2157,6 +2165,10 @@ public: static int v_ob_ls_snapshots_ora_schema(share::schema::ObTableSchema &table_schema); static int gv_ob_tracepoint_info_ora_schema(share::schema::ObTableSchema &table_schema); static int v_ob_tracepoint_info_ora_schema(share::schema::ObTableSchema &table_schema); + static int gv_ob_tenant_resource_limit_ora_schema(share::schema::ObTableSchema &table_schema); + static int v_ob_tenant_resource_limit_ora_schema(share::schema::ObTableSchema &table_schema); + static int gv_ob_tenant_resource_limit_detail_ora_schema(share::schema::ObTableSchema &table_schema); + static int v_ob_tenant_resource_limit_detail_ora_schema(share::schema::ObTableSchema &table_schema); static int gv_ob_nic_info_ora_schema(share::schema::ObTableSchema &table_schema); static int v_ob_nic_info_ora_schema(share::schema::ObTableSchema &table_schema); static int all_table_aux_lob_meta_schema(share::schema::ObTableSchema &table_schema); @@ -3685,6 +3697,8 @@ const schema_create_func virtual_table_schema_creators [] = { ObInnerTableSchema::all_virtual_tenant_snapshot_ls_replica_history_schema, ObInnerTableSchema::enabled_roles_schema, ObInnerTableSchema::all_virtual_tracepoint_info_schema, + ObInnerTableSchema::all_virtual_tenant_resource_limit_schema, + ObInnerTableSchema::all_virtual_tenant_resource_limit_detail_schema, ObInnerTableSchema::all_virtual_nic_info_schema, ObInnerTableSchema::all_virtual_ash_all_virtual_ash_i1_schema, ObInnerTableSchema::all_virtual_sql_plan_monitor_all_virtual_sql_plan_monitor_i1_schema, @@ -3962,6 +3976,8 @@ const schema_create_func virtual_table_schema_creators [] = { ObInnerTableSchema::all_virtual_ls_snapshot_ora_schema, ObInnerTableSchema::all_virtual_index_usage_info_real_agent_ora_schema, ObInnerTableSchema::all_virtual_tracepoint_info_ora_schema, + ObInnerTableSchema::all_virtual_tenant_resource_limit_ora_schema, + ObInnerTableSchema::all_virtual_tenant_resource_limit_detail_ora_schema, ObInnerTableSchema::all_virtual_nic_info_ora_schema, ObInnerTableSchema::all_virtual_table_real_agent_ora_idx_data_table_id_real_agent_schema, ObInnerTableSchema::all_virtual_table_real_agent_ora_idx_db_tb_name_real_agent_schema, @@ -4456,6 +4472,10 @@ const schema_create_func sys_view_schema_creators [] = { ObInnerTableSchema::dba_mvref_stmt_stats_schema, ObInnerTableSchema::gv_ob_tracepoint_info_schema, ObInnerTableSchema::v_ob_tracepoint_info_schema, + ObInnerTableSchema::gv_ob_tenant_resource_limit_schema, + ObInnerTableSchema::v_ob_tenant_resource_limit_schema, + ObInnerTableSchema::gv_ob_tenant_resource_limit_detail_schema, + ObInnerTableSchema::v_ob_tenant_resource_limit_detail_schema, ObInnerTableSchema::gv_ob_nic_info_schema, ObInnerTableSchema::v_ob_nic_info_schema, ObInnerTableSchema::dba_synonyms_schema, @@ -4913,6 +4933,10 @@ const schema_create_func sys_view_schema_creators [] = { ObInnerTableSchema::v_ob_ls_snapshots_ora_schema, ObInnerTableSchema::gv_ob_tracepoint_info_ora_schema, ObInnerTableSchema::v_ob_tracepoint_info_ora_schema, + ObInnerTableSchema::gv_ob_tenant_resource_limit_ora_schema, + ObInnerTableSchema::v_ob_tenant_resource_limit_ora_schema, + ObInnerTableSchema::gv_ob_tenant_resource_limit_detail_ora_schema, + ObInnerTableSchema::v_ob_tenant_resource_limit_detail_ora_schema, ObInnerTableSchema::gv_ob_nic_info_ora_schema, ObInnerTableSchema::v_ob_nic_info_ora_schema, NULL,}; @@ -5527,6 +5551,8 @@ const uint64_t tenant_space_tables [] = { OB_ALL_VIRTUAL_TENANT_SNAPSHOT_LS_REPLICA_HISTORY_TID, OB_ENABLED_ROLES_TID, OB_ALL_VIRTUAL_TRACEPOINT_INFO_TID, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_TID, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_TID, OB_ALL_VIRTUAL_NIC_INFO_TID, OB_ALL_VIRTUAL_SQL_AUDIT_ORA_TID, OB_ALL_VIRTUAL_SQL_AUDIT_ORA_ALL_VIRTUAL_SQL_AUDIT_I1_TID, @@ -5803,6 +5829,8 @@ const uint64_t tenant_space_tables [] = { OB_ALL_VIRTUAL_LS_SNAPSHOT_ORA_TID, OB_ALL_VIRTUAL_INDEX_USAGE_INFO_REAL_AGENT_ORA_TID, OB_ALL_VIRTUAL_TRACEPOINT_INFO_ORA_TID, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_ORA_TID, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TID, OB_ALL_VIRTUAL_NIC_INFO_ORA_TID, OB_GV_OB_PLAN_CACHE_STAT_TID, OB_GV_OB_PLAN_CACHE_PLAN_STAT_TID, @@ -6094,6 +6122,10 @@ const uint64_t tenant_space_tables [] = { OB_DBA_MVREF_STMT_STATS_TID, OB_GV_OB_TRACEPOINT_INFO_TID, OB_V_OB_TRACEPOINT_INFO_TID, + OB_GV_OB_TENANT_RESOURCE_LIMIT_TID, + OB_V_OB_TENANT_RESOURCE_LIMIT_TID, + OB_GV_OB_TENANT_RESOURCE_LIMIT_DETAIL_TID, + OB_V_OB_TENANT_RESOURCE_LIMIT_DETAIL_TID, OB_GV_OB_NIC_INFO_TID, OB_V_OB_NIC_INFO_TID, OB_DBA_SYNONYMS_TID, @@ -6551,6 +6583,10 @@ const uint64_t tenant_space_tables [] = { OB_V_OB_LS_SNAPSHOTS_ORA_TID, OB_GV_OB_TRACEPOINT_INFO_ORA_TID, OB_V_OB_TRACEPOINT_INFO_ORA_TID, + OB_GV_OB_TENANT_RESOURCE_LIMIT_ORA_TID, + OB_V_OB_TENANT_RESOURCE_LIMIT_ORA_TID, + OB_GV_OB_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TID, + OB_V_OB_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TID, OB_GV_OB_NIC_INFO_ORA_TID, OB_V_OB_NIC_INFO_ORA_TID, OB_ALL_TABLE_IDX_DATA_TABLE_ID_TID, @@ -7401,6 +7437,8 @@ const uint64_t all_ora_mapping_virtual_table_org_tables [] = { OB_ALL_VIRTUAL_SYS_VARIABLE_DEFAULT_VALUE_TID, OB_ALL_VIRTUAL_LS_SNAPSHOT_TID, OB_ALL_VIRTUAL_TRACEPOINT_INFO_TID, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_TID, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_TID, OB_ALL_VIRTUAL_NIC_INFO_TID, }; const uint64_t all_ora_mapping_virtual_tables [] = { OB_ALL_VIRTUAL_SQL_AUDIT_ORA_TID @@ -7545,6 +7583,8 @@ const uint64_t all_ora_mapping_virtual_tables [] = { OB_ALL_VIRTUAL_SQL_AUDIT_O , OB_ALL_VIRTUAL_SYS_VARIABLE_DEFAULT_VALUE_ORA_TID , OB_ALL_VIRTUAL_LS_SNAPSHOT_ORA_TID , OB_ALL_VIRTUAL_TRACEPOINT_INFO_ORA_TID +, OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_ORA_TID +, OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TID , OB_ALL_VIRTUAL_NIC_INFO_ORA_TID , }; @@ -8053,6 +8093,8 @@ const char* const tenant_space_table_names [] = { OB_ALL_VIRTUAL_TENANT_SNAPSHOT_LS_REPLICA_HISTORY_TNAME, OB_ENABLED_ROLES_TNAME, OB_ALL_VIRTUAL_TRACEPOINT_INFO_TNAME, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_TNAME, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_TNAME, OB_ALL_VIRTUAL_NIC_INFO_TNAME, OB_ALL_VIRTUAL_SQL_AUDIT_ORA_TNAME, OB_ALL_VIRTUAL_SQL_AUDIT_ORA_ALL_VIRTUAL_SQL_AUDIT_I1_TNAME, @@ -8329,6 +8371,8 @@ const char* const tenant_space_table_names [] = { OB_ALL_VIRTUAL_LS_SNAPSHOT_ORA_TNAME, OB_ALL_VIRTUAL_INDEX_USAGE_INFO_REAL_AGENT_ORA_TNAME, OB_ALL_VIRTUAL_TRACEPOINT_INFO_ORA_TNAME, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_ORA_TNAME, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TNAME, OB_ALL_VIRTUAL_NIC_INFO_ORA_TNAME, OB_GV_OB_PLAN_CACHE_STAT_TNAME, OB_GV_OB_PLAN_CACHE_PLAN_STAT_TNAME, @@ -8620,6 +8664,10 @@ const char* const tenant_space_table_names [] = { OB_DBA_MVREF_STMT_STATS_TNAME, OB_GV_OB_TRACEPOINT_INFO_TNAME, OB_V_OB_TRACEPOINT_INFO_TNAME, + OB_GV_OB_TENANT_RESOURCE_LIMIT_TNAME, + OB_V_OB_TENANT_RESOURCE_LIMIT_TNAME, + OB_GV_OB_TENANT_RESOURCE_LIMIT_DETAIL_TNAME, + OB_V_OB_TENANT_RESOURCE_LIMIT_DETAIL_TNAME, OB_GV_OB_NIC_INFO_TNAME, OB_V_OB_NIC_INFO_TNAME, OB_DBA_SYNONYMS_TNAME, @@ -9077,6 +9125,10 @@ const char* const tenant_space_table_names [] = { OB_V_OB_LS_SNAPSHOTS_ORA_TNAME, OB_GV_OB_TRACEPOINT_INFO_ORA_TNAME, OB_V_OB_TRACEPOINT_INFO_ORA_TNAME, + OB_GV_OB_TENANT_RESOURCE_LIMIT_ORA_TNAME, + OB_V_OB_TENANT_RESOURCE_LIMIT_ORA_TNAME, + OB_GV_OB_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TNAME, + OB_V_OB_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TNAME, OB_GV_OB_NIC_INFO_ORA_TNAME, OB_V_OB_NIC_INFO_ORA_TNAME, OB_ALL_TABLE_IDX_DATA_TABLE_ID_TNAME, @@ -9936,6 +9988,8 @@ const uint64_t tenant_distributed_vtables [] = { OB_ALL_VIRTUAL_CHECKPOINT_DIAGNOSE_INFO_TID, OB_ALL_VIRTUAL_LS_SNAPSHOT_TID, OB_ALL_VIRTUAL_TRACEPOINT_INFO_TID, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_TID, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_TID, OB_ALL_VIRTUAL_NIC_INFO_TID, OB_ALL_VIRTUAL_SQL_AUDIT_ORA_TID, OB_ALL_VIRTUAL_SQL_AUDIT_ORA_ALL_VIRTUAL_SQL_AUDIT_I1_TID, @@ -10008,6 +10062,8 @@ const uint64_t tenant_distributed_vtables [] = { OB_ALL_VIRTUAL_CGROUP_CONFIG_ORA_TID, OB_ALL_VIRTUAL_LS_SNAPSHOT_ORA_TID, OB_ALL_VIRTUAL_TRACEPOINT_INFO_ORA_TID, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_ORA_TID, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TID, OB_ALL_VIRTUAL_NIC_INFO_ORA_TID, }; const uint64_t restrict_access_virtual_tables[] = { @@ -10134,6 +10190,8 @@ const uint64_t restrict_access_virtual_tables[] = { OB_ALL_VIRTUAL_LS_SNAPSHOT_ORA_TID, OB_ALL_VIRTUAL_INDEX_USAGE_INFO_REAL_AGENT_ORA_TID, OB_ALL_VIRTUAL_TRACEPOINT_INFO_ORA_TID, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_ORA_TID, + OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TID, OB_ALL_VIRTUAL_NIC_INFO_ORA_TID }; @@ -12647,11 +12705,11 @@ static inline int get_sys_table_lob_aux_schema(const uint64_t tid, const int64_t OB_CORE_TABLE_COUNT = 4; const int64_t OB_SYS_TABLE_COUNT = 288; -const int64_t OB_VIRTUAL_TABLE_COUNT = 799; -const int64_t OB_SYS_VIEW_COUNT = 868; -const int64_t OB_SYS_TENANT_TABLE_COUNT = 1960; +const int64_t OB_VIRTUAL_TABLE_COUNT = 803; +const int64_t OB_SYS_VIEW_COUNT = 876; +const int64_t OB_SYS_TENANT_TABLE_COUNT = 1972; const int64_t OB_CORE_SCHEMA_VERSION = 1; -const int64_t OB_BOOTSTRAP_SCHEMA_VERSION = 1963; +const int64_t OB_BOOTSTRAP_SCHEMA_VERSION = 1975; } // end namespace share } // end namespace oceanbase diff --git a/src/share/inner_table/ob_inner_table_schema_constants.h b/src/share/inner_table/ob_inner_table_schema_constants.h index e844c62147..8e9b78b87c 100644 --- a/src/share/inner_table/ob_inner_table_schema_constants.h +++ b/src/share/inner_table/ob_inner_table_schema_constants.h @@ -759,6 +759,8 @@ const uint64_t OB_ALL_VIRTUAL_COLUMN_PRIVILEGE_HISTORY_TID = 12463; // "__all_vi const uint64_t OB_ALL_VIRTUAL_TENANT_SNAPSHOT_LS_REPLICA_HISTORY_TID = 12464; // "__all_virtual_tenant_snapshot_ls_replica_history" const uint64_t OB_ENABLED_ROLES_TID = 12466; // "ENABLED_ROLES" const uint64_t OB_ALL_VIRTUAL_TRACEPOINT_INFO_TID = 12469; // "__all_virtual_tracepoint_info" +const uint64_t OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_TID = 12481; // "__all_virtual_tenant_resource_limit" +const uint64_t OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_TID = 12482; // "__all_virtual_tenant_resource_limit_detail" const uint64_t OB_ALL_VIRTUAL_NIC_INFO_TID = 12487; // "__all_virtual_nic_info" const uint64_t OB_ALL_VIRTUAL_SQL_AUDIT_ORA_TID = 15009; // "ALL_VIRTUAL_SQL_AUDIT_ORA" const uint64_t OB_ALL_VIRTUAL_PLAN_STAT_ORA_TID = 15010; // "ALL_VIRTUAL_PLAN_STAT_ORA" @@ -1026,6 +1028,8 @@ const uint64_t OB_ALL_VIRTUAL_TRANSFER_PARTITION_TASK_HISTORY_REAL_AGENT_ORA_TID const uint64_t OB_ALL_VIRTUAL_LS_SNAPSHOT_ORA_TID = 15439; // "ALL_VIRTUAL_LS_SNAPSHOT_ORA" const uint64_t OB_ALL_VIRTUAL_INDEX_USAGE_INFO_REAL_AGENT_ORA_TID = 15440; // "ALL_VIRTUAL_INDEX_USAGE_INFO_REAL_AGENT_ORA" const uint64_t OB_ALL_VIRTUAL_TRACEPOINT_INFO_ORA_TID = 15445; // "ALL_VIRTUAL_TRACEPOINT_INFO_ORA" +const uint64_t OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_ORA_TID = 15450; // "ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_ORA" +const uint64_t OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TID = 15451; // "ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_ORA" const uint64_t OB_ALL_VIRTUAL_NIC_INFO_ORA_TID = 15456; // "ALL_VIRTUAL_NIC_INFO_ORA" const uint64_t OB_GV_OB_PLAN_CACHE_STAT_TID = 20001; // "GV$OB_PLAN_CACHE_STAT" const uint64_t OB_GV_OB_PLAN_CACHE_PLAN_STAT_TID = 20002; // "GV$OB_PLAN_CACHE_PLAN_STAT" @@ -1436,6 +1440,10 @@ const uint64_t OB_CDB_MVREF_STMT_STATS_TID = 21539; // "CDB_MVREF_STMT_STATS" const uint64_t OB_DBA_MVREF_STMT_STATS_TID = 21540; // "DBA_MVREF_STMT_STATS" const uint64_t OB_GV_OB_TRACEPOINT_INFO_TID = 21543; // "GV$OB_TRACEPOINT_INFO" const uint64_t OB_V_OB_TRACEPOINT_INFO_TID = 21544; // "V$OB_TRACEPOINT_INFO" +const uint64_t OB_GV_OB_TENANT_RESOURCE_LIMIT_TID = 21550; // "GV$OB_TENANT_RESOURCE_LIMIT" +const uint64_t OB_V_OB_TENANT_RESOURCE_LIMIT_TID = 21551; // "V$OB_TENANT_RESOURCE_LIMIT" +const uint64_t OB_GV_OB_TENANT_RESOURCE_LIMIT_DETAIL_TID = 21552; // "GV$OB_TENANT_RESOURCE_LIMIT_DETAIL" +const uint64_t OB_V_OB_TENANT_RESOURCE_LIMIT_DETAIL_TID = 21553; // "V$OB_TENANT_RESOURCE_LIMIT_DETAIL" const uint64_t OB_GV_OB_NIC_INFO_TID = 21580; // "GV$OB_NIC_INFO" const uint64_t OB_V_OB_NIC_INFO_TID = 21581; // "V$OB_NIC_INFO" const uint64_t OB_DBA_SYNONYMS_TID = 25001; // "DBA_SYNONYMS" @@ -1893,6 +1901,10 @@ const uint64_t OB_GV_OB_LS_SNAPSHOTS_ORA_TID = 28215; // "GV$OB_LS_SNAPSHOTS_ORA const uint64_t OB_V_OB_LS_SNAPSHOTS_ORA_TID = 28216; // "V$OB_LS_SNAPSHOTS_ORA" const uint64_t OB_GV_OB_TRACEPOINT_INFO_ORA_TID = 28221; // "GV$OB_TRACEPOINT_INFO_ORA" const uint64_t OB_V_OB_TRACEPOINT_INFO_ORA_TID = 28222; // "V$OB_TRACEPOINT_INFO_ORA" +const uint64_t OB_GV_OB_TENANT_RESOURCE_LIMIT_ORA_TID = 28224; // "GV$OB_TENANT_RESOURCE_LIMIT_ORA" +const uint64_t OB_V_OB_TENANT_RESOURCE_LIMIT_ORA_TID = 28225; // "V$OB_TENANT_RESOURCE_LIMIT_ORA" +const uint64_t OB_GV_OB_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TID = 28226; // "GV$OB_TENANT_RESOURCE_LIMIT_DETAIL_ORA" +const uint64_t OB_V_OB_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TID = 28227; // "V$OB_TENANT_RESOURCE_LIMIT_DETAIL_ORA" const uint64_t OB_GV_OB_NIC_INFO_ORA_TID = 28230; // "GV$OB_NIC_INFO_ORA" const uint64_t OB_V_OB_NIC_INFO_ORA_TID = 28231; // "V$OB_NIC_INFO_ORA" const uint64_t OB_ALL_TABLE_AUX_LOB_META_TID = 50003; // "__all_table_aux_lob_meta" @@ -3405,6 +3417,8 @@ const char *const OB_ALL_VIRTUAL_COLUMN_PRIVILEGE_HISTORY_TNAME = "__all_virtual const char *const OB_ALL_VIRTUAL_TENANT_SNAPSHOT_LS_REPLICA_HISTORY_TNAME = "__all_virtual_tenant_snapshot_ls_replica_history"; const char *const OB_ENABLED_ROLES_TNAME = "ENABLED_ROLES"; const char *const OB_ALL_VIRTUAL_TRACEPOINT_INFO_TNAME = "__all_virtual_tracepoint_info"; +const char *const OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_TNAME = "__all_virtual_tenant_resource_limit"; +const char *const OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_TNAME = "__all_virtual_tenant_resource_limit_detail"; const char *const OB_ALL_VIRTUAL_NIC_INFO_TNAME = "__all_virtual_nic_info"; const char *const OB_ALL_VIRTUAL_SQL_AUDIT_ORA_TNAME = "ALL_VIRTUAL_SQL_AUDIT"; const char *const OB_ALL_VIRTUAL_PLAN_STAT_ORA_TNAME = "ALL_VIRTUAL_PLAN_STAT"; @@ -3672,6 +3686,8 @@ const char *const OB_ALL_VIRTUAL_TRANSFER_PARTITION_TASK_HISTORY_REAL_AGENT_ORA_ const char *const OB_ALL_VIRTUAL_LS_SNAPSHOT_ORA_TNAME = "ALL_VIRTUAL_LS_SNAPSHOT"; const char *const OB_ALL_VIRTUAL_INDEX_USAGE_INFO_REAL_AGENT_ORA_TNAME = "ALL_VIRTUAL_INDEX_USAGE_INFO_REAL_AGENT"; const char *const OB_ALL_VIRTUAL_TRACEPOINT_INFO_ORA_TNAME = "ALL_VIRTUAL_TRACEPOINT_INFO"; +const char *const OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_ORA_TNAME = "ALL_VIRTUAL_TENANT_RESOURCE_LIMIT"; +const char *const OB_ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TNAME = "ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL"; const char *const OB_ALL_VIRTUAL_NIC_INFO_ORA_TNAME = "ALL_VIRTUAL_NIC_INFO"; const char *const OB_GV_OB_PLAN_CACHE_STAT_TNAME = "GV$OB_PLAN_CACHE_STAT"; const char *const OB_GV_OB_PLAN_CACHE_PLAN_STAT_TNAME = "GV$OB_PLAN_CACHE_PLAN_STAT"; @@ -4082,6 +4098,10 @@ const char *const OB_CDB_MVREF_STMT_STATS_TNAME = "CDB_MVREF_STMT_STATS"; const char *const OB_DBA_MVREF_STMT_STATS_TNAME = "DBA_MVREF_STMT_STATS"; const char *const OB_GV_OB_TRACEPOINT_INFO_TNAME = "GV$OB_TRACEPOINT_INFO"; const char *const OB_V_OB_TRACEPOINT_INFO_TNAME = "V$OB_TRACEPOINT_INFO"; +const char *const OB_GV_OB_TENANT_RESOURCE_LIMIT_TNAME = "GV$OB_TENANT_RESOURCE_LIMIT"; +const char *const OB_V_OB_TENANT_RESOURCE_LIMIT_TNAME = "V$OB_TENANT_RESOURCE_LIMIT"; +const char *const OB_GV_OB_TENANT_RESOURCE_LIMIT_DETAIL_TNAME = "GV$OB_TENANT_RESOURCE_LIMIT_DETAIL"; +const char *const OB_V_OB_TENANT_RESOURCE_LIMIT_DETAIL_TNAME = "V$OB_TENANT_RESOURCE_LIMIT_DETAIL"; const char *const OB_GV_OB_NIC_INFO_TNAME = "GV$OB_NIC_INFO"; const char *const OB_V_OB_NIC_INFO_TNAME = "V$OB_NIC_INFO"; const char *const OB_DBA_SYNONYMS_TNAME = "DBA_SYNONYMS"; @@ -4539,6 +4559,10 @@ const char *const OB_GV_OB_LS_SNAPSHOTS_ORA_TNAME = "GV$OB_LS_SNAPSHOTS"; const char *const OB_V_OB_LS_SNAPSHOTS_ORA_TNAME = "V$OB_LS_SNAPSHOTS"; const char *const OB_GV_OB_TRACEPOINT_INFO_ORA_TNAME = "GV$OB_TRACEPOINT_INFO"; const char *const OB_V_OB_TRACEPOINT_INFO_ORA_TNAME = "V$OB_TRACEPOINT_INFO"; +const char *const OB_GV_OB_TENANT_RESOURCE_LIMIT_ORA_TNAME = "GV$OB_TENANT_RESOURCE_LIMIT"; +const char *const OB_V_OB_TENANT_RESOURCE_LIMIT_ORA_TNAME = "V$OB_TENANT_RESOURCE_LIMIT"; +const char *const OB_GV_OB_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TNAME = "GV$OB_TENANT_RESOURCE_LIMIT_DETAIL"; +const char *const OB_V_OB_TENANT_RESOURCE_LIMIT_DETAIL_ORA_TNAME = "V$OB_TENANT_RESOURCE_LIMIT_DETAIL"; const char *const OB_GV_OB_NIC_INFO_ORA_TNAME = "GV$OB_NIC_INFO"; const char *const OB_V_OB_NIC_INFO_ORA_TNAME = "V$OB_NIC_INFO"; const char *const OB_ALL_TABLE_AUX_LOB_META_TNAME = "__all_table_aux_lob_meta"; diff --git a/src/share/inner_table/ob_inner_table_schema_def.py b/src/share/inner_table/ob_inner_table_schema_def.py index 4f0ebcb4d1..11045a6d01 100644 --- a/src/share/inner_table/ob_inner_table_schema_def.py +++ b/src/share/inner_table/ob_inner_table_schema_def.py @@ -14155,8 +14155,55 @@ def_table_schema( # 12478: __all_virtual_tablet_reorganize_history # 12479: __all_virtual_res_mgr_directive # 12480: __all_virtual_service -# 12481: __all_virtual_tenant_resource_limit -# 12482: __all_virtual_tenant_resource_limit_detail + +def_table_schema( + owner = 'yanyuan.cxf', + table_name = '__all_virtual_tenant_resource_limit', + table_id = '12481', + table_type = 'VIRTUAL_TABLE', + gm_columns = [], + rowkey_columns = [ + ], + + in_tenant_space = True, + normal_columns = [ + ('svr_ip', 'varchar:MAX_IP_ADDR_LENGTH'), + ('svr_port', 'int'), + ('tenant_id', 'int'), + ('zone', 'varchar:MAX_ZONE_LENGTH'), + ('resource_name', 'varchar:MAX_RESOURCE_NAME_LEN'), + ('current_utilization', 'bigint'), + ('max_utilization', 'bigint'), + ('reserved_value', 'bigint'), + ('limit_value', 'bigint'), + ('effective_limit_type', 'varchar:MAX_CONSTRAINT_NAME_LEN'), + ], + partition_columns = ['svr_ip', 'svr_port'], + vtable_route_policy = 'distributed', +) + +def_table_schema( + owner = 'yanyuan.cxf', + table_name = '__all_virtual_tenant_resource_limit_detail', + table_id = '12482', + table_type = 'VIRTUAL_TABLE', + gm_columns = [], + rowkey_columns = [ + ], + + in_tenant_space = True, + normal_columns = [ + ('svr_ip', 'varchar:MAX_IP_ADDR_LENGTH'), + ('svr_port', 'int'), + ('tenant_id', 'int'), + ('resource_name', 'varchar:MAX_RESOURCE_NAME_LEN'), + ('limit_type', 'varchar:MAX_CONSTRAINT_NAME_LEN'), + ('limit_value', 'bigint'), + ], + partition_columns = ['svr_ip', 'svr_port'], + vtable_route_policy = 'distributed', +) + # 12483: __all_virtual_group_io_stat # 12484: __all_virtual_res_mgr_consumer_group # 12485: __all_virtual_storage_io_usage @@ -14649,8 +14696,9 @@ def_table_schema(**no_direct_access(gen_oracle_mapping_virtual_table_def('15445' # 15447: __all_user_proxy_role_info # 15448: idx_user_proxy_info_proxy_user_id_real_agent # 15449: __all_virtual_service -# 15450: __all_virtual_tenant_resource_limit -# 15451: __all_virtual_tenant_resource_limit_detail +def_table_schema(**no_direct_access(gen_oracle_mapping_virtual_table_def('15450', all_def_keywords['__all_virtual_tenant_resource_limit']))) +def_table_schema(**no_direct_access(gen_oracle_mapping_virtual_table_def('15451', all_def_keywords['__all_virtual_tenant_resource_limit_detail']))) + # 15452: __all_virtual_group_io_stat # 15453: __all_storage_io_usage # 15454: __all_virtual_storage_io_usage @@ -33813,10 +33861,98 @@ def_table_schema( # 21547: CDB_OB_RSRC_DIRECTIVES # 21548: DBA_OB_SERVICES # 21549: CDB_OB_SERVICES -# 21550: GV$OB_TENANT_RESOURCE_LIMIT -# 21551: V$OB_TENANT_RESOURCE_LIMIT -# 21552: GV$OB_TENANT_RESOURCE_LIMIT_DETAIL -# 21553: V$OB_TENANT_RESOURCE_LIMIT_DETAIL + +def_table_schema( + owner = 'cxf262476', + table_name = 'GV$OB_TENANT_RESOURCE_LIMIT', + table_id = '21550', + table_type = 'SYSTEM_VIEW', + rowkey_columns = [], + normal_columns = [], + gm_columns = [], + in_tenant_space = True, + view_definition = """ +SELECT + svr_ip AS SVR_IP, + svr_port AS SVR_PORT, + tenant_id AS TENANT_ID, + zone AS ZONE, + resource_name AS RESOURCE_NAME, + current_utilization AS CURRENT_UTILIZATION, + max_utilization AS MAX_UTILIZATION, + reserved_value AS RESERVED_VALUE, + limit_value AS LIMIT_VALUE, + effective_limit_type AS EFFECTIVE_LIMIT_TYPE +FROM + oceanbase.__all_virtual_tenant_resource_limit +""".replace("\n", " ") +) + +def_table_schema( + owner = 'cxf262476', + table_name = 'V$OB_TENANT_RESOURCE_LIMIT', + table_id = '21551', + table_type = 'SYSTEM_VIEW', + rowkey_columns = [], + normal_columns = [], + gm_columns = [], + in_tenant_space = True, + view_definition = """ +SELECT + SVR_IP, SVR_PORT, TENANT_ID, ZONE, RESOURCE_NAME, CURRENT_UTILIZATION, MAX_UTILIZATION, + RESERVED_VALUE, LIMIT_VALUE, EFFECTIVE_LIMIT_TYPE +FROM + oceanbase.GV$OB_TENANT_RESOURCE_LIMIT +WHERE + SVR_IP=HOST_IP() +AND + SVR_PORT=RPC_PORT() +""".replace("\n", " ") +) + +def_table_schema( + owner = 'cxf262476', + table_name = 'GV$OB_TENANT_RESOURCE_LIMIT_DETAIL', + table_id = '21552', + table_type = 'SYSTEM_VIEW', + rowkey_columns = [], + normal_columns = [], + gm_columns = [], + in_tenant_space = True, + view_definition = """ +SELECT + svr_ip AS SVR_IP, + svr_port AS SVR_PORT, + tenant_id AS TENANT_ID, + resource_name AS RESOURCE_NAME, + limit_type AS LIMIT_TYPE, + limit_value AS LIMIT_VALUE +FROM + oceanbase.__all_virtual_tenant_resource_limit_detail +""".replace("\n", " ") +) + +def_table_schema( + owner = 'cxf262476', + table_name = 'V$OB_TENANT_RESOURCE_LIMIT_DETAIL', + table_id = '21553', + table_type = 'SYSTEM_VIEW', + rowkey_columns = [], + normal_columns = [], + gm_columns = [], + in_tenant_space = True, + view_definition = """ +SELECT + SVR_IP, SVR_PORT, TENANT_ID, RESOURCE_NAME, LIMIT_TYPE, LIMIT_VALUE +FROM + oceanbase.GV$OB_TENANT_RESOURCE_LIMIT_DETAIL +WHERE + SVR_IP=HOST_IP() +AND + SVR_PORT=RPC_PORT() +""".replace("\n", " ") +) + # 21554: INNODB_LOCK_WAITS # 21555: INNODB_LOCKS # 21556: INNODB_TRX @@ -33886,6 +34022,7 @@ def_table_schema( ) # + # 余留位置（此行之前占位） # 本区域占位建议：采用真实视图名进行占位 ################################################################################ @@ -61236,10 +61373,104 @@ def_table_schema( """.replace("\n", " ") ) # 28223: DBA_OB_RSRC_DIRECTIVES -# 28224: GV$OB_TENANT_RESOURCE_LIMIT -# 28225: V$OB_TENANT_RESOURCE_LIMIT -# 28226: GV$OB_TENANT_RESOURCE_LIMIT_DETAIL -# 28227: V$OB_TENANT_RESOURCE_LIMIT_DETAIL +def_table_schema( + owner = 'cxf262476', + table_name = 'GV$OB_TENANT_RESOURCE_LIMIT', + name_postfix = '_ORA', + database_id = 'OB_ORA_SYS_DATABASE_ID', + table_id = '28224', + table_type = 'SYSTEM_VIEW', + rowkey_columns = [], + normal_columns = [], + gm_columns = [], + in_tenant_space = True, + view_definition = """ +SELECT + SVR_IP, + SVR_PORT, + TENANT_ID, + ZONE, + RESOURCE_NAME, + CURRENT_UTILIZATION, + MAX_UTILIZATION, + RESERVED_VALUE, + LIMIT_VALUE, + EFFECTIVE_LIMIT_TYPE +FROM + SYS.ALL_VIRTUAL_TENANT_RESOURCE_LIMIT +""".replace("\n", " ") +) + +def_table_schema( + owner = 'cxf262476', + table_name = 'V$OB_TENANT_RESOURCE_LIMIT', + name_postfix = '_ORA', + database_id = 'OB_ORA_SYS_DATABASE_ID', + table_id = '28225', + table_type = 'SYSTEM_VIEW', + rowkey_columns = [], + normal_columns = [], + gm_columns = [], + in_tenant_space = True, + view_definition = """ +SELECT + SVR_IP, SVR_PORT, TENANT_ID, ZONE, RESOURCE_NAME, CURRENT_UTILIZATION, MAX_UTILIZATION, + RESERVED_VALUE, LIMIT_VALUE, EFFECTIVE_LIMIT_TYPE +FROM + SYS.GV$OB_TENANT_RESOURCE_LIMIT +WHERE + SVR_IP=HOST_IP() +AND + SVR_PORT=RPC_PORT() +""".replace("\n", " ") +) + +def_table_schema( + owner = 'cxf262476', + table_name = 'GV$OB_TENANT_RESOURCE_LIMIT_DETAIL', + name_postfix = '_ORA', + database_id = 'OB_ORA_SYS_DATABASE_ID', + table_id = '28226', + table_type = 'SYSTEM_VIEW', + rowkey_columns = [], + normal_columns = [], + gm_columns = [], + in_tenant_space = True, + view_definition = """ +SELECT + SVR_IP, + SVR_PORT, + TENANT_ID, + RESOURCE_NAME, + LIMIT_TYPE, + LIMIT_VALUE +FROM + SYS.ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL +""".replace("\n", " ") +) + +def_table_schema( + owner = 'cxf262476', + table_name = 'V$OB_TENANT_RESOURCE_LIMIT_DETAIL', + name_postfix = '_ORA', + database_id = 'OB_ORA_SYS_DATABASE_ID', + table_id = '28227', + table_type = 'SYSTEM_VIEW', + rowkey_columns = [], + normal_columns = [], + gm_columns = [], + in_tenant_space = True, + view_definition = """ +SELECT + SVR_IP, SVR_PORT, TENANT_ID, RESOURCE_NAME, LIMIT_TYPE, LIMIT_VALUE +FROM + SYS.GV$OB_TENANT_RESOURCE_LIMIT_DETAIL +WHERE + SVR_IP=HOST_IP() +AND + SVR_PORT=RPC_PORT() +""".replace("\n", " ") +) # 28228: V$OB_GROUP_IO_STAT # 28229: GV$OB_GROUP_IO_STAT diff --git a/src/share/inner_table/sys_package/dbms_ob_limit_calculator_body_mysql.sql b/src/share/inner_table/sys_package/dbms_ob_limit_calculator_body_mysql.sql new file mode 100644 index 0000000000..b07551e04b --- /dev/null +++ b/src/share/inner_table/sys_package/dbms_ob_limit_calculator_body_mysql.sql @@ -0,0 +1,56 @@ +#package_name:dbms_ob_limit_calculator +#author:cxf262476, yangyifei.yyf + +CREATE OR replace PACKAGE BODY dbms_ob_limit_calculator + PROCEDURE phy_res_calculate_by_logic_res_inner( + IN args VARCHAR(1024) DEFAULT '', + OUT res VARCHAR(2048)); + PRAGMA INTERFACE(C, PHY_RES_CALCULATE_BY_LOGIC_RES); + + PROCEDURE phy_res_calculate_by_unit_inner( + IN tenant_id INTEGER, + IN server VARCHAR(64), + OUT res VARCHAR(2048)); + PRAGMA INTERFACE(C, PHY_RES_CALCULATE_BY_UNIT); + + PROCEDURE phy_res_calculate_by_standby_tenant_inner( + IN primary_tenant_id INTEGER, + IN standby_tenant_unit_num INTEGER, + OUT res VARCHAR(2048)); + PRAGMA INTERFACE(C, PHY_RES_CALCULATE_BY_STANDBY_TENANT); + + PROCEDURE calculate_min_phy_res_needed_by_unit( + IN tenant_id INTEGER, + IN server VARCHAR(64)) + BEGIN + DECLARE res VARCHAR(2048); + CALL phy_res_calculate_by_unit_inner(tenant_id, server, res); + SELECT * FROM JSON_TABLE(res, '$[*]' COLUMNS (SVR_IP VARCHAR(64) PATH '$.svr_ip', + SVR_PORT INTEGER PATH '$.svr_port', + TENANT_ID INTEGER PATH '$.tenant_id', + PHYSICAL_RESOURCE_NAME VARCHAR(64) PATH '$.physical_resource_name', + MIN_VALUE BIGINT PATH '$.min_value')) t; + END; + + PROCEDURE calculate_min_phy_res_needed_by_logic_res( + IN args VARCHAR(1024) DEFAULT '') + BEGIN + DECLARE res VARCHAR(2048); + CALL phy_res_calculate_by_logic_res_inner(args, res); + SELECT * FROM JSON_TABLE(res, '$[*]' COLUMNS (PHYSICAL_RESOURCE_NAME VARCHAR(64) PATH '$.physical_resource_name', + MIN_VALUE BIGINT PATH '$.min_value')) t; + END; + + PROCEDURE calculate_min_phy_res_needed_by_standby_tenant( + IN primary_tenant_id INTEGER, + IN standby_tenant_unit_num INTEGER) + BEGIN + DECLARE res VARCHAR(2048); + CALL phy_res_calculate_by_standby_tenant_inner(primary_tenant_id, standby_tenant_unit_num, res); + SELECT * FROM JSON_TABLE(res, '$[*]' COLUMNS (PHYSICAL_RESOURCE_NAME VARCHAR(64) PATH '$.physical_resource_name', + MIN_VALUE BIGINT PATH '$.min_value')) t; + END; + + +END; +// diff --git a/src/share/inner_table/sys_package/dbms_ob_limit_calculator_mysql.sql b/src/share/inner_table/sys_package/dbms_ob_limit_calculator_mysql.sql new file mode 100644 index 0000000000..c39288ae06 --- /dev/null +++ b/src/share/inner_table/sys_package/dbms_ob_limit_calculator_mysql.sql @@ -0,0 +1,14 @@ +#package_name:dbms_ob_limit_calculator +#author:cxf262476, yangyifei.yyf + +CREATE OR REPLACE PACKAGE dbms_ob_limit_calculator + PROCEDURE calculate_min_phy_res_needed_by_unit( + IN tenant_id INTEGER, + IN server VARCHAR(64)); + PROCEDURE calculate_min_phy_res_needed_by_logic_res( + IN args VARCHAR(1024) DEFAULT ''); + PROCEDURE calculate_min_phy_res_needed_by_standby_tenant( + IN primary_tenant_id INTEGER, + IN standby_tenant_unit_num INTEGER); +END; +// diff --git a/src/share/inner_table/table_id_to_name b/src/share/inner_table/table_id_to_name index 18d0e425c5..48ecab9667 100644 --- a/src/share/inner_table/table_id_to_name +++ b/src/share/inner_table/table_id_to_name @@ -1093,6 +1093,8 @@ # 12464: __all_tenant_snapshot_ls_replica_history # BASE_TABLE_NAME # 12466: ENABLED_ROLES # 12469: __all_virtual_tracepoint_info +# 12481: __all_virtual_tenant_resource_limit +# 12482: __all_virtual_tenant_resource_limit_detail # 12487: __all_virtual_nic_info # 15009: ALL_VIRTUAL_SQL_AUDIT # 15009: __all_virtual_sql_audit # BASE_TABLE_NAME @@ -1685,6 +1687,10 @@ # 15440: __all_index_usage_info # BASE_TABLE_NAME # 15445: ALL_VIRTUAL_TRACEPOINT_INFO # 15445: __all_virtual_tracepoint_info # BASE_TABLE_NAME +# 15450: ALL_VIRTUAL_TENANT_RESOURCE_LIMIT +# 15450: __all_virtual_tenant_resource_limit # BASE_TABLE_NAME +# 15451: ALL_VIRTUAL_TENANT_RESOURCE_LIMIT_DETAIL +# 15451: __all_virtual_tenant_resource_limit_detail # BASE_TABLE_NAME # 15456: ALL_VIRTUAL_NIC_INFO # 15456: __all_virtual_nic_info # BASE_TABLE_NAME # 20001: GV$OB_PLAN_CACHE_STAT @@ -2096,6 +2102,10 @@ # 21540: DBA_MVREF_STMT_STATS # 21543: GV$OB_TRACEPOINT_INFO # 21544: V$OB_TRACEPOINT_INFO +# 21550: GV$OB_TENANT_RESOURCE_LIMIT +# 21551: V$OB_TENANT_RESOURCE_LIMIT +# 21552: GV$OB_TENANT_RESOURCE_LIMIT_DETAIL +# 21553: V$OB_TENANT_RESOURCE_LIMIT_DETAIL # 21580: GV$OB_NIC_INFO # 21581: V$OB_NIC_INFO # 25001: DBA_SYNONYMS @@ -2553,6 +2563,10 @@ # 28216: V$OB_LS_SNAPSHOTS # 28221: GV$OB_TRACEPOINT_INFO # 28222: V$OB_TRACEPOINT_INFO +# 28224: GV$OB_TENANT_RESOURCE_LIMIT +# 28225: V$OB_TENANT_RESOURCE_LIMIT +# 28226: GV$OB_TENANT_RESOURCE_LIMIT_DETAIL +# 28227: V$OB_TENANT_RESOURCE_LIMIT_DETAIL # 28230: GV$OB_NIC_INFO # 28231: V$OB_NIC_INFO # 14999: __idx_11003_all_virtual_plan_cache_stat_i1 diff --git a/src/share/ob_rpc_struct.cpp b/src/share/ob_rpc_struct.cpp index 11d6e0a758..17441da716 100755 --- a/src/share/ob_rpc_struct.cpp +++ b/src/share/ob_rpc_struct.cpp @@ -6734,6 +6734,33 @@ int ObGetLSSyncScnRes::assign(const ObGetLSSyncScnRes &other) } return ret; } +OB_SERIALIZE_MEMBER(ObGetTenantResArg, tenant_id_); +OB_SERIALIZE_MEMBER(ObTenantLogicalRes, server_, arg_); +int ObTenantLogicalRes::init(const ObAddr &server, const ObUserResourceCalculateArg &arg) +{ + int ret = OB_SUCCESS; + if (OB_UNLIKELY(!server.is_valid())) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("server is invalid", KR(ret), K(server)); + } else if (OB_FAIL(arg_.assign(arg))) { + LOG_WARN("failed to assign arg", KR(ret), K(arg)); + } else { + server_ = server; + } + return ret; +} +int ObTenantLogicalRes::assign(const ObTenantLogicalRes &other) +{ + int ret = OB_SUCCESS; + if (this != &other) { + if (OB_FAIL(arg_.assign(other.arg_))) { + LOG_WARN("failed to assign", KR(ret), K(other)); + } else { + server_ = other.server_; + } + } + return ret; +} OB_SERIALIZE_MEMBER(ObGetLSReplayedScnArg, tenant_id_, ls_id_, all_replica_); diff --git a/src/share/ob_rpc_struct.h b/src/share/ob_rpc_struct.h index be8670c455..3ee8563e9c 100755 --- a/src/share/ob_rpc_struct.h +++ b/src/share/ob_rpc_struct.h @@ -74,6 +74,7 @@ #include "share/restore/ob_import_arg.h" #include "share/tenant_snapshot/ob_tenant_snapshot_id.h" #include "share/location_cache/ob_location_update_task.h" +#include "share/resource_limit_calculator/ob_resource_limit_calculator.h"//ObUserResourceCalculateArg namespace oceanbase { @@ -7782,6 +7783,58 @@ public: share::SCN cur_restore_source_max_scn_; }; +struct ObGetTenantResArg +{ + OB_UNIS_VERSION(1); +public: + ObGetTenantResArg() : tenant_id_(OB_INVALID_TENANT_ID) {} + ObGetTenantResArg(const uint64_t tenant_id) : tenant_id_(tenant_id) {} + ~ObGetTenantResArg() {} + bool is_valid() const + { + return is_valid_tenant_id(tenant_id_); + } + int assign(const ObGetTenantResArg &other) + { + tenant_id_ = other.tenant_id_; + return OB_SUCCESS; + } + TO_STRING_KV(K_(tenant_id)); + uint64_t get_tenant_id() const + { + return tenant_id_; + } +private: + DISALLOW_COPY_AND_ASSIGN(ObGetTenantResArg); + uint64_t tenant_id_; +}; +struct ObTenantLogicalRes +{ + OB_UNIS_VERSION(1); +public: + ObTenantLogicalRes() : server_(), arg_() {} + ~ObTenantLogicalRes() {} + bool is_valid() const + { + return server_.is_valid(); + } + int init(const ObAddr &server, const share::ObUserResourceCalculateArg &arg); + int assign(const ObTenantLogicalRes &other); + TO_STRING_KV(K_(server), K_(arg)); + ObAddr get_server() const + { + return server_; + } + const share::ObUserResourceCalculateArg& get_arg() const + { + return arg_; + } +private: + DISALLOW_COPY_AND_ASSIGN(ObTenantLogicalRes); + ObAddr server_; + share::ObUserResourceCalculateArg arg_; + +}; struct ObGetLSReplayedScnArg { OB_UNIS_VERSION(1); @@ -7859,6 +7912,7 @@ private: common::ObAddr self_addr_;//add in 4.3.0 }; + struct ObSwitchTenantArg { OB_UNIS_VERSION(1); diff --git a/src/share/ob_srv_rpc_proxy.h b/src/share/ob_srv_rpc_proxy.h index caf78e1c03..bb623d7619 100755 --- a/src/share/ob_srv_rpc_proxy.h +++ b/src/share/ob_srv_rpc_proxy.h @@ -21,6 +21,7 @@ #include "observer/ob_server_struct.h" #include "observer/net/ob_net_endpoint_ingress_rpc_struct.h" #include "share/ob_heartbeat_struct.h" +#include "share/resource_limit_calculator/ob_resource_commmon.h" #include "observer/table_load/control/ob_table_load_control_rpc_struct.h" #include "rpc/obrpc/ob_rpc_reverse_keepalive_struct.h" @@ -256,6 +257,8 @@ public: RPC_S(PR5 cancel_gather_stats, OB_CANCEL_GATHER_STATS, (ObCancelGatherStatsArg)); RPC_S(PR5 force_set_tenant_log_disk, OB_LOG_FORCE_SET_TENANT_LOG_DISK, (obrpc::ObForceSetTenantLogDiskArg)); RPC_S(PR5 dump_server_usage, OB_FORCE_DUMP_SERVER_USAGE, (obrpc::ObDumpServerUsageRequest), obrpc::ObDumpServerUsageResult); + RPC_AP(PR5 get_tenant_logical_resource, OB_CAL_STANDBY_TENANT_PHY_RESOURCE, (obrpc::ObGetTenantResArg), obrpc::ObTenantLogicalRes); + RPC_S(PR5 phy_res_calculate_by_unit, OB_CAL_UNIT_PHY_RESOURCE, (obrpc::Int64), share::ObMinPhyResourceResult); RPC_S(PR5 rpc_reverse_keepalive, OB_RPC_REVERSE_KEEPALIVE, (obrpc::ObRpcReverseKeepaliveArg), obrpc::ObRpcReverseKeepaliveResp); }; // end of class ObSrvRpcProxy diff --git a/src/share/rc/ob_tenant_base.h b/src/share/rc/ob_tenant_base.h index 35eaf00452..301bbc38ee 100755 --- a/src/share/rc/ob_tenant_base.h +++ b/src/share/rc/ob_tenant_base.h @@ -215,6 +215,7 @@ class ObTenantErrsimModuleMgr; class ObTenantErrsimEventMgr; class ObSharedMemAllocMgr; class ObIndexUsageInfoMgr; +class ObResourceLimitCalculator; namespace schema { class ObTenantSchemaService; @@ -357,6 +358,7 @@ using ObTableScanIteratorObjPool = common::ObServerObjectPool +#include "lib/container/ob_array_serialization.h" +#include "lib/utility/ob_print_utils.h" +#include "lib/utility/ob_unify_serialize.h" + +namespace oceanbase +{ +namespace share +{ +enum ObLogicResourceType : int64_t +{ + INVALID_LOGIC_RESOURCE = 0, +#define DEF_RESOURCE_LIMIT_CALCULATOR(n, type, name, subhandler) \ + LOGIC_RESOURCE_##type = n, +#include "share/resource_limit_calculator/ob_resource_limit_calculator_def.h" +#undef DEF_RESOURCE_LIMIT_CALCULATOR + + MAX_LOGIC_RESOURCE +}; + +const char *get_logic_res_type_name(const int64_t type); +int64_t get_logic_res_type_by_name(const char *name); +bool is_valid_logic_res_type(const int64_t type); + +enum ObPhyResourceType : int64_t +{ + INVALID_PHY_RESOURCE = 0, +#define DEF_PHY_RES(n, type, name) \ + PHY_RESOURCE_##type = n, +#include "share/resource_limit_calculator/ob_resource_limit_calculator_def.h" +#undef DEF_PHY_RES + + MAX_PHY_RESOURCE +}; + +const char *get_phy_res_type_name(const int64_t type); +bool is_valid_phy_res_type(const int64_t type); + +enum ObLogicResourceConstraintType : int64_t +{ + INVALID_CONSTRAINT_TYPE = 0, +#define DEF_RESOURCE_CONSTRAINT(n, type, name) \ + type##_CONSTRAINT = n, +#include "share/resource_limit_calculator/ob_resource_limit_calculator_def.h" +#undef DEF_RESOURCE_CONSTRAINT + + MAX_CONSTRAINT +}; + +const char *get_constraint_type_name(const int64_t type); +bool is_valid_res_constraint_type(const int64_t type); + +struct ObResourceInfo +{ +public: + ObResourceInfo() { reset(); } + ~ObResourceInfo() { reset(); } + void reset() + { + curr_utilization_ = 0; + max_utilization_ = 0; + reserved_value_ = 0; + min_constraint_value_ = 0; + min_constraint_type_ = INVALID_CONSTRAINT_TYPE; + } + + DECLARE_TO_STRING; +public: + int64_t curr_utilization_; + int64_t max_utilization_; + int64_t reserved_value_; + int64_t min_constraint_value_; + int64_t min_constraint_type_; +}; + +struct ObResoureConstraintValue +{ +public: +ObResoureConstraintValue() :constraint_values_() {} + ~ObResoureConstraintValue() {} + void reset() + { + for (int64_t i = 0; i < constraint_values_.count(); i++) { + constraint_values_[i] = INT64_MAX; + } + } + void get_min_constraint(int64_t &type, int64_t &value) + { + int64_t min_type = 0; + int64_t min_value = INT64_MAX; + for (int64_t i = 0; i < constraint_values_.count(); i++) { + if (constraint_values_[i] < min_value) { + min_type = i; + min_value = constraint_values_[i]; + } + } + type = min_type; + value = min_value; + } + int get_type_value(const int64_t type, int64_t &value) const; + int set_type_value(const int64_t type, const int64_t value); + int get_copy_assign_ret() const + { return constraint_values_.get_copy_assign_ret(); } + DECLARE_TO_STRING; +public: + common::ObSArray constraint_values_; + DISALLOW_COPY_AND_ASSIGN(ObResoureConstraintValue); +}; + +struct ObMinPhyResourceResult +{ + OB_UNIS_VERSION_V(1); +public: + ObMinPhyResourceResult() : min_phy_resource_value_() {} + ~ObMinPhyResourceResult() { reset(); } + int set_type_value(const int64_t type, const int64_t value); + int get_type_value(const int64_t type, int64_t &value) const; + int inc_update(const ObMinPhyResourceResult &res); + int get_copy_assign_ret() const + { return min_phy_resource_value_.get_copy_assign_ret(); } + void reset() + { + for (int i = 0; i < min_phy_resource_value_.count(); i++) { + min_phy_resource_value_[i] = 0; + } + } + DECLARE_TO_STRING; +private: + common::ObSArray min_phy_resource_value_; +}; + +} //end share +} //end oceanbase + +#endif diff --git a/src/share/resource_limit_calculator/ob_resource_limit_calculator.cpp b/src/share/resource_limit_calculator/ob_resource_limit_calculator.cpp new file mode 100644 index 0000000000..25edeb9233 --- /dev/null +++ b/src/share/resource_limit_calculator/ob_resource_limit_calculator.cpp @@ -0,0 +1,374 @@ +/** + * Copyright (c) 2024 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. + */ + +#define USING_LOG_PREFIX SHARE +#include "share/rc/ob_tenant_base.h" +#include "share/resource_limit_calculator/ob_resource_limit_calculator.h" +#include "storage/tx_storage/ob_ls_service.h" + +namespace oceanbase +{ +namespace share +{ + +void ObLogicResourceStatIterator::reset() +{ + is_ready_ = false; + curr_type_ = 0; +} + +int ObLogicResourceStatIterator::set_ready() +{ + int ret = OB_SUCCESS; + + if (is_ready_) { + LOG_WARN("ObLogicResourceStatIterator is already ready"); + ret = OB_ERR_UNEXPECTED; + } else { + is_ready_ = true; + } + return ret; +} + +int ObLogicResourceStatIterator::get_next(ObResourceInfo &info) +{ + int ret = OB_SUCCESS; + if (!is_ready()) { + ret = OB_NOT_INIT; + LOG_WARN("ObLogicResourceStatIterator is not ready", K(ret)); + } else { + bool need_retry = false; + do { + need_retry = false; + curr_type_++; + if (curr_type_ >= MAX_LOGIC_RESOURCE) { + ret = OB_ITER_END; + } else if (!is_valid_logic_res_type(curr_type_)) { + need_retry = true; + } else if (OB_FAIL(MTL(ObResourceLimitCalculator *)->get_logic_resource_stat(curr_type_, + info))) { + LOG_WARN("get_next failed", K(ret), K(curr_type_)); + } + } while (need_retry); + } + return ret; +} + +int ObLogicResourceStatIterator::get_next_type() +{ + int ret = OB_SUCCESS; + if (!is_ready()) { + ret = OB_NOT_INIT; + LOG_WARN("ObLogicResourceStatIterator is not ready", K(ret)); + } else { + bool need_retry = false; + do { + need_retry = false; + curr_type_++; + if (curr_type_ >= MAX_LOGIC_RESOURCE) { + ret = OB_ITER_END; + } else if (!is_valid_logic_res_type(curr_type_)) { + need_retry = true; + } + } while (need_retry); + } + return ret; +} + +void ObResourceConstraintIterator::reset() +{ + is_ready_ = false; + res_type_ = 0; + curr_constraint_type_ = 0; + res_.reset(); +} + +int ObResourceConstraintIterator::set_ready(const int64_t res_type) +{ + int ret = OB_SUCCESS; + + if (is_ready_) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("ObResourceConstraintIterator is already ready", K(ret)); + } else if (!is_valid_logic_res_type(res_type)) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid argument", K(ret), K(res_type)); + } else if (OB_FAIL(MTL(ObResourceLimitCalculator *)->get_logic_resource_constraint_value(res_type, + res_))) { + LOG_WARN("get resource constraint value failed", K(ret), K(res_type)); + } else { + res_type_ = res_type; + is_ready_ = true; + } + return ret; +} + +int ObResourceConstraintIterator::get_next(int64_t &val) +{ + int ret = OB_SUCCESS; + if (!is_ready()) { + ret = OB_NOT_INIT; + LOG_WARN("ObResourceConstraintIterator is not ready", K(ret)); + } else { + bool need_retry = false; + do { + need_retry = false; + curr_constraint_type_++; + if (curr_constraint_type_ >= MAX_CONSTRAINT) { + ret = OB_ITER_END; + } else if (!is_valid_res_constraint_type(curr_constraint_type_)) { + need_retry = true; + } else if (OB_FAIL(res_.get_type_value(curr_constraint_type_, val))) { + LOG_WARN("get type value failed", K(ret), K(curr_constraint_type_), K(val)); + } + } while (need_retry); + } + return ret; +} + +int ObUserResourceCalculateArg::set_type_value(const int64_t type, const int64_t value) +{ + int ret = OB_SUCCESS; + if (!is_valid_logic_res_type(type)) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid argument", K(ret), K(type)); + } else { + int64_t count = needed_num_.count(); + while (OB_SUCC(ret) && count < MAX_LOGIC_RESOURCE) { + if (OB_FAIL(needed_num_.push_back(0))) { + LOG_WARN("set type value failed", K(ret)); + } else { + count = needed_num_.count(); + } + } + if (OB_SUCC(ret)) { + needed_num_[type] = value; + } + } + return ret; +} + +int ObUserResourceCalculateArg::get_type_value(const int64_t type, int64_t &value) const +{ + int ret = OB_SUCCESS; + if (!is_valid_logic_res_type(type)) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid argument", K(ret), K(type)); + } else if (type < needed_num_.count()) { + value = needed_num_[type]; + } else { + value = 0; + } + return ret; +} + +OB_SERIALIZE_MEMBER(ObUserResourceCalculateArg, needed_num_); + +int ObUserResourceCalculateArg::assign(const ObUserResourceCalculateArg &other) +{ + int ret = OB_SUCCESS; + if (this != &other) { + if (OB_FAIL(needed_num_.assign(other.needed_num_))) { + LOG_WARN("failed to needed num", KR(ret), K(other)); + } + } + return ret; +} + +DEF_TO_STRING(ObUserResourceCalculateArg) +{ + int64_t pos = 0; + J_OBJ_START(); + for (int64_t i = LOGIC_RESOURCE_LS; i < needed_num_.count(); i++) { + J_KV(get_logic_res_type_name(i), needed_num_[i]); + J_COMMA(); + } + J_OBJ_END(); + return pos; +} + +int ObResourceLimitCalculator::mtl_init(ObResourceLimitCalculator *&calculator) +{ + return calculator->init(); +} + +int ObResourceLimitCalculator::init() +{ + int ret = OB_SUCCESS; + if (IS_INIT) { + ret = OB_INIT_TWICE; + LOG_WARN("resource limit calculator already initialized", K(ret)); + } else { + WLockGuard guard(lock_); +#define DEF_RESOURCE_LIMIT_CALCULATOR(n, type, name, subhandler) \ + if (OB_SUCC(ret)) { \ + handlers_[n] = subhandler; \ + } +#include "share/resource_limit_calculator/ob_resource_limit_calculator_def.h" +#undef DEF_RESOURCE_LIMIT_CALCULATOR + is_inited_ = true; + } + return ret; +} + +int ObResourceLimitCalculator::get_logic_resource_stat( + const int64_t type, + ObResourceInfo &val) +{ + int ret = OB_SUCCESS; + ObIResourceLimitCalculatorHandler *handler = NULL; + RLockGuard guard(lock_); + if (IS_NOT_INIT) { + ret = OB_NOT_RUNNING; + LOG_WARN("resource limit calculator not running", K(ret)); + } else if (!is_valid_logic_res_type(type)) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid resource type", K(ret), K(type)); + } else if (OB_ISNULL(handler = handlers_[type])) { + ret = OB_NOT_RUNNING; + LOG_WARN("the tenant may destroyed", K(ret), KP(handler)); + } else if (OB_FAIL(handler->get_current_info(val))) { + LOG_WARN("get resource stat failed", K(ret), K(type)); + } + return ret; +} + +int ObResourceLimitCalculator::get_logic_resource_constraint_value( + const int64_t type, + ObResoureConstraintValue &val) +{ + int ret = OB_SUCCESS; + ObIResourceLimitCalculatorHandler *handler = NULL; + RLockGuard guard(lock_); + if (IS_NOT_INIT) { + ret = OB_NOT_RUNNING; + LOG_WARN("resource limit calculator not running", K(ret)); + } else if (!is_valid_logic_res_type(type)) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid resource type", K(ret), K(type)); + } else if (OB_ISNULL(handler = handlers_[type])) { + ret = OB_NOT_RUNNING; + LOG_WARN("the tenant may destroyed", K(ret), KP(handler)); + } else if (OB_FAIL(handler->get_resource_constraint_value(val))) { + LOG_WARN("get resource stat failed", K(ret), K(type)); + } + return ret; +} + +int ObResourceLimitCalculator::get_tenant_min_phy_resource_value( + ObMinPhyResourceResult &res) +{ + int ret = OB_SUCCESS; + ObIResourceLimitCalculatorHandler *handler = NULL; + ObMinPhyResourceResult min_res; + ObMinPhyResourceResult tmp; + if (IS_NOT_INIT) { + ret = OB_NOT_RUNNING; + LOG_WARN("resource limit calculator not running", K(ret)); + } else { + RLockGuard guard(lock_); +#define DEF_RESOURCE_LIMIT_CALCULATOR(n, type, name, subhandler) \ + if (OB_SUCC(ret)) { \ + if (OB_ISNULL(handler = handlers_[n])) { \ + ret = OB_NOT_RUNNING; \ + LOG_WARN("the tenant may destroyed", K(ret), K(n), KP(handler)); \ + } else if (OB_FAIL(handler->cal_min_phy_resource_needed(tmp))) { \ + LOG_WARN("get resource stat failed", K(ret), K(n), K(#name)); \ + } else if (OB_FAIL(min_res.inc_update(tmp))) { \ + LOG_WARN("inc_update failed", K(min_res), K(tmp)); \ + } else { \ + tmp.reset(); \ + } \ + } +#include "share/resource_limit_calculator/ob_resource_limit_calculator_def.h" +#undef DEF_RESOURCE_LIMIT_CALCULATOR + + if (OB_SUCC(ret)) { + res = min_res; + ret = res.get_copy_assign_ret(); + } + } + return ret; +} + +int ObResourceLimitCalculator::get_tenant_min_phy_resource_value( + const ObUserResourceCalculateArg &arg, + ObMinPhyResourceResult &res) +{ + int ret = OB_SUCCESS; + ObIResourceLimitCalculatorHandler *handler = NULL; + ObMinPhyResourceResult min_res; + ObMinPhyResourceResult tmp; + int64_t res_type = 0; + int64_t need_num = 0; + if (IS_NOT_INIT) { + ret = OB_NOT_RUNNING; + LOG_WARN("resource limit calculator not running", K(ret)); + } else { + RLockGuard guard(lock_); +#define DEF_RESOURCE_LIMIT_CALCULATOR(n, type, name, subhandler) \ + if (OB_SUCC(ret)) { \ + if (OB_ISNULL(handler = handlers_[n])) { \ + ret = OB_NOT_RUNNING; \ + LOG_WARN("the tenant may destroyed", K(ret), K(n), KP(handler)); \ + } else if (OB_FAIL(arg.get_type_value(n, need_num))) { \ + LOG_WARN("get needed num failed", K(ret), K(n)); \ + } else if (OB_FAIL(handler->cal_min_phy_resource_needed(need_num, \ + tmp))) { \ + LOG_WARN("get resource stat failed", K(ret), K(n), K(need_num)); \ + } else if (OB_FAIL(min_res.inc_update(tmp))) { \ + LOG_WARN("inc_update failed", K(ret), K(min_res), K(tmp)); \ + } else { \ + tmp.reset(); \ + } \ + } +#include "share/resource_limit_calculator/ob_resource_limit_calculator_def.h" +#undef DEF_RESOURCE_LIMIT_CALCULATOR + + if (OB_SUCC(ret)) { + res = min_res; + ret = res.get_copy_assign_ret(); + } + } + return ret; +} + +int ObResourceLimitCalculator::get_tenant_logical_resource(ObUserResourceCalculateArg &arg) +{ + int ret = OB_SUCCESS; + arg.reset(); + ObLogicResourceStatIterator iter; + if (IS_NOT_INIT) { + ret = OB_NOT_RUNNING; + LOG_WARN("resource limit calculator not running", KR(ret)); + } else if (OB_FAIL(iter.set_ready())) { + LOG_WARN("failed to set ready", KR(ret)); + } else { + ObResourceInfo info; + while(OB_SUCC(ret)) { + if (OB_FAIL(iter.get_next(info))) { + if (OB_ITER_END != ret) { + LOG_WARN("failed to get next", KR(ret)); + } + } else if (OB_FAIL(arg.set_type_value(iter.get_curr_type(), info.curr_utilization_))) { + LOG_WARN("failed to set type value", KR(ret), K(info)); + } + } + if (OB_ITER_END == ret) { + ret = OB_SUCCESS; + } + } + return ret; +} + +} // end namespace share +} // end namespace oceanbase diff --git a/src/share/resource_limit_calculator/ob_resource_limit_calculator.h b/src/share/resource_limit_calculator/ob_resource_limit_calculator.h new file mode 100644 index 0000000000..050ea8b2a1 --- /dev/null +++ b/src/share/resource_limit_calculator/ob_resource_limit_calculator.h @@ -0,0 +1,139 @@ +/** + * Copyright (c) 2024 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_SHARE_OB_RESOURCE_LIMIT_CALCULCATOR_H +#define OCEANBASE_SHARE_OB_RESOURCE_LIMIT_CALCULCATOR_H + +#include "lib/lock/ob_spin_rwlock.h" +#include "share/resource_limit_calculator/ob_resource_commmon.h" + +namespace oceanbase +{ +namespace share +{ + +class ObIResourceLimitCalculatorHandler +{ +public: + virtual int get_current_info(ObResourceInfo &info) = 0; + virtual int get_resource_constraint_value(ObResoureConstraintValue &constraint_value) = 0; + virtual int cal_min_phy_resource_needed(ObMinPhyResourceResult &min_phy_res) = 0; + virtual int cal_min_phy_resource_needed(const int64_t num, ObMinPhyResourceResult &min_phy_res) = 0; +}; + +class ObLogicResourceStatIterator +{ +public: + ObLogicResourceStatIterator() : is_ready_(false), + curr_type_(0) {} + ~ObLogicResourceStatIterator() {} + void reset(); + + int set_ready(); + bool is_ready() const { return is_ready_; } + + int get_next(ObResourceInfo &info); + int get_next_type(); + int64_t get_curr_type() const { return curr_type_; } +private: + bool is_ready_; + int64_t curr_type_; +}; + +class ObResourceConstraintIterator +{ +public: + ObResourceConstraintIterator() : is_ready_(false), + res_type_(0), + curr_constraint_type_(0), + res_() + {} + ~ObResourceConstraintIterator() {} + void reset(); + + int set_ready(const int64_t res_type); + bool is_ready() const { return is_ready_; } + int get_next(int64_t &val); + int64_t get_curr_type() const { return curr_constraint_type_; } +private: + bool is_ready_; + // which resource's constraint + int64_t res_type_; + int64_t curr_constraint_type_; + ObResoureConstraintValue res_; +}; + +struct ObUserResourceCalculateArg +{ + OB_UNIS_VERSION_V(1); +public: + ObUserResourceCalculateArg() : needed_num_() {} + ~ObUserResourceCalculateArg() {} + void reset() + { + for (int i = 0; i < needed_num_.count(); i++) { + needed_num_[i] = 0; + } + } + int get_type_value(const int64_t type, int64_t &value) const; + int set_type_value(const int64_t type, const int64_t value); + int assign(const ObUserResourceCalculateArg &other); + int64_t count() const + { + return needed_num_.count(); + } + + DECLARE_TO_STRING; +private: + common::ObSArray needed_num_; + DISALLOW_COPY_AND_ASSIGN(ObUserResourceCalculateArg); +}; + +class ObResourceLimitCalculator +{ + using RWLock = common::SpinRWLock; + using RLockGuard = common::SpinRLockGuard; + using WLockGuard = common::SpinWLockGuard; +public: + ObResourceLimitCalculator() : is_inited_(false) { } + ~ObResourceLimitCalculator() { destroy(); } + static int mtl_init(ObResourceLimitCalculator *&calculator); + int init(); + void destroy() + { + WLockGuard guard(lock_); + is_inited_ = false; + for (int i = 0; i < MAX_LOGIC_RESOURCE; i++) { + handlers_[i] = NULL; + } + } + + // DISPLAYER + int get_logic_resource_stat(const int64_t type, + ObResourceInfo &val); + int get_logic_resource_constraint_value(const int64_t type, + ObResoureConstraintValue &val); + + int get_tenant_logical_resource(ObUserResourceCalculateArg &arg); + // CALCULCATOR + int get_tenant_min_phy_resource_value(ObMinPhyResourceResult &res); + int get_tenant_min_phy_resource_value(const ObUserResourceCalculateArg &arg, + ObMinPhyResourceResult &res); +private: + bool is_inited_; + RWLock lock_; + ObIResourceLimitCalculatorHandler *handlers_[MAX_LOGIC_RESOURCE]; +}; + +} // end namespace share +} // end namespace oceanbase +#endif diff --git a/src/share/resource_limit_calculator/ob_resource_limit_calculator_def.h b/src/share/resource_limit_calculator/ob_resource_limit_calculator_def.h new file mode 100644 index 0000000000..e9138ef919 --- /dev/null +++ b/src/share/resource_limit_calculator/ob_resource_limit_calculator_def.h @@ -0,0 +1,36 @@ +/** + * Copyright (c) 2024 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. + */ + +// DEF_RESOURCE_LIMIT_CALCULATOR(n, type, name, subhandler) +#ifdef DEF_RESOURCE_LIMIT_CALCULATOR +DEF_RESOURCE_LIMIT_CALCULATOR(1, LS, ls, MTL(ObLSService*)) +DEF_RESOURCE_LIMIT_CALCULATOR(2, TABLET, tablet, MTL(ObTenantMetaMemMgr*)->get_t3m_limit_calculator()) +#endif + +// DEF_PHY_RES(n, type, name) +#ifdef DEF_PHY_RES +DEF_PHY_RES(1, MEMSTORE, memstore) +DEF_PHY_RES(2, MEMORY, memory) +DEF_PHY_RES(3, DATA_DISK, data_disk) +DEF_PHY_RES(4, CLOG_DISK, clog_disk) +DEF_PHY_RES(5, CPU, cpu) +#endif + +// DEF_RESOURCE_CONSTRAINT(n, type, name) +#ifdef DEF_RESOURCE_CONSTRAINT +DEF_RESOURCE_CONSTRAINT(1, CONFIGURATION, configuration) +DEF_RESOURCE_CONSTRAINT(2, MEMSTORE, memstore) +DEF_RESOURCE_CONSTRAINT(3, MEMORY, memory) +DEF_RESOURCE_CONSTRAINT(4, DATA_DISK, data_disk) +DEF_RESOURCE_CONSTRAINT(5, CLOG_DISK, clog_disk) +DEF_RESOURCE_CONSTRAINT(6, CPU, cpu) +#endif diff --git a/src/storage/meta_mem/ob_tablet_pointer_map.cpp b/src/storage/meta_mem/ob_tablet_pointer_map.cpp index 0600cd6e29..b62951d0f4 100644 --- a/src/storage/meta_mem/ob_tablet_pointer_map.cpp +++ b/src/storage/meta_mem/ob_tablet_pointer_map.cpp @@ -18,6 +18,22 @@ namespace oceanbase namespace storage { +ObTabletPointerMap::ObTabletPointerMap() + : ObResourceMap(), max_count_(0) +{ +} + +int ObTabletPointerMap::set(const ObTabletMapKey &key, ObTabletPointer &ptr) +{ + int ret = OB_SUCCESS; + if (OB_FAIL(ResourceMap::set(key, ptr))) { + STORAGE_LOG(WARN, "fail to set into ResourceMap", K(ret), K(key)); + } else if (count() > ATOMIC_LOAD(&max_count_)) { + ATOMIC_INC(&max_count_); + } + return ret; +} + int ObTabletPointerMap::erase(const ObTabletMapKey &key, ObMetaObjGuard &guard) { int ret = common::OB_SUCCESS; diff --git a/src/storage/meta_mem/ob_tablet_pointer_map.h b/src/storage/meta_mem/ob_tablet_pointer_map.h index 256e6ed126..a1c95e28cd 100644 --- a/src/storage/meta_mem/ob_tablet_pointer_map.h +++ b/src/storage/meta_mem/ob_tablet_pointer_map.h @@ -42,6 +42,8 @@ class ObTabletPointerMap : public ObResourceMap { public: typedef ObResourceMap ResourceMap; + ObTabletPointerMap(); + int set(const ObTabletMapKey &key, ObTabletPointer &ptr); // overwrite int erase(const ObTabletMapKey &key, ObMetaObjGuard &guard); int exist(const ObTabletMapKey &key, bool &is_exist); int get_meta_obj(const ObTabletMapKey &key, ObMetaObjGuard &guard); @@ -77,6 +79,7 @@ public: template int for_each_value_store(Operator &op); int wash_meta_obj(const ObTabletMapKey &key, ObMetaObjGuard &guard, void *&free_obj); int64_t count() const { return ResourceMap::map_.size(); } + OB_INLINE int64_t max_count() const { return ATOMIC_LOAD(&max_count_); } private: // used when tablet object and memory is hold by external allocator @@ -108,6 +111,9 @@ private: public: using ObResourceMap::ObResourceMap; + +private: + int64_t max_count_; }; // ATTENTION: operator should be read-only operations diff --git a/src/storage/meta_mem/ob_tenant_meta_mem_mgr.cpp b/src/storage/meta_mem/ob_tenant_meta_mem_mgr.cpp index e78ecae8b7..f50a248024 100644 --- a/src/storage/meta_mem/ob_tenant_meta_mem_mgr.cpp +++ b/src/storage/meta_mem/ob_tenant_meta_mem_mgr.cpp @@ -194,6 +194,7 @@ ObTenantMetaMemMgr::ObTenantMetaMemMgr(const uint64_t tenant_id) lock_memtable_pool_(tenant_id, MAX_LOCK_MEMTABLE_CNT_IN_OBJ_POOL, "LockMemObj", ObCtxIds::DEFAULT_CTX_ID), meta_cache_io_allocator_(), last_access_tenant_config_ts_(-1), + t3m_limit_calculator_(*this), is_tablet_leak_checker_enabled_(false), is_inited_(false) { @@ -2142,6 +2143,98 @@ int ObTenantMetaMemMgr::dump_tablet_info() return ret; } +int ObTenantMetaMemMgr::ObT3MResourceLimitCalculatorHandler:: + get_current_info(share::ObResourceInfo &info) +{ + int ret = OB_SUCCESS; + ObResoureConstraintValue constraint_value; + if (!t3m_.is_inited_) { + ret = OB_NOT_INIT; + LOG_WARN("t3m not inited, the resource info may not right.", K(ret)); + } else if (OB_FAIL(get_resource_constraint_value(constraint_value))) { + LOG_WARN("get resource constraint value failed", K(ret)); + } else { + info.curr_utilization_ = t3m_.tablet_map_.count(); + info.max_utilization_ = t3m_.tablet_map_.max_count(); + info.reserved_value_ = 0; // reserve value will be used later + constraint_value.get_min_constraint(info.min_constraint_type_, info.min_constraint_value_); + } + return ret; +} + +int ObTenantMetaMemMgr::ObT3MResourceLimitCalculatorHandler:: + get_resource_constraint_value(share::ObResoureConstraintValue &constraint_value) +{ + int ret = OB_SUCCESS; + // Get tenant config + omt::ObTenantConfigGuard tenant_config(TENANT_CONF(MTL_ID())); + const int64_t config_tablet_per_gb = tenant_config.is_valid() ? + tenant_config->_max_tablet_cnt_per_gb : + DEFAULT_TABLET_CNT_PER_GB; + const int64_t config_mem_percentage = tenant_config.is_valid() ? + tenant_config->_storage_meta_memory_limit_percentage : + OB_DEFAULT_META_OBJ_PERCENTAGE_LIMIT; + const int64_t tenant_mem = lib::get_tenant_memory_limit(MTL_ID()); + // Calculate config constraint : (tenant_mem / 1GB) * config_tablet_per_gb + const int64_t config_constraint = tenant_mem / (1.0 * 1024 * 1024 * 1024 /* 1GB */) * config_tablet_per_gb; + // Calculate memory constraint : (tenant_mem * config_mem_percentage) / 200MB * 20000 + const int64_t memory_constraint = tenant_mem * (config_mem_percentage / 100.0) / + (200.0 * 1024 * 1024 /* 200MB */) * + DEFAULT_TABLET_CNT_PER_GB; + // Set into constraint value + if (OB_FAIL(constraint_value.set_type_value(CONFIGURATION_CONSTRAINT, config_constraint))) { + LOG_WARN("set type value failed", K(ret), K(CONFIGURATION_CONSTRAINT), + K(config_tablet_per_gb), K(tenant_mem), K(config_constraint)); + } else if (OB_FAIL(constraint_value.set_type_value(MEMORY_CONSTRAINT, memory_constraint))) { + LOG_WARN("set type value failed", K(ret), K(MEMORY_CONSTRAINT), + K(config_mem_percentage), K(tenant_mem), K(memory_constraint)); + } + return ret; +} + +int ObTenantMetaMemMgr::ObT3MResourceLimitCalculatorHandler:: + cal_min_phy_resource_needed(const int64_t num, share::ObMinPhyResourceResult &min_phy_res) +{ + int ret = OB_SUCCESS; + int64_t cal_num = num >= 0 ? num : 0; // We treat unexpected negative input numbers as zero. + // Get tenant memory + omt::ObTenantConfigGuard tenant_config(TENANT_CONF(MTL_ID())); + const int64_t config_tablet_per_gb = tenant_config.is_valid() ? + tenant_config->_max_tablet_cnt_per_gb : + DEFAULT_TABLET_CNT_PER_GB; + const int64_t config_mem_percentage = tenant_config.is_valid() ? + tenant_config->_storage_meta_memory_limit_percentage : + OB_DEFAULT_META_OBJ_PERCENTAGE_LIMIT; + // Inverse calculate through config formula and memory formula + const int64_t memory_constraint_formula_inverse = + cal_num * (200.0 * 1024 * 1024 /* 200MB */) / DEFAULT_TABLET_CNT_PER_GB / (config_mem_percentage / 100.0); + const int64_t config_constraint_formula_inverse = + cal_num * (1.0 * 1024 * 1024 * 1024 /* 1GB */) / config_tablet_per_gb; + // Set into MinPhyResourceResult + const int64_t minimum_physics_needed = std::max(memory_constraint_formula_inverse, config_constraint_formula_inverse); + LOG_INFO("t3m resource limit calculator, cal_min_phy_resource_needed", K(num), + K(cal_num), K(memory_constraint_formula_inverse), + K(config_constraint_formula_inverse), K(minimum_physics_needed), + K(config_tablet_per_gb), K(config_mem_percentage)); + if (OB_FAIL(min_phy_res.set_type_value(PHY_RESOURCE_MEMORY, minimum_physics_needed))) { + LOG_WARN("set type value failed", K(PHY_RESOURCE_MEMORY), + K(memory_constraint_formula_inverse), + K(config_constraint_formula_inverse), K(minimum_physics_needed)); + } + return ret; +} + +int ObTenantMetaMemMgr::ObT3MResourceLimitCalculatorHandler:: + cal_min_phy_resource_needed(share::ObMinPhyResourceResult &min_phy_res) { + int ret = OB_SUCCESS; + // Get current tablet count + const int64_t current_tablet_count = t3m_.tablet_map_.count(); + if (OB_FAIL(cal_min_phy_resource_needed(current_tablet_count, min_phy_res))) { + LOG_WARN("cal_min_phy_resource_needed failed", K(ret), K(current_tablet_count)); + } + return ret; +} + int ObTenantMetaMemMgr::TabletMapDumpOperator::operator()(common::hash::HashMapPair &entry) { int ret = OB_SUCCESS; diff --git a/src/storage/meta_mem/ob_tenant_meta_mem_mgr.h b/src/storage/meta_mem/ob_tenant_meta_mem_mgr.h index 9213c35229..b228291f0d 100644 --- a/src/storage/meta_mem/ob_tenant_meta_mem_mgr.h +++ b/src/storage/meta_mem/ob_tenant_meta_mem_mgr.h @@ -22,6 +22,7 @@ #include "lib/lock/ob_thread_cond.h" #include "lib/queue/ob_link_queue.h" #include "share/ob_ls_id.h" +#include "share/resource_limit_calculator/ob_resource_limit_calculator.h" #include "storage/blocksstable/ob_macro_block_id.h" #include "storage/blocksstable/ob_sstable.h" #include "storage/ddl/ob_tablet_ddl_kv_mgr.h" @@ -169,6 +170,9 @@ public: return ret; } +private: + static const int64_t DEFAULT_TABLET_CNT_PER_GB = 20000; + private: explicit ObTenantMetaMemMgr(const uint64_t tenant_id); public: @@ -287,11 +291,26 @@ public: int has_meta_wait_gc(bool &is_wait); int dump_tablet_info(); int release_memtable_and_mds_table_for_ls_offline(const ObTabletMapKey &key); + OB_INLINE share::ObIResourceLimitCalculatorHandler * get_t3m_limit_calculator() { return &t3m_limit_calculator_; } TO_STRING_KV(K_(tenant_id), K_(is_inited), "tablet count", tablet_map_.count()); int inc_ref_in_leak_checker(const int32_t index); int dec_ref_in_leak_checker(const int32_t index); +public: + class ObT3MResourceLimitCalculatorHandler final : public share::ObIResourceLimitCalculatorHandler + { + public: + explicit ObT3MResourceLimitCalculatorHandler(ObTenantMetaMemMgr &t3m) : t3m_(t3m) {} + int get_current_info(share::ObResourceInfo &info) override; + int get_resource_constraint_value(share::ObResoureConstraintValue &constraint_value) override; + int cal_min_phy_resource_needed(share::ObMinPhyResourceResult &min_phy_res) override; + int cal_min_phy_resource_needed(const int64_t num, share::ObMinPhyResourceResult &min_phy_res) override; + private: + DISALLOW_COPY_AND_ASSIGN(ObT3MResourceLimitCalculatorHandler); + private: + ObTenantMetaMemMgr &t3m_; + }; private: int fill_buffer_infos( const ObTabletPoolType pool_type, @@ -528,6 +547,7 @@ private: common::ObConcurrentFIFOAllocator meta_cache_io_allocator_; int64_t last_access_tenant_config_ts_; + ObT3MResourceLimitCalculatorHandler t3m_limit_calculator_; bool is_tablet_leak_checker_enabled_; bool is_inited_; diff --git a/src/storage/tx_storage/ob_ls_service.cpp b/src/storage/tx_storage/ob_ls_service.cpp index 9251e7d604..9ec971d15e 100644 --- a/src/storage/tx_storage/ob_ls_service.cpp +++ b/src/storage/tx_storage/ob_ls_service.cpp @@ -69,7 +69,8 @@ ObLSService::ObLSService() storage_svr_rpc_proxy_(), storage_rpc_(), safe_ls_destroy_task_cnt_(0), - iter_cnt_(0) + iter_cnt_(0), + max_ls_cnt_(0) {} ObLSService::~ObLSService() @@ -96,6 +97,7 @@ void ObLSService::destroy() rs_reporter_ = nullptr; storage_svr_rpc_proxy_.destroy(); storage_rpc_.destroy(); + max_ls_cnt_ = 0; is_inited_ = false; } @@ -132,6 +134,130 @@ void ObLSService::dec_iter_cnt() ATOMIC_DEC(&iter_cnt_); } +int ObLSService::get_resource_constraint_value(ObResoureConstraintValue &constraint_value) +{ + int ret = OB_SUCCESS; + if (IS_NOT_INIT) { + ret = OB_NOT_INIT; + LOG_WARN("ls service not inited, the resource info may not right.", K(ret)); + } else if (!is_running_ || is_stopped_) { + ret = OB_NOT_RUNNING; + LOG_WARN("the ls service is not running ,the resource info may not right.", K(ret)); + } else { + ret = get_resource_constraint_value_(constraint_value); + } + + return ret; +} + +int ObLSService::get_resource_constraint_value_(ObResoureConstraintValue &constraint_value) +{ + int ret = OB_SUCCESS; + int64_t config_value = OB_MAX_LS_NUM_PER_TENANT_PER_SERVER; + int64_t memory_value = INT64_MAX; + int64_t clog_disk_value = INT64_MAX; + // 1. configuration + omt::ObTenantConfigGuard tenant_config(TENANT_CONF(MTL_ID())); + if (OB_LIKELY(tenant_config.is_valid())) { + config_value = (tenant_config->_max_ls_cnt_per_server != 0 + ? tenant_config->_max_ls_cnt_per_server : config_value); + } + + // 2. memory + const int64_t tenant_memory = lib::get_tenant_memory_limit(MTL_ID()); + memory_value = OB_MAX(tenant_memory - SMALL_TENANT_MEMORY_LIMIT, 0) / TENANT_MEMORY_PER_LS_NEED + + OB_MAX_LS_NUM_PER_TENANT_PER_SERVER_FOR_SMALL_TENANT; + + // 3. clog disk + palf::PalfOptions palf_opts; + if (OB_FAIL(MTL(ObLogService*)->get_palf_options(palf_opts))) { + LOG_WARN("get palf options failed", K(ret)); + } else { + const palf::PalfDiskOptions &disk_opts = palf_opts.disk_options_; + clog_disk_value = disk_opts.log_disk_usage_limit_size_ / MIN_DISK_SIZE_PER_PALF_INSTANCE; + } + if (OB_FAIL(ret)) { + } else if (OB_FAIL(constraint_value.set_type_value(CONFIGURATION_CONSTRAINT, config_value))) { + LOG_WARN("set_type_value failed", K(ret), K(CONFIGURATION_CONSTRAINT), K(config_value)); + } else if (OB_FAIL(constraint_value.set_type_value(MEMORY_CONSTRAINT, memory_value))) { + LOG_WARN("set_type_value failed", K(ret), K(MEMORY_CONSTRAINT), K(memory_value)); + } else if (OB_FAIL(constraint_value.set_type_value(CLOG_DISK_CONSTRAINT, clog_disk_value))) { + LOG_WARN("set_type_value failed", K(ret), K(CLOG_DISK_CONSTRAINT), K(clog_disk_value)); + } + + return ret; +} + +int ObLSService::get_current_info(share::ObResourceInfo &info) +{ + int ret = OB_SUCCESS; + ObResoureConstraintValue constraint_value; + if (IS_NOT_INIT) { + ret = OB_NOT_INIT; + LOG_WARN("ls service not inited, the resource info may not right.", K(ret)); + } else if (!is_running_ || is_stopped_) { + ret = OB_NOT_RUNNING; + LOG_WARN("the ls service is not running ,the resource info may not right.", K(ret)); + } else if (OB_FAIL(get_resource_constraint_value_(constraint_value))) { + LOG_WARN("get resource constraint value failed", K(ret)); + } else { + info.curr_utilization_ = ls_map_.get_ls_count() + ATOMIC_LOAD(&safe_ls_destroy_task_cnt_); + info.max_utilization_ = ATOMIC_LOAD(&max_ls_cnt_); + info.reserved_value_ = 0; // reserve value will be used later + constraint_value.get_min_constraint(info.min_constraint_type_, info.min_constraint_value_); + } + return ret; +} + +int ObLSService::cal_min_phy_resource_needed(share::ObMinPhyResourceResult &min_phy_res) +{ + int ret = OB_SUCCESS; + if (IS_NOT_INIT) { + ret = OB_NOT_INIT; + LOG_WARN("ls service not inited, the resource info may not right.", K(ret)); + } else if (!is_running_ || is_stopped_) { + ret = OB_NOT_RUNNING; + LOG_WARN("the ls service is not running ,the resource info may not right.", K(ret)); + } else { + int64_t ls_cnt = ls_map_.get_ls_count() + ATOMIC_LOAD(&safe_ls_destroy_task_cnt_); + ret = cal_min_phy_resource_needed_(ls_cnt, min_phy_res); + } + return ret; +} + +int ObLSService::cal_min_phy_resource_needed(const int64_t num, + ObMinPhyResourceResult &min_phy_res) +{ + int ret = OB_SUCCESS; + ret = cal_min_phy_resource_needed_(num, min_phy_res); + return ret; +} + +int ObLSService::cal_min_phy_resource_needed_(const int64_t num, + ObMinPhyResourceResult &min_phy_res) +{ + int ret = OB_SUCCESS; + int64_t ls_cnt = num; + int64_t clog_disk_bytes = 0; + int64_t memory_bytes = 0; + // 1. memory + // if the ls num is smaller than OB_MAX_LS_NUM_PER_TENANT_PER_SERVER_FOR_SMALL_TENANT, + // just return SMALL_TENANT_MEMORY_LIMIT. + memory_bytes = (SMALL_TENANT_MEMORY_LIMIT + + OB_MAX(ls_cnt - OB_MAX_LS_NUM_PER_TENANT_PER_SERVER_FOR_SMALL_TENANT, 0) + * TENANT_MEMORY_PER_LS_NEED); + memory_bytes = ls_cnt > 0 ? memory_bytes : 0; + // 2. clog disk + clog_disk_bytes = MIN_DISK_SIZE_PER_PALF_INSTANCE * OB_MAX(0, ls_cnt); + + if (OB_FAIL(min_phy_res.set_type_value(PHY_RESOURCE_MEMORY, memory_bytes))) { + LOG_WARN("set type value failed", K(PHY_RESOURCE_MEMORY), K(memory_bytes)); + } else if (OB_FAIL(min_phy_res.set_type_value(PHY_RESOURCE_CLOG_DISK, clog_disk_bytes))) { + LOG_WARN("set type value failed", K(PHY_RESOURCE_CLOG_DISK), K(clog_disk_bytes)); + } + return ret; +} + int ObLSService::stop() { int ret = OB_SUCCESS; @@ -264,23 +390,20 @@ int ObLSService::start() int ObLSService::check_tenant_ls_num_() { int ret = OB_SUCCESS; - omt::ObTenantConfigGuard tenant_config(TENANT_CONF(MTL_ID())); - const int64_t normal_ls_count = ls_map_.get_ls_count(); - const int64_t removeing_ls_count = ATOMIC_LOAD(&safe_ls_destroy_task_cnt_); - const int64_t tenant_memory = lib::get_tenant_memory_limit(MTL_ID()); - int64_t tenant_max_ls_limit = OB_MAX(tenant_memory - SMALL_TENANT_MEMORY_LIMIT, 0) / TENANT_MEMORY_PER_LS_NEED + - OB_MAX_LS_NUM_PER_TENANT_PER_SERVER_FOR_SMALL_TENANT; - // the max ls limit should not greater than OB_MAX_LS_NUM_PER_TENANT_PER_SERVER - tenant_max_ls_limit = OB_MIN(tenant_max_ls_limit, OB_MAX_LS_NUM_PER_TENANT_PER_SERVER); - // the config priority is higher than the calculate result. - if (OB_LIKELY(tenant_config.is_valid())) { - tenant_max_ls_limit = (tenant_config->_max_ls_cnt_per_server != 0 ? - tenant_config->_max_ls_cnt_per_server : tenant_max_ls_limit); - } - if (normal_ls_count + removeing_ls_count + 1 > tenant_max_ls_limit) { - ret = OB_TOO_MANY_TENANT_LS; - LOG_WARN("too many ls of a tenant", K(ret), K(normal_ls_count), K(removeing_ls_count), - K(tenant_max_ls_limit), K(tenant_memory)); + ObResoureConstraintValue constraint_value; + if (OB_FAIL(get_resource_constraint_value_(constraint_value))) { + LOG_WARN("get resource constraint value failed", K(ret)); + } else { + int64_t min_constraint_value = 0; + int64_t min_constraint_type = 0; + const int64_t normal_ls_count = ls_map_.get_ls_count(); + const int64_t removeing_ls_count = ATOMIC_LOAD(&safe_ls_destroy_task_cnt_); + constraint_value.get_min_constraint(min_constraint_type, min_constraint_value); + if (normal_ls_count + removeing_ls_count + 1 > min_constraint_value) { + ret = OB_TOO_MANY_TENANT_LS; + LOG_WARN("too many ls of a tenant", K(ret), K(normal_ls_count), K(removeing_ls_count), + K(min_constraint_type), K(get_constraint_type_name(min_constraint_type)), K(min_constraint_value)); + } } return ret; } @@ -336,6 +459,11 @@ int ObLSService::add_ls_to_map_(ObLS *ls) int ret = OB_SUCCESS; if (OB_FAIL(ls_map_.add_ls(*ls))) { LOG_WARN("add ls failed.", K(ret), K(ls->get_ls_id())); + } else { + // update the max ls cnt + const int64_t normal_ls_count = ls_map_.get_ls_count(); + const int64_t removeing_ls_count = ATOMIC_LOAD(&safe_ls_destroy_task_cnt_); + inc_update(&max_ls_cnt_, normal_ls_count + removeing_ls_count); } return ret; } diff --git a/src/storage/tx_storage/ob_ls_service.h b/src/storage/tx_storage/ob_ls_service.h index 7426636484..bfcfecf0de 100644 --- a/src/storage/tx_storage/ob_ls_service.h +++ b/src/storage/tx_storage/ob_ls_service.h @@ -18,6 +18,7 @@ #include "storage/tx_storage/ob_ls_map.h" #include "storage/ob_storage_rpc.h" #include "storage/ls/ob_ls_meta_package.h" // ObLSMetaPackage +#include "share/resource_limit_calculator/ob_resource_limit_calculator.h" namespace oceanbase { @@ -44,7 +45,7 @@ struct ObLSMeta; // Maintain the tenant <-> log streams mapping relationship // Support log stream meta persistent and checkpoint -class ObLSService +class ObLSService : public ObIResourceLimitCalculatorHandler { static const int64_t DEFAULT_LOCK_TIMEOUT = 60_s; static const int64_t SMALL_TENANT_MEMORY_LIMIT = 4 * 1024 * 1024 * 1024L; // 4G @@ -53,7 +54,7 @@ public: int64_t break_point = -1; // just for test public: ObLSService(); - ~ObLSService(); + virtual ~ObLSService(); static int mtl_init(ObLSService* &ls_service); int init(const uint64_t tenant_id, @@ -67,6 +68,12 @@ public: void dec_ls_safe_destroy_task_cnt(); void inc_iter_cnt(); void dec_iter_cnt(); +public: + // for limit calculator + virtual int get_current_info(share::ObResourceInfo &info) override; + virtual int get_resource_constraint_value(share::ObResoureConstraintValue &constraint_value) override; + virtual int cal_min_phy_resource_needed(share::ObMinPhyResourceResult &min_phy_res) override; + virtual int cal_min_phy_resource_needed(const int64_t num, share::ObMinPhyResourceResult &min_phy_res) override; public: // create a LS // @param [in] arg, all the parameters that is need to create a LS. @@ -209,6 +216,11 @@ private: ObLSRestoreStatus get_restore_status_by_tenant_role_(const ObTenantRole& tenant_role); int64_t get_create_type_by_tenant_role_(const ObTenantRole& tenant_role); + // for resource limit calculator + int cal_min_phy_resource_needed_(const int64_t ls_cnt, + ObMinPhyResourceResult &min_phy_res); + int get_resource_constraint_value_(ObResoureConstraintValue &constraint_value); + private: bool is_inited_; bool is_running_; // used by create/remove, only can be used after start and before stop. @@ -233,6 +245,10 @@ private: // record the count of ls iter int64_t iter_cnt_; + + // for limit calculator + // the max ls cnt after observer start + int64_t max_ls_cnt_; DISALLOW_COPY_AND_ASSIGN(ObLSService); }; diff --git a/tools/deploy/mysql_test/r/mysql/information_schema.result b/tools/deploy/mysql_test/r/mysql/information_schema.result index 3e4e20849e..cb46f7580a 100644 --- a/tools/deploy/mysql_test/r/mysql/information_schema.result +++ b/tools/deploy/mysql_test/r/mysql/information_schema.result @@ -399,6 +399,8 @@ select * from information_schema.tables where table_schema in ('oceanbase', 'mys | def | oceanbase | GV$OB_TABLET_COMPACTION_PROGRESS | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | GV$OB_TABLET_STATS | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | GV$OB_TENANT_MEMORY | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | +| def | oceanbase | GV$OB_TENANT_RESOURCE_LIMIT | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | +| def | oceanbase | GV$OB_TENANT_RESOURCE_LIMIT_DETAIL | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | GV$OB_THREAD | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | GV$OB_TRACEPOINT_INFO | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | GV$OB_TRANSACTION_PARTICIPANTS | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | @@ -467,6 +469,8 @@ select * from information_schema.tables where table_schema in ('oceanbase', 'mys | def | oceanbase | V$OB_TABLET_COMPACTION_PROGRESS | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | V$OB_TABLET_STATS | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | V$OB_TENANT_MEMORY | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | +| def | oceanbase | V$OB_TENANT_RESOURCE_LIMIT | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | +| def | oceanbase | V$OB_TENANT_RESOURCE_LIMIT_DETAIL | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | V$OB_THREAD | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | V$OB_TIMESTAMP_SERVICE | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | V$OB_TRACEPOINT_INFO | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | @@ -832,6 +836,8 @@ select * from information_schema.tables where table_schema in ('oceanbase', 'mys | def | oceanbase | __all_virtual_tenant_mysql_sys_agent | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | __all_virtual_tenant_parameter | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | __all_virtual_tenant_parameter_stat | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | +| def | oceanbase | __all_virtual_tenant_resource_limit | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | +| def | oceanbase | __all_virtual_tenant_resource_limit_detail | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | __all_virtual_tenant_snapshot | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | __all_virtual_tenant_snapshot_job | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | __all_virtual_tenant_snapshot_ls | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | @@ -1818,6 +1824,8 @@ select * from information_schema.tables where table_schema in ('oceanbase', 'mys | def | oceanbase | GV$OB_TABLET_COMPACTION_PROGRESS | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | GV$OB_TABLET_STATS | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | GV$OB_TENANT_MEMORY | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | +| def | oceanbase | GV$OB_TENANT_RESOURCE_LIMIT | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | +| def | oceanbase | GV$OB_TENANT_RESOURCE_LIMIT_DETAIL | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | GV$OB_THREAD | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | GV$OB_TRACEPOINT_INFO | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | GV$OB_TRANSACTION_PARTICIPANTS | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | @@ -1886,6 +1894,8 @@ select * from information_schema.tables where table_schema in ('oceanbase', 'mys | def | oceanbase | V$OB_TABLET_COMPACTION_PROGRESS | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | V$OB_TABLET_STATS | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | V$OB_TENANT_MEMORY | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | +| def | oceanbase | V$OB_TENANT_RESOURCE_LIMIT | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | +| def | oceanbase | V$OB_TENANT_RESOURCE_LIMIT_DETAIL | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | V$OB_THREAD | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | V$OB_TIMESTAMP_SERVICE | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | V$OB_TRACEPOINT_INFO | SYSTEM VIEW | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | @@ -2251,6 +2261,8 @@ select * from information_schema.tables where table_schema in ('oceanbase', 'mys | def | oceanbase | __all_virtual_tenant_mysql_sys_agent | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | __all_virtual_tenant_parameter | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | __all_virtual_tenant_parameter_stat | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | +| def | oceanbase | __all_virtual_tenant_resource_limit | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | +| def | oceanbase | __all_virtual_tenant_resource_limit_detail | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | __all_virtual_tenant_snapshot | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | __all_virtual_tenant_snapshot_job | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | | def | oceanbase | __all_virtual_tenant_snapshot_ls | SYSTEM TABLE | MEMORY | NULL | DYNAMIC | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | utf8mb4_general_ci | NULL | NULL | | diff --git a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_sys_views_in_mysql.result b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_sys_views_in_mysql.result index 6e81a4404a..ff3b65817e 100644 --- a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_sys_views_in_mysql.result +++ b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_sys_views_in_mysql.result @@ -6119,6 +6119,58 @@ TP_MATCH bigint(20) NO select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.V$OB_TRACEPOINT_INFO limit 1); cnt 1 +desc oceanbase.GV$OB_TENANT_RESOURCE_LIMIT; +Field Type Null Key Default Extra +SVR_IP varchar(46) NO NULL +SVR_PORT bigint(20) NO NULL +TENANT_ID bigint(20) NO NULL +ZONE varchar(128) NO NULL +RESOURCE_NAME varchar(128) NO NULL +CURRENT_UTILIZATION bigint(20) NO NULL +MAX_UTILIZATION bigint(20) NO NULL +RESERVED_VALUE bigint(20) NO NULL +LIMIT_VALUE bigint(20) NO NULL +EFFECTIVE_LIMIT_TYPE varchar(128) NO NULL +select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.GV$OB_TENANT_RESOURCE_LIMIT limit 1); +cnt +1 +desc oceanbase.V$OB_TENANT_RESOURCE_LIMIT; +Field Type Null Key Default Extra +SVR_IP varchar(46) NO +SVR_PORT bigint(20) NO +TENANT_ID bigint(20) NO +ZONE varchar(128) NO +RESOURCE_NAME varchar(128) NO +CURRENT_UTILIZATION bigint(20) NO +MAX_UTILIZATION bigint(20) NO +RESERVED_VALUE bigint(20) NO +LIMIT_VALUE bigint(20) NO +EFFECTIVE_LIMIT_TYPE varchar(128) NO +select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.V$OB_TENANT_RESOURCE_LIMIT limit 1); +cnt +1 +desc oceanbase.GV$OB_TENANT_RESOURCE_LIMIT_DETAIL; +Field Type Null Key Default Extra +SVR_IP varchar(46) NO NULL +SVR_PORT bigint(20) NO NULL +TENANT_ID bigint(20) NO NULL +RESOURCE_NAME varchar(128) NO NULL +LIMIT_TYPE varchar(128) NO NULL +LIMIT_VALUE bigint(20) NO NULL +select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.GV$OB_TENANT_RESOURCE_LIMIT_DETAIL limit 1); +cnt +1 +desc oceanbase.V$OB_TENANT_RESOURCE_LIMIT_DETAIL; +Field Type Null Key Default Extra +SVR_IP varchar(46) NO +SVR_PORT bigint(20) NO +TENANT_ID bigint(20) NO +RESOURCE_NAME varchar(128) NO +LIMIT_TYPE varchar(128) NO +LIMIT_VALUE bigint(20) NO +select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.V$OB_TENANT_RESOURCE_LIMIT_DETAIL limit 1); +cnt +1 desc oceanbase.GV$OB_NIC_INFO; Field Type Null Key Default Extra SVR_IP varchar(46) NO NULL diff --git a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_sys_views_in_sys.result b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_sys_views_in_sys.result index 4d45f643ed..9a3c2ce550 100644 --- a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_sys_views_in_sys.result +++ b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_sys_views_in_sys.result @@ -8864,6 +8864,58 @@ TP_MATCH bigint(20) NO select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.V$OB_TRACEPOINT_INFO limit 1); cnt 1 +desc oceanbase.GV$OB_TENANT_RESOURCE_LIMIT; +Field Type Null Key Default Extra +SVR_IP varchar(46) NO NULL +SVR_PORT bigint(20) NO NULL +TENANT_ID bigint(20) NO NULL +ZONE varchar(128) NO NULL +RESOURCE_NAME varchar(128) NO NULL +CURRENT_UTILIZATION bigint(20) NO NULL +MAX_UTILIZATION bigint(20) NO NULL +RESERVED_VALUE bigint(20) NO NULL +LIMIT_VALUE bigint(20) NO NULL +EFFECTIVE_LIMIT_TYPE varchar(128) NO NULL +select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.GV$OB_TENANT_RESOURCE_LIMIT limit 1); +cnt +1 +desc oceanbase.V$OB_TENANT_RESOURCE_LIMIT; +Field Type Null Key Default Extra +SVR_IP varchar(46) NO +SVR_PORT bigint(20) NO +TENANT_ID bigint(20) NO +ZONE varchar(128) NO +RESOURCE_NAME varchar(128) NO +CURRENT_UTILIZATION bigint(20) NO +MAX_UTILIZATION bigint(20) NO +RESERVED_VALUE bigint(20) NO +LIMIT_VALUE bigint(20) NO +EFFECTIVE_LIMIT_TYPE varchar(128) NO +select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.V$OB_TENANT_RESOURCE_LIMIT limit 1); +cnt +1 +desc oceanbase.GV$OB_TENANT_RESOURCE_LIMIT_DETAIL; +Field Type Null Key Default Extra +SVR_IP varchar(46) NO NULL +SVR_PORT bigint(20) NO NULL +TENANT_ID bigint(20) NO NULL +RESOURCE_NAME varchar(128) NO NULL +LIMIT_TYPE varchar(128) NO NULL +LIMIT_VALUE bigint(20) NO NULL +select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.GV$OB_TENANT_RESOURCE_LIMIT_DETAIL limit 1); +cnt +1 +desc oceanbase.V$OB_TENANT_RESOURCE_LIMIT_DETAIL; +Field Type Null Key Default Extra +SVR_IP varchar(46) NO +SVR_PORT bigint(20) NO +TENANT_ID bigint(20) NO +RESOURCE_NAME varchar(128) NO +LIMIT_TYPE varchar(128) NO +LIMIT_VALUE bigint(20) NO +select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.V$OB_TENANT_RESOURCE_LIMIT_DETAIL limit 1); +cnt +1 desc oceanbase.GV$OB_NIC_INFO; Field Type Null Key Default Extra SVR_IP varchar(46) NO NULL diff --git a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_mysql.result b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_mysql.result index e10178e325..a759b5f2f0 100644 --- a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_mysql.result +++ b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_mysql.result @@ -4838,6 +4838,38 @@ IF(count(*) >= 0, 1, 0) "oceanbase.__all_virtual_tracepoint_info runs in single server" IF(count(*) >= 0, 1, 0) 1 +desc oceanbase.__all_virtual_tenant_resource_limit; +Field Type Null Key Default Extra +svr_ip varchar(46) NO NULL +svr_port bigint(20) NO NULL +tenant_id bigint(20) NO NULL +zone varchar(128) NO NULL +resource_name varchar(128) NO NULL +current_utilization bigint(20) NO NULL +max_utilization bigint(20) NO NULL +reserved_value bigint(20) NO NULL +limit_value bigint(20) NO NULL +effective_limit_type varchar(128) NO NULL +select /*+QUERY_TIMEOUT(60000000)*/ IF(count(*) >= 0, 1, 0) from oceanbase.__all_virtual_tenant_resource_limit; +IF(count(*) >= 0, 1, 0) +1 +"oceanbase.__all_virtual_tenant_resource_limit runs in single server" +IF(count(*) >= 0, 1, 0) +1 +desc oceanbase.__all_virtual_tenant_resource_limit_detail; +Field Type Null Key Default Extra +svr_ip varchar(46) NO NULL +svr_port bigint(20) NO NULL +tenant_id bigint(20) NO NULL +resource_name varchar(128) NO NULL +limit_type varchar(128) NO NULL +limit_value bigint(20) NO NULL +select /*+QUERY_TIMEOUT(60000000)*/ IF(count(*) >= 0, 1, 0) from oceanbase.__all_virtual_tenant_resource_limit_detail; +IF(count(*) >= 0, 1, 0) +1 +"oceanbase.__all_virtual_tenant_resource_limit_detail runs in single server" +IF(count(*) >= 0, 1, 0) +1 desc oceanbase.__all_virtual_nic_info; Field Type Null Key Default Extra svr_ip varchar(46) NO NULL diff --git a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_sys.result b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_sys.result index 4f59168e88..4e4c17067f 100644 --- a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_sys.result +++ b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_sys.result @@ -9381,6 +9381,38 @@ IF(count(*) >= 0, 1, 0) "oceanbase.__all_virtual_tracepoint_info runs in single server" IF(count(*) >= 0, 1, 0) 1 +desc oceanbase.__all_virtual_tenant_resource_limit; +Field Type Null Key Default Extra +svr_ip varchar(46) NO NULL +svr_port bigint(20) NO NULL +tenant_id bigint(20) NO NULL +zone varchar(128) NO NULL +resource_name varchar(128) NO NULL +current_utilization bigint(20) NO NULL +max_utilization bigint(20) NO NULL +reserved_value bigint(20) NO NULL +limit_value bigint(20) NO NULL +effective_limit_type varchar(128) NO NULL +select /*+QUERY_TIMEOUT(60000000)*/ IF(count(*) >= 0, 1, 0) from oceanbase.__all_virtual_tenant_resource_limit; +IF(count(*) >= 0, 1, 0) +1 +"oceanbase.__all_virtual_tenant_resource_limit runs in single server" +IF(count(*) >= 0, 1, 0) +1 +desc oceanbase.__all_virtual_tenant_resource_limit_detail; +Field Type Null Key Default Extra +svr_ip varchar(46) NO NULL +svr_port bigint(20) NO NULL +tenant_id bigint(20) NO NULL +resource_name varchar(128) NO NULL +limit_type varchar(128) NO NULL +limit_value bigint(20) NO NULL +select /*+QUERY_TIMEOUT(60000000)*/ IF(count(*) >= 0, 1, 0) from oceanbase.__all_virtual_tenant_resource_limit_detail; +IF(count(*) >= 0, 1, 0) +1 +"oceanbase.__all_virtual_tenant_resource_limit_detail runs in single server" +IF(count(*) >= 0, 1, 0) +1 desc oceanbase.__all_virtual_nic_info; Field Type Null Key Default Extra svr_ip varchar(46) NO NULL diff --git a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/inner_table_overall.result b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/inner_table_overall.result index 3621f8aaa9..9fa16adf98 100644 --- a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/inner_table_overall.result +++ b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/inner_table_overall.result @@ -731,6 +731,8 @@ select 0xffffffffff & table_id, table_name, table_type, database_id, part_num fr 12464 __all_virtual_tenant_snapshot_ls_replica_history 2 201001 1 12466 ENABLED_ROLES 2 201002 1 12469 __all_virtual_tracepoint_info 2 201001 1 +12481 __all_virtual_tenant_resource_limit 2 201001 1 +12482 __all_virtual_tenant_resource_limit_detail 2 201001 1 12487 __all_virtual_nic_info 2 201001 1 20001 GV$OB_PLAN_CACHE_STAT 1 201001 1 20002 GV$OB_PLAN_CACHE_PLAN_STAT 1 201001 1 @@ -1141,6 +1143,10 @@ select 0xffffffffff & table_id, table_name, table_type, database_id, part_num fr 21540 DBA_MVREF_STMT_STATS 1 201001 1 21543 GV$OB_TRACEPOINT_INFO 1 201001 1 21544 V$OB_TRACEPOINT_INFO 1 201001 1 +21550 GV$OB_TENANT_RESOURCE_LIMIT 1 201001 1 +21551 V$OB_TENANT_RESOURCE_LIMIT 1 201001 1 +21552 GV$OB_TENANT_RESOURCE_LIMIT_DETAIL 1 201001 1 +21553 V$OB_TENANT_RESOURCE_LIMIT_DETAIL 1 201001 1 21580 GV$OB_NIC_INFO 1 201001 1 21581 V$OB_NIC_INFO 1 201001 1 check sys table count and table_id range success