hcq/oceanbase
hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

improve sql statement for flushing ss_micro_cache

Browse Source
This commit is contained in:
sunzhoujia 2024-09-20 11:15:39 +00:00 committed by ob-robot
parent c7d111a790
commit ffa4025af4
8 changed files with 89 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
deps/oblib/src/rpc/obrpc/ob_rpc_packet_list.h vendored
View File

@ -1205,7 +1205,7 @@ PCODE_DEF(OB_KILL_QUERY_CLIENT_SESSION, 0x162E)
PCODE_DEF(OB_ENABLE_SS_MICRO_CACHE, 0x162F)
PCODE_DEF(OB_GET_SS_MICRO_CACHE_INFO, 0x1630)
//PCODE_DEF(OB_MODULE_DATA, 0x1631)
PCODE_DEF(OB_CLEAR_SS_MICRO_CACHE, 0x1632)
//**** 注意：在此行之前增加新的RPC ID ******
//
//占位须知：

22
src/observer/ob_rpc_processor_simple.cpp
View File

@ -3703,6 +3703,28 @@ int ObGetSSMicroCacheInfoP::process()
return ret;
}
int ObRpcClearSSMicroCacheP::process()
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!arg_.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(ret), K_(arg));
} else {
MTL_SWITCH(arg_.tenant_id_)
{
ObSSMicroCache *micro_cache = nullptr;
if (OB_ISNULL(micro_cache = MTL(ObSSMicroCache *))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("micro_cache is nullptr", KR(ret));
} else {
micro_cache->clear_micro_cache();
LOG_INFO("success clear ss_micro_cache");
}
}
}
return ret;
}
#endif
int ObNotifySharedStorageInfoP::process()

1
src/observer/ob_rpc_processor_simple.h
View File

@ -242,6 +242,7 @@ OB_DEFINE_PROCESSOR_S(Srv, OB_GET_SS_MACRO_BLOCK_BY_URI, ObGetSSMacroBlockByURIP
OB_DEFINE_PROCESSOR_S(Srv, OB_DEL_SS_TABLET_META, ObDelSSTabletMetaP);
OB_DEFINE_PROCESSOR_S(Srv, OB_ENABLE_SS_MICRO_CACHE, ObEnableSSMicroCacheP);
OB_DEFINE_PROCESSOR_S(Srv, OB_GET_SS_MICRO_CACHE_INFO, ObGetSSMicroCacheInfoP);
OB_DEFINE_PROCESSOR_S(Srv, OB_CLEAR_SS_MICRO_CACHE, ObRpcClearSSMicroCacheP);
#endif
OB_DEFINE_PROCESSOR_S(Srv, OB_REMOTE_WRITE_DDL_INC_COMMIT_LOG, ObRpcRemoteWriteDDLIncCommitLogP);
OB_DEFINE_PROCESSOR_S(Srv, OB_CHECK_LS_CAN_OFFLINE, ObRpcCheckLSCanOfflineP);

1
src/observer/ob_srv_xlator_storage.cpp
View File

@ -150,6 +150,7 @@ void oceanbase::observer::init_srv_xlator_for_storage(ObSrvRpcXlator *xlator) {
RPC_PROCESSOR(ObDelSSTabletMetaP, gctx_);
RPC_PROCESSOR(ObEnableSSMicroCacheP, gctx_);
RPC_PROCESSOR(ObGetSSMicroCacheInfoP, gctx_);
RPC_PROCESSOR(ObRpcClearSSMicroCacheP, gctx_);
#endif
RPC_PROCESSOR(ObNotifySharedStorageInfoP, gctx_);
}

1
src/share/ob_rpc_struct.cpp
View File

@ -10842,6 +10842,7 @@ OB_SERIALIZE_MEMBER(ObDelSSTabletMetaArg, tenant_id_, macro_id_);
OB_SERIALIZE_MEMBER(ObEnableSSMicroCacheArg, tenant_id_, is_enabled_);
OB_SERIALIZE_MEMBER(ObGetSSMicroCacheInfoArg, tenant_id_);
OB_SERIALIZE_MEMBER(ObGetSSMicroCacheInfoResult, micro_cache_stat_, super_block_, arc_info_);
OB_SERIALIZE_MEMBER(ObClearSSMicroCacheArg, tenant_id_);
#endif
ObRpcRemoteWriteDDLIncCommitLogArg::ObRpcRemoteWriteDDLIncCommitLogArg()

16
src/share/ob_rpc_struct.h
View File

@ -10921,6 +10921,22 @@ public:
ObSSMicroCacheSuperBlock super_block_;
ObSSARCInfo arc_info_;
};
struct ObClearSSMicroCacheArg {
OB_UNIS_VERSION(1);
public:
ObClearSSMicroCacheArg() : tenant_id_(OB_INVALID_TENANT_ID) {}
~ObClearSSMicroCacheArg() {}
bool is_valid() const
{
return is_valid_tenant_id(tenant_id_);
}
TO_STRING_KV(K_(tenant_id));
public:
uint64_t tenant_id_;
};
#endif
struct ObRpcRemoteWriteDDLIncCommitLogArg final

1
src/share/ob_srv_rpc_proxy.h
View File

@ -225,6 +225,7 @@ public:
RPC_S(PR5 del_ss_tablet_meta, OB_DEL_SS_TABLET_META, (obrpc::ObDelSSTabletMetaArg));
RPC_S(PR5 enable_ss_micro_cache, OB_ENABLE_SS_MICRO_CACHE, (obrpc::ObEnableSSMicroCacheArg));
RPC_S(PR5 get_ss_micro_cache_info, OB_GET_SS_MICRO_CACHE_INFO, (obrpc::ObGetSSMicroCacheInfoArg), obrpc::ObGetSSMicroCacheInfoResult);
RPC_S(PR5 clear_ss_micro_cache, OB_CLEAR_SS_MICRO_CACHE, (obrpc::ObClearSSMicroCacheArg));
#endif
RPC_S(PR5 remote_write_ddl_inc_commit_log, OB_REMOTE_WRITE_DDL_INC_COMMIT_LOG, (obrpc::ObRpcRemoteWriteDDLIncCommitLogArg), ObRpcRemoteWriteDDLIncCommitLogRes);
RPC_S(PR5 check_ls_can_offline, OB_CHECK_LS_CAN_OFFLINE, (obrpc::ObCheckLSCanOfflineArg));

64
src/sql/engine/cmd/ob_alter_system_executor.cpp
View File

@ -600,34 +600,62 @@ int ObFlushSSMicroCacheExecutor::execute(ObExecContext &ctx, ObFlushSSMicroCache
int ret = OB_SUCCESS;
#ifdef OB_BUILD_SHARED_STORAGE
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
obrpc::ObCommonRpcProxy *common_rpc = nullptr;
share::schema::ObSchemaGetterGuard schema_guard;
uint64_t tenant_id = OB_INVALID_ID;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(GCTX.schema_service_->get_tenant_schema_guard(
ctx.get_my_session()->get_effective_tenant_id(), schema_guard))) {
LOG_WARN("get_schema_guard failed", K(ret));
} else if (OB_FAIL(schema_guard.get_tenant_id(ObString::make_string(stmt.tenant_name_.ptr()), tenant_id)) ||
OB_INVALID_ID == tenant_id) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("tenant not found", K(ret), K_(stmt.tenant_name));
} else {
share::schema::ObSchemaGetterGuard schema_guard;
if (OB_FAIL(GCTX.schema_service_->get_tenant_schema_guard(
ctx.get_my_session()->get_effective_tenant_id(), schema_guard))) {
LOG_WARN("get_schema_guard failed", K(ret));
ObArray<ObAddr> server_list;
ObArray<ObUnit> tenant_units;
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, tenant_units))) {
LOG_WARN("failed to get tenant units", KR(ret), K(tenant_id));
} else if (OB_UNLIKELY(0 == tenant_units.count())) {
ret = OB_TENANT_NOT_EXIST;
LOG_WARN("tenant not exist", KR(ret), K(tenant_id));
} else {
uint64_t tenant_id = OB_INVALID_ID;
if (OB_FAIL(schema_guard.get_tenant_id(ObString::make_string(stmt.tenant_name_.ptr()), tenant_id)) ||
OB_INVALID_ID == tenant_id) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("tenant not found", K(ret), K_(stmt.tenant_name));
FOREACH_X(unit, tenant_units, OB_SUCC(ret)) {
bool is_alive = false;
if (OB_FAIL(SVR_TRACER.check_server_alive(unit->server_, is_alive))) {
LOG_WARN("check_server_alive failed", KR(ret), K(unit->server_));
} else if (is_alive) {
if (has_exist_in_array(server_list, unit->server_)) {
// server exist
} else if (OB_FAIL(server_list.push_back(unit->server_))) {
LOG_WARN("push_back failed", KR(ret), K(unit->server_));
}
}
}
}
if (OB_SUCC(ret)) {
const int64_t rpc_timeout = 10000000; // 10s
obrpc::ObClearSSMicroCacheArg arg;
arg.tenant_id_ = tenant_id;
obrpc::ObSrvRpcProxy *srv_rpc_proxy = nullptr;
if (OB_ISNULL(srv_rpc_proxy = GCTX.srv_rpc_proxy_)) {
ret = OB_ERR_SYS;
LOG_WARN("srv rpc proxy is null", KR(ret), KP(srv_rpc_proxy));
} else {
MTL_SWITCH(tenant_id)
{
ObSSMicroCache *micro_cache = nullptr;
if (OB_ISNULL(micro_cache = MTL(ObSSMicroCache *))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("micro_cache is nullptr", KR(ret));
FOREACH_X(server_addr, server_list, OB_SUCC(ret)) {
if (OB_FAIL(srv_rpc_proxy->to(*server_addr).timeout(rpc_timeout).clear_ss_micro_cache(arg))) {
LOG_WARN("fail to send clear_ss_micro_cache rpc", KR(ret), K(arg));
} else {
micro_cache->clear_micro_cache();
LOG_INFO("success clear ss_micro_cache");
LOG_INFO("succ to send clear_ss_micro_cache rpc", K(arg));
}
}
}