From 7e357ea8c974b778a1d104961ac9dfc950232b4a Mon Sep 17 00:00:00 2001 From: seuwebber Date: Tue, 29 Nov 2022 13:35:43 +0000 Subject: [PATCH] [to #45393823]update route_sql when alter package compile --- src/rootserver/ob_ddl_operator.cpp | 34 +++++++++ src/rootserver/ob_ddl_operator.h | 5 ++ src/rootserver/ob_ddl_service.cpp | 40 +++++++++++ src/rootserver/ob_ddl_service.h | 5 ++ src/rootserver/ob_root_service.cpp | 61 +++++++++++++++- src/share/ob_rpc_struct.cpp | 22 +++++- src/share/ob_rpc_struct.h | 15 +++- src/share/schema/ob_routine_sql_service.cpp | 28 ++++++++ src/share/schema/ob_routine_sql_service.h | 4 +- src/sql/engine/cmd/ob_package_executor.cpp | 6 +- .../ddl/ob_alter_package_resolver.cpp | 69 +++++++++++++------ .../resolver/ddl/ob_alter_package_resolver.h | 21 ++++-- .../ddl/ob_create_package_resolver.cpp | 65 ++++++++++------- .../resolver/ddl/ob_create_package_resolver.h | 6 ++ 14 files changed, 315 insertions(+), 66 deletions(-) diff --git a/src/rootserver/ob_ddl_operator.cpp b/src/rootserver/ob_ddl_operator.cpp index 8ad756e01..6ce8df7c7 100644 --- a/src/rootserver/ob_ddl_operator.cpp +++ b/src/rootserver/ob_ddl_operator.cpp @@ -8143,6 +8143,40 @@ int ObDDLOperator::create_package(const ObPackageInfo *old_package_info, return ret; } +int ObDDLOperator::alter_package(const ObPackageInfo &package_info, + ObMySQLTransaction &trans, + ObIArray &public_routine_infos, + ObErrorInfo &error_info, + const ObString *ddl_stmt_str) +{ + int ret = OB_SUCCESS; + UNUSEDx(ddl_stmt_str); + ObSchemaService *schema_service_impl = schema_service_.get_schema_service(); + const uint64_t tenant_id = package_info.get_tenant_id(); + int64_t new_schema_version = OB_INVALID_VERSION; + uint64_t package_id = package_info.get_package_id(); + ObPackageInfo new_package_info; + OV (OB_NOT_NULL(schema_service_impl), OB_ERR_SYS); + OV (OB_INVALID_ID != tenant_id && OB_INVALID_ID != package_id, OB_INVALID_ARGUMENT); + if (OB_SUCC(ret)) { + if (public_routine_infos.count() > 0) { + // update routine route sql + ARRAY_FOREACH(public_routine_infos, routine_idx) { + ObRoutineInfo &routine_info = public_routine_infos.at(routine_idx); + OZ (schema_service_.gen_new_schema_version(tenant_id, new_schema_version)); + OX (routine_info.set_schema_version(new_schema_version)); + OZ (schema_service_impl->get_routine_sql_service().update_routine(routine_info, &trans)); + } + OZ (new_package_info.assign(package_info)); + OZ (schema_service_.gen_new_schema_version(tenant_id, new_schema_version)); + OX (new_package_info.set_schema_version(new_schema_version)); + OZ (schema_service_impl->get_routine_sql_service().alter_package(new_package_info, &trans, ddl_stmt_str)); + } + } + OZ (error_info.handle_error_info(trans, &package_info)); + return ret; +} + int ObDDLOperator::drop_package(const ObPackageInfo &package_info, ObMySQLTransaction &trans, ObSchemaGetterGuard &schema_guard, diff --git a/src/rootserver/ob_ddl_operator.h b/src/rootserver/ob_ddl_operator.h index c509004f8..1676bfdd8 100644 --- a/src/rootserver/ob_ddl_operator.h +++ b/src/rootserver/ob_ddl_operator.h @@ -760,6 +760,11 @@ public: share::schema::ObErrorInfo &error_info, common::ObIArray &dep_infos, const common::ObString *ddl_stmt_str/*=NULL*/); + int alter_package(const share::schema::ObPackageInfo &package_info, + common::ObMySQLTransaction &trans, + ObIArray &public_routine_infos, + share::schema::ObErrorInfo &error_info, + const common::ObString *ddl_stmt_str); int drop_package(const share::schema::ObPackageInfo &package_info, common::ObMySQLTransaction &trans, share::schema::ObSchemaGetterGuard &schema_guard, diff --git a/src/rootserver/ob_ddl_service.cpp b/src/rootserver/ob_ddl_service.cpp index 7170b36b8..3835a2ed3 100644 --- a/src/rootserver/ob_ddl_service.cpp +++ b/src/rootserver/ob_ddl_service.cpp @@ -26630,6 +26630,46 @@ int ObDDLService::create_package(ObSchemaGetterGuard &schema_guard, return ret; } +int ObDDLService::alter_package(ObSchemaGetterGuard &schema_guard, + const ObPackageInfo &package_info, + ObIArray &public_routine_infos, + share::schema::ObErrorInfo &error_info, + const ObString *ddl_stmt_str) +{ + int ret = OB_SUCCESS; + uint64_t tenant_id = package_info.get_tenant_id(); + if (OB_FAIL(check_inner_stat())) { + LOG_WARN("variable is not init", KR(ret)); + } else { + const uint64_t tenant_id = package_info.get_tenant_id(); + ObDDLSQLTransaction trans(schema_service_); + ObDDLOperator ddl_operator(*schema_service_, *sql_proxy_); + int64_t refreshed_schema_version = 0; + if (OB_FAIL(schema_guard.get_schema_version(tenant_id, refreshed_schema_version))) { + LOG_WARN("failed to get tenant schema version", KR(ret), K(tenant_id)); + } else if (OB_FAIL(trans.start(sql_proxy_, tenant_id, refreshed_schema_version))) { + LOG_WARN("start transaction failed", KR(ret), K(tenant_id), K(refreshed_schema_version)); + } else if (OB_FAIL(ddl_operator.alter_package(package_info, trans, public_routine_infos, + error_info, ddl_stmt_str))) { + LOG_WARN("alter package failed", K(package_info), K(ret)); + } + if (trans.is_started()) { + int temp_ret = OB_SUCCESS; + if (OB_SUCCESS != (temp_ret = trans.end(OB_SUCC(ret)))) { + LOG_WARN("trans end failed", "is_commit", OB_SUCC(ret), K(temp_ret)); + ret = (OB_SUCC(ret)) ? temp_ret : ret; + } + } + + if (OB_SUCC(ret)) { + if (OB_FAIL(publish_schema(tenant_id))) { + LOG_WARN("publish schema failed", K(ret)); + } + } + } + return ret; +} + int ObDDLService::drop_package(const ObPackageInfo &package_info, ObErrorInfo &error_info, const ObString *ddl_stmt_str) diff --git a/src/rootserver/ob_ddl_service.h b/src/rootserver/ob_ddl_service.h index 5e7d691a6..8bba3bd6b 100644 --- a/src/rootserver/ob_ddl_service.h +++ b/src/rootserver/ob_ddl_service.h @@ -808,6 +808,11 @@ public: share::schema::ObErrorInfo &error_info, common::ObIArray &dep_infos, const common::ObString *ddl_stmt_str); + virtual int alter_package(share::schema::ObSchemaGetterGuard &schema_guard, + const ObPackageInfo &package_info, + ObIArray &public_routine_infos, + share::schema::ObErrorInfo &error_info, + const common::ObString *ddl_stmt_str); virtual int drop_package(const share::schema::ObPackageInfo &package_info, share::schema::ObErrorInfo &error_info, const common::ObString *ddl_stmt_str); diff --git a/src/rootserver/ob_root_service.cpp b/src/rootserver/ob_root_service.cpp index 4fb5a3f48..ec638dd0e 100644 --- a/src/rootserver/ob_root_service.cpp +++ b/src/rootserver/ob_root_service.cpp @@ -6365,9 +6365,64 @@ int ObRootService::create_package(const obrpc::ObCreatePackageArg &arg) int ObRootService::alter_package(const obrpc::ObAlterPackageArg &arg) { - UNUSED(arg); - // need not LOG_UESR_ERROR, actually 'alter trigger' is not supported in oracle parser now. - return OB_NOT_SUPPORTED; + int ret = OB_SUCCESS; + if (!inited_) { + ret = OB_NOT_INIT; + LOG_WARN("not init", K(ret)); + } else if (!arg.is_valid()) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid arg", K(arg), K(ret)); + } else { + uint64_t tenant_id = arg.tenant_id_; + const ObString &db_name = arg.db_name_; + const ObString &package_name = arg.package_name_; + ObPackageType package_type = arg.package_type_; + int64_t compatible_mode = arg.compatible_mode_; + ObSchemaGetterGuard schema_guard; + const ObDatabaseSchema *db_schema = NULL; + if (OB_FAIL(ddl_service_.get_tenant_schema_guard_with_version_in_inner_table(tenant_id, schema_guard))) { + LOG_WARN("get schema guard in inner table failed", K(ret)); + } else if (OB_FAIL(schema_guard.get_database_schema(tenant_id, db_name, db_schema))) { + LOG_WARN("get database schema failed", K(ret)); + } else if (NULL == db_schema) { + ret = OB_ERR_BAD_DATABASE; + LOG_WARN("database id is invalid", K(tenant_id), K(db_name), K(ret)); + } else if (db_schema->is_in_recyclebin()) { + ret = OB_ERR_OPERATION_ON_RECYCLE_OBJECT; + LOG_WARN("Can't not create package of db in recyclebin", K(ret), K(arg), K(*db_schema)); + } + if (OB_SUCC(ret)) { + bool exist = false; + ObSArray &public_routine_infos = const_cast &>(arg.public_routine_infos_); + if (OB_FAIL(schema_guard.check_package_exist(tenant_id, db_schema->get_database_id(), + package_name, package_type, compatible_mode, exist))) { + LOG_WARN("failed to check package info exist", K(package_name), K(ret)); + } else if (exist) { + const ObPackageInfo *package_info = NULL; + if (OB_FAIL(schema_guard.get_package_info(tenant_id, db_schema->get_database_id(), package_name, package_type, + compatible_mode, package_info))) { + LOG_WARN("get package info failed", K(ret)); + } else if (OB_ISNULL(package_info)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("package info is null", K(db_schema->get_database_id()), K(package_name), K(package_type), K(ret)); + } else if (OB_FAIL(ddl_service_.alter_package(schema_guard, + *package_info, + public_routine_infos, + const_cast(arg.error_info_), + &arg.ddl_stmt_str_))) { + LOG_WARN("drop package failed", K(ret), K(package_name)); + } + } else { + ret = OB_ERR_PACKAGE_DOSE_NOT_EXIST; + const char *type = (package_type == PACKAGE_TYPE ? "PACKAGE" : "PACKAGE BODY"); + LOG_USER_ERROR(OB_ERR_PACKAGE_DOSE_NOT_EXIST, type, + db_schema->get_database_name_str().length(), db_schema->get_database_name(), + package_name.length(), package_name.ptr()); + } + } + } + + return ret; } int ObRootService::drop_package(const obrpc::ObDropPackageArg &arg) diff --git a/src/share/ob_rpc_struct.cpp b/src/share/ob_rpc_struct.cpp index 1e26cbef8..4ad852ff7 100644 --- a/src/share/ob_rpc_struct.cpp +++ b/src/share/ob_rpc_struct.cpp @@ -4453,7 +4453,27 @@ bool ObAlterPackageArg::is_valid() const && INVALID_PACKAGE_TYPE != package_type_; } -OB_SERIALIZE_MEMBER((ObAlterPackageArg, ObDDLArg), tenant_id_, db_name_, package_name_, package_type_); +int ObAlterPackageArg::assign(const ObAlterPackageArg &other) +{ + int ret = OB_SUCCESS; + if (OB_FAIL(ObDDLArg::assign(other))) { + LOG_WARN("fail to assign ddl arg", KR(ret)); + } else if (OB_FAIL(public_routine_infos_.assign(other.public_routine_infos_))) { + LOG_WARN("fail to assign array", K(ret)); + } else if (OB_FAIL(error_info_.assign(other.error_info_))) { + LOG_WARN("failed to copy error info", K(ret)); + } else { + tenant_id_ = other.tenant_id_; + db_name_ = other.db_name_; + package_name_ = other.package_name_; + package_type_ = other.package_type_; + compatible_mode_ = other.compatible_mode_; + } + return ret; +} + +OB_SERIALIZE_MEMBER((ObAlterPackageArg, ObDDLArg), tenant_id_, db_name_, package_name_, package_type_, + compatible_mode_, public_routine_infos_, error_info_); bool ObDropPackageArg::is_valid() const { diff --git a/src/share/ob_rpc_struct.h b/src/share/ob_rpc_struct.h index 04783817d..c9baf7ece 100644 --- a/src/share/ob_rpc_struct.h +++ b/src/share/ob_rpc_struct.h @@ -5353,15 +5353,24 @@ public: : tenant_id_(common::OB_INVALID_ID), db_name_(), package_name_(), - package_type_(share::schema::INVALID_PACKAGE_TYPE) {} + package_type_(share::schema::INVALID_PACKAGE_TYPE), + compatible_mode_(-1), + public_routine_infos_(), + error_info_() + {} virtual ~ObAlterPackageArg() {} bool is_valid() const; - TO_STRING_KV(K_(tenant_id), K_(db_name), K_(package_name), K_(package_type)); + int assign(const ObAlterPackageArg &other); + TO_STRING_KV(K_(tenant_id), K_(db_name), K_(package_name), K_(package_type), + K_(compatible_mode), K_(public_routine_infos), K_(error_info)); uint64_t tenant_id_; common::ObString db_name_; common::ObString package_name_; share::schema::ObPackageType package_type_; + int64_t compatible_mode_; + common::ObSArray public_routine_infos_; + share::schema::ObErrorInfo error_info_; }; struct ObDropPackageArg : public ObDDLArg @@ -5458,7 +5467,7 @@ OB_UNIS_VERSION(1); public: ObAlterTriggerArg() : - ObDDLArg(), trigger_info_() + ObDDLArg(), trigger_database_(), trigger_info_() {} virtual ~ObAlterTriggerArg() {} diff --git a/src/share/schema/ob_routine_sql_service.cpp b/src/share/schema/ob_routine_sql_service.cpp index 1ed8c9722..c1f91340b 100644 --- a/src/share/schema/ob_routine_sql_service.cpp +++ b/src/share/schema/ob_routine_sql_service.cpp @@ -91,6 +91,34 @@ int ObRoutineSqlService::drop_package(const ObPackageInfo &package_info, return ret; } +int ObRoutineSqlService::alter_package(const ObPackageInfo &package_info, + common::ObISQLClient *sql_client, + const common::ObString *ddl_stmt_str) +{ + int ret = OB_SUCCESS; + if (OB_ISNULL(sql_client)) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("sql_client is NULL, ", K(ret)); + } else if (!package_info.is_valid()) { + ret = OB_INVALID_ARGUMENT; + SHARE_SCHEMA_LOG(WARN, "package_info is invalid", K(package_info), K(ret)); + } else if (OB_FAIL(add_package(*sql_client, package_info, true))) { + LOG_WARN("add package failed", K(ret)); + } else { + ObSchemaOperation opt; + opt.tenant_id_ = package_info.get_tenant_id(); + opt.database_id_ = package_info.get_database_id(); + opt.table_id_ = package_info.get_package_id(); + opt.op_type_ = OB_DDL_ALTER_PACKAGE; + opt.schema_version_ = package_info.get_schema_version(); + opt.ddl_stmt_str_ = (NULL != ddl_stmt_str) ? *ddl_stmt_str : ObString(); + if (OB_FAIL(log_operation(opt, *sql_client))) { + LOG_WARN("Failed to log operation", K(ret)); + } + } + return ret; +} + int ObRoutineSqlService::add_package(common::ObISQLClient &sql_client, const ObPackageInfo &package_info, bool is_replace, diff --git a/src/share/schema/ob_routine_sql_service.h b/src/share/schema/ob_routine_sql_service.h index 08ac6e394..79c7e94bf 100644 --- a/src/share/schema/ob_routine_sql_service.h +++ b/src/share/schema/ob_routine_sql_service.h @@ -55,9 +55,9 @@ public: common::ObISQLClient *sql_client, bool is_replace, const common::ObString *ddl_stmt_str = NULL); - int alter_package(ObPackageInfo &package_info, + int alter_package(const ObPackageInfo &package_info, common::ObISQLClient *sql_client, - const common::ObString *ddl_stmt_str = NULL); + const common::ObString *ddl_stmt_str); int drop_package(const ObPackageInfo &package_info, const int64_t new_schema_version, common::ObISQLClient &sql_client, diff --git a/src/sql/engine/cmd/ob_package_executor.cpp b/src/sql/engine/cmd/ob_package_executor.cpp index 26f72f710..b4758fcf1 100644 --- a/src/sql/engine/cmd/ob_package_executor.cpp +++ b/src/sql/engine/cmd/ob_package_executor.cpp @@ -78,11 +78,9 @@ int ObAlterPackageExecutor::execute(ObExecContext &ctx, ObAlterPackageStmt &stmt } else if (OB_ISNULL(common_rpc_proxy)){ ret = OB_ERR_UNEXPECTED; LOG_WARN("common rpc proxy should not be null", K(ret)); - } /* - TODO: 暂无需要发到RootService端的需求, 暂时注掉 - else if (OB_FAIL(common_rpc_proxy->alter_package(arg))) { + } else if (OB_FAIL(common_rpc_proxy->alter_package(arg))) { LOG_WARN("rpc proxy drop procedure failed", K(ret), "dst", common_rpc_proxy->get_server()); - } */ + } return ret; } diff --git a/src/sql/resolver/ddl/ob_alter_package_resolver.cpp b/src/sql/resolver/ddl/ob_alter_package_resolver.cpp index 4714e8022..9f2728860 100644 --- a/src/sql/resolver/ddl/ob_alter_package_resolver.cpp +++ b/src/sql/resolver/ddl/ob_alter_package_resolver.cpp @@ -18,6 +18,7 @@ #include "pl/parser/parse_stmt_item_type.h" #include "pl/ob_pl_package.h" #include "pl/ob_pl_compile.h" +#include "sql/resolver/ddl/ob_create_package_resolver.h" namespace oceanbase { @@ -48,16 +49,17 @@ int ObAlterPackageResolver::resolve(const ParseNode &parse_tree) stmt::T_ALTER_ROUTINE, session_info_->get_enable_role_array())); } - OZ (resolve_alter_clause(*alter_clause, db_name, package_name)); - if (OB_SUCC(ret) && OB_ISNULL(alter_package_stmt = create_stmt())) { - ret = OB_ALLOCATE_MEMORY_FAILED; - LOG_WARN("failed to alloc memory for ObAlterPackageStmt", K(ret)); - } + OV (OB_NOT_NULL(alter_package_stmt = create_stmt()), OB_ALLOCATE_MEMORY_FAILED); + OX (alter_package_stmt->get_alter_package_arg().db_name_ = db_name); + OX (alter_package_stmt->get_alter_package_arg().package_name_ = package_name); + OZ (resolve_alter_clause(*alter_clause, db_name, package_name, alter_package_stmt->get_alter_package_arg())); return ret; } -int ObAlterPackageResolver::resolve_alter_clause( - const ParseNode &alter_clause, const ObString &db_name, const ObString &package_name) +int ObAlterPackageResolver::resolve_alter_clause(const ParseNode &alter_clause, + const ObString &db_name, + const ObString &package_name, + obrpc::ObAlterPackageArg &pkg_arg) { int ret = OB_SUCCESS; CK (OB_LIKELY(T_PACKAGE_ALTER_OPTIONS == alter_clause.type_)); @@ -68,13 +70,15 @@ int ObAlterPackageResolver::resolve_alter_clause( LOG_WARN("alter editionable is not supported yet!", K(ret)); LOG_USER_ERROR(OB_NOT_SUPPORTED, "alter editionable"); } else { - OZ (resolve_alter_compile_clause(alter_clause, db_name, package_name)); + OZ (resolve_alter_compile_clause(alter_clause, db_name, package_name, pkg_arg)); } return ret; } -int ObAlterPackageResolver::resolve_alter_compile_clause( - const ParseNode &alter_clause, const ObString &db_name, const ObString &package_name) +int ObAlterPackageResolver::resolve_alter_compile_clause(const ParseNode &alter_clause, + const ObString &db_name, + const ObString &package_name, + obrpc::ObAlterPackageArg &pkg_arg) { int ret = OB_SUCCESS; bool compile_spec = false; @@ -91,7 +95,7 @@ int ObAlterPackageResolver::resolve_alter_compile_clause( } else if (PACKAGE_UNIT_SPECIFICATION == alter_clause.int16_values_[2]) { compile_spec = true; } - OZ (compile_package(db_name, package_name, compile_spec, compile_body)); + OZ (compile_package(db_name, package_name, compile_spec, compile_body, pkg_arg)); return ret; } @@ -127,7 +131,7 @@ int ObAlterPackageResolver::analyze_package(ObPLCompiler &compiler, const ObString &package_name, const ObPackageInfo *package_info, share::schema::ObErrorInfo &error_info, - const bool need_delete_error_info) + bool &has_error) { int ret = OB_SUCCESS; if (OB_FAIL(compiler.analyze_package(source, parent_ns, package_ast, is_for_trigger))) { @@ -142,25 +146,27 @@ int ObAlterPackageResolver::analyze_package(ObPLCompiler &compiler, default: LOG_USER_WARN(OB_ERR_PACKAGE_COMPILE_ERROR, is_package ? "PACKAGE" : "PACKAGE BODY", db_name.length(), db_name.ptr(), package_name.length(), package_name.ptr()); + has_error = true; ret = OB_SUCCESS; break; } - collec_error_info(package_info, error_info); - } else if (need_delete_error_info) { - OZ (error_info.delete_error(package_info)); + error_info.collect_error_info(package_info); } return ret; } -int ObAlterPackageResolver::compile_package( - const ObString& db_name, const ObString &package_name, bool compile_spec, bool compile_body) +int ObAlterPackageResolver::compile_package(const ObString& db_name, + const ObString &package_name, + bool compile_spec, + bool compile_body, + obrpc::ObAlterPackageArg &pkg_arg) { int ret = OB_SUCCESS; const ObPackageInfo *package_spec_info = NULL; const ObPackageInfo *package_body_info = NULL; int64_t compatible_mode = lib::is_oracle_mode() ? COMPATIBLE_ORACLE_MODE : COMPATIBLE_MYSQL_MODE; - share::schema::ObErrorInfo error_info; + share::schema::ObErrorInfo &error_info = pkg_arg.error_info_; HEAP_VARS_2((ObPLPackageAST, package_spec_ast, *allocator_), (ObPLPackageAST, package_body_ast, *allocator_)) { ObPLPackageGuard package_guard(session_info_->get_effective_tenant_id()); @@ -170,6 +176,7 @@ int ObAlterPackageResolver::compile_package( package_guard, *(params_.sql_proxy_)); ObString source; + bool has_error = false; OZ (package_guard.init()); OZ (schema_checker_->get_package_info(session_info_->get_effective_tenant_id(), db_name, @@ -188,7 +195,7 @@ int ObAlterPackageResolver::compile_package( OZ (ObSQLUtils::convert_sql_text_from_schema_for_resolve( *allocator_, session_info_->get_dtc_params(), source)); OZ (analyze_package(compiler, source, NULL, package_spec_ast, false, true, - db_name, package_name, package_spec_info, error_info, false)); + db_name, package_name, package_spec_info, error_info, has_error)); if (OB_FAIL(ret)) { // error msg has fixed in analyze_package } else if (1 == package_spec_ast.get_routine_table().get_count() @@ -220,7 +227,7 @@ int ObAlterPackageResolver::compile_package( OB_INVALID_VERSION, &package_spec_ast)); OZ (analyze_package(compiler, source, &(package_spec_ast.get_body()->get_namespace()), - package_body_ast, false, false, db_name, package_name, package_body_info, error_info, true)); + package_body_ast, false, false, db_name, package_name, package_body_info, error_info, has_error)); } else if (OB_ERR_PACKAGE_DOSE_NOT_EXIST == ret) { ret = OB_SUCCESS; OZ (error_info.delete_error(package_spec_info)); @@ -246,6 +253,7 @@ int ObAlterPackageResolver::compile_package( if (OB_FAIL(ret)) { } else if (compile_body || (!compile_body && !compile_spec)) { ObString source; + has_error = false; OZ (schema_checker_->get_package_info(session_info_->get_effective_tenant_id(), db_name, package_name, @@ -263,7 +271,26 @@ int ObAlterPackageResolver::compile_package( OB_INVALID_VERSION, &package_spec_ast)); OZ (analyze_package(compiler, source, &(package_spec_ast.get_body()->get_namespace()), - package_body_ast, false, false, db_name, package_name, package_body_info, error_info, true)); + package_body_ast, false, false, db_name, package_name, package_body_info, error_info, has_error)); + OX (pkg_arg.tenant_id_ = package_body_info->get_tenant_id()); + OX (pkg_arg.package_type_ = package_body_info->get_type()); + OX (pkg_arg.compatible_mode_ = package_body_info->get_compatibility_mode()); + if (OB_SUCC(ret) && !has_error) { + // if has_error, don't need to update routine route sql + ObArray routine_infos; + ObPLRoutineTable &spec_routine_table = package_spec_ast.get_routine_table(); + ObPLRoutineTable &body_routine_table = package_body_ast.get_routine_table(); + OZ (schema_checker_->get_schema_guard()->get_routine_infos_in_package( + session_info_->get_effective_tenant_id(), + package_spec_info->get_package_id(), + routine_infos)); + OZ (ObCreatePackageBodyResolver::update_routine_route_sql(*allocator_, + *session_info_, + pkg_arg.public_routine_infos_, + spec_routine_table, + body_routine_table, + routine_infos)); + } } } // TODO: collect error info diff --git a/src/sql/resolver/ddl/ob_alter_package_resolver.h b/src/sql/resolver/ddl/ob_alter_package_resolver.h index 5049eca09..98c1ce810 100644 --- a/src/sql/resolver/ddl/ob_alter_package_resolver.h +++ b/src/sql/resolver/ddl/ob_alter_package_resolver.h @@ -32,10 +32,14 @@ public: virtual int resolve(const ParseNode &parse_tree); private: - int resolve_alter_clause( - const ParseNode &alter_clause, const ObString &db_name, const ObString &package_name); - int resolve_alter_compile_clause( - const ParseNode &alter_clause, const ObString &db_name, const ObString &package_name); + int resolve_alter_clause(const ParseNode &alter_clause, + const ObString &db_name, + const ObString &package_name, + obrpc::ObAlterPackageArg &pkg_arg); + int resolve_alter_compile_clause(const ParseNode &alter_clause, + const ObString &db_name, + const ObString &package_name, + obrpc::ObAlterPackageArg &pkg_arg); int analyze_package(pl::ObPLCompiler &compiler, const ObString &source, const pl::ObPLBlockNS *parent_ns, @@ -46,9 +50,12 @@ private: const ObString &package_name, const ObPackageInfo *package_info, share::schema::ObErrorInfo &error_info, - const bool need_delete_error_info); - int compile_package( - const ObString& db_name, const ObString &package_name, bool compile_spec, bool compile_body); + bool &has_error); + int compile_package(const ObString& db_name, + const ObString &package_name, + bool compile_spec, + bool compile_body, + obrpc::ObAlterPackageArg &pkg_arg); int collec_error_info(const ObPackageInfo *package_info, share::schema::ObErrorInfo &error_info); diff --git a/src/sql/resolver/ddl/ob_create_package_resolver.cpp b/src/sql/resolver/ddl/ob_create_package_resolver.cpp index 7f9f12fa9..8c4708e7e 100644 --- a/src/sql/resolver/ddl/ob_create_package_resolver.cpp +++ b/src/sql/resolver/ddl/ob_create_package_resolver.cpp @@ -559,7 +559,8 @@ int ObCreatePackageBodyResolver::resolve(const ParseNode &parse_tree) if (OB_SUCC(ret)) { obrpc::ObCreatePackageArg &create_package_arg = stmt->get_create_package_arg(); ObIArray &routine_list = create_package_arg.public_routine_infos_; - const ObPLRoutineTable &routine_table = package_body_ast.get_routine_table(); + const ObPLRoutineTable &spec_routine_table = package_spec_ast.get_routine_table(); + const ObPLRoutineTable &body_routine_table = package_body_ast.get_routine_table(); ObRoutineInfo routine_info; const ObPLRoutineInfo *pl_routine_info = NULL; ObArray routine_infos; @@ -569,30 +570,8 @@ int ObCreatePackageBodyResolver::resolve(const ParseNode &parse_tree) OZ (schema_checker_->get_schema_guard()->get_routine_infos_in_package( session_info_->get_effective_tenant_id(), package_spec_info->get_package_id(), routine_infos)); - for (int64_t i = ObPLRoutineTable::NORMAL_ROUTINE_START_IDX; - OB_SUCC(ret) && i < package_spec_ast.get_routine_table().get_count(); i++) { - const ObRoutineInfo* tmp_routine_info = NULL; - bool found = false; - OX (routine_info.reset()); - OZ (routine_table.get_routine_info(i, pl_routine_info)); - for (int64_t j = 0; OB_SUCC(ret) && j < routine_infos.count(); ++j) { - tmp_routine_info = routine_infos.at(j); - if (tmp_routine_info->get_subprogram_id() == i) { - ObString route_sql = pl_routine_info->get_route_sql(); - ObString routine_body = pl_routine_info->get_routine_body(); - CK (false == found); - OX (found = true); - OX (routine_info = *tmp_routine_info); - OZ (ObSQLUtils::convert_sql_text_to_schema_for_storing( - *allocator_, session_info_->get_dtc_params(), route_sql)); - OX (routine_info.set_route_sql(route_sql)); - OZ (ObSQLUtils::convert_sql_text_to_schema_for_storing( - *allocator_, session_info_->get_dtc_params(), routine_body)); - OX (routine_info.set_routine_body(routine_body)); - } - } - OZ (routine_list.push_back(routine_info)); - } + OZ (update_routine_route_sql(*allocator_, *session_info_, routine_list, + spec_routine_table, body_routine_table, routine_infos)); } if (OB_FAIL(ret) && ret != OB_ERR_UNEXPECTED && ret != OB_ERR_TOO_LONG_IDENT) { LOG_USER_WARN(OB_ERR_PACKAGE_COMPILE_ERROR, "PACKAGE BODY", @@ -674,5 +653,41 @@ int ObCreatePackageBodyResolver::resolve(const ParseNode &parse_tree) } return ret; } + +int ObCreatePackageBodyResolver::update_routine_route_sql(ObIAllocator &allocator, + const ObSQLSessionInfo &session_info, + ObIArray &public_routine_list, + const ObPLRoutineTable &spec_routine_table, + const ObPLRoutineTable &body_routine_table, + ObArray &routine_infos) +{ + int ret = OB_SUCCESS; + const ObPLRoutineInfo *pl_routine_info = NULL; + ObRoutineInfo routine_info; + for (int64_t i = ObPLRoutineTable::NORMAL_ROUTINE_START_IDX; + OB_SUCC(ret) && i < spec_routine_table.get_count(); i++) { + const ObRoutineInfo* tmp_routine_info = NULL; + bool found = false; + OX (routine_info.reset()); + OZ (body_routine_table.get_routine_info(i, pl_routine_info)); + for (int64_t j = 0; OB_SUCC(ret) && j < routine_infos.count(); ++j) { + tmp_routine_info = routine_infos.at(j); + if (tmp_routine_info->get_subprogram_id() == i) { + ObString route_sql = pl_routine_info->get_route_sql(); + ObString routine_body = pl_routine_info->get_routine_body(); + CK (false == found); + OX (found = true); + OX (routine_info = *tmp_routine_info); + OZ (ObSQLUtils::convert_sql_text_to_schema_for_storing(allocator, session_info.get_dtc_params(), route_sql)); + OX (routine_info.set_route_sql(route_sql)); + OZ (ObSQLUtils::convert_sql_text_to_schema_for_storing(allocator, session_info.get_dtc_params(), routine_body)); + OX (routine_info.set_routine_body(routine_body)); + } + } + OZ (public_routine_list.push_back(routine_info)); + } + return ret; +} + } //namespace sql } //namespace oceanbase diff --git a/src/sql/resolver/ddl/ob_create_package_resolver.h b/src/sql/resolver/ddl/ob_create_package_resolver.h index 5d1b538cb..d060372c6 100644 --- a/src/sql/resolver/ddl/ob_create_package_resolver.h +++ b/src/sql/resolver/ddl/ob_create_package_resolver.h @@ -53,6 +53,12 @@ public: explicit ObCreatePackageBodyResolver(ObResolverParams ¶ms) : ObDDLResolver(params) {} virtual ~ObCreatePackageBodyResolver() {} virtual int resolve(const ParseNode &parse_tree); + static int update_routine_route_sql(ObIAllocator &allocator, + const ObSQLSessionInfo &session_info, + ObIArray &public_routine_list, + const pl::ObPLRoutineTable &spec_routine_table, + const pl::ObPLRoutineTable &body_routine_table, + ObArray &routine_infos); private: DISALLOW_COPY_AND_ASSIGN(ObCreatePackageBodyResolver); };