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

[to #45393823]update route_sql when alter package compile

Browse Source
This commit is contained in:
seuwebber 2022-11-29 13:35:43 +00:00 committed by ob-robot
parent 41d204312e
commit 7e357ea8c9
14 changed files with 315 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/rootserver/ob_ddl_operator.cpp
View File

@ -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<ObRoutineInfo> &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,

5
src/rootserver/ob_ddl_operator.h
View File

@ -760,6 +760,11 @@ public:
share::schema::ObErrorInfo &error_info,
common::ObIArray<share::schema::ObDependencyInfo> &dep_infos,
const common::ObString *ddl_stmt_str/*=NULL*/);
int alter_package(const share::schema::ObPackageInfo &package_info,
common::ObMySQLTransaction &trans,
ObIArray<ObRoutineInfo> &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,

40
src/rootserver/ob_ddl_service.cpp
View File

@ -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<ObRoutineInfo> &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)

5
src/rootserver/ob_ddl_service.h
View File

@ -808,6 +808,11 @@ public:
share::schema::ObErrorInfo &error_info,
common::ObIArray<share::schema::ObDependencyInfo> &dep_infos,
const common::ObString *ddl_stmt_str);
virtual int alter_package(share::schema::ObSchemaGetterGuard &schema_guard,
const ObPackageInfo &package_info,
ObIArray<ObRoutineInfo> &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);

61
src/rootserver/ob_root_service.cpp
View File

@ -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<ObRoutineInfo> &public_routine_infos = const_cast<ObSArray<ObRoutineInfo> &>(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<ObErrorInfo &>(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)

22
src/share/ob_rpc_struct.cpp
View File

@ -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
{

15
src/share/ob_rpc_struct.h
View File

@ -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<share::schema::ObRoutineInfo> 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()
{}

28
src/share/schema/ob_routine_sql_service.cpp
View File

@ -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,

4
src/share/schema/ob_routine_sql_service.h
View File

@ -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,

6
src/sql/engine/cmd/ob_package_executor.cpp
View File

@ -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;
}

69
src/sql/resolver/ddl/ob_alter_package_resolver.cpp
View File

@ -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<ObAlterPackageStmt>())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("failed to alloc memory for ObAlterPackageStmt", K(ret));
}
OV (OB_NOT_NULL(alter_package_stmt = create_stmt<ObAlterPackageStmt>()), 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<const ObRoutineInfo *> 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

21
src/sql/resolver/ddl/ob_alter_package_resolver.h
View File

@ -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);

65
src/sql/resolver/ddl/ob_create_package_resolver.cpp
View File

@ -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<ObRoutineInfo> &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<const ObRoutineInfo *> 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<ObRoutineInfo> &public_routine_list,
const ObPLRoutineTable &spec_routine_table,
const ObPLRoutineTable &body_routine_table,
ObArray<const ObRoutineInfo *> &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

6
src/sql/resolver/ddl/ob_create_package_resolver.h
View File

@ -53,6 +53,12 @@ public:
explicit ObCreatePackageBodyResolver(ObResolverParams &params) : ObDDLResolver(params) {}
virtual ~ObCreatePackageBodyResolver() {}
virtual int resolve(const ParseNode &parse_tree);
static int update_routine_route_sql(ObIAllocator &allocator,
const ObSQLSessionInfo &session_info,
ObIArray<ObRoutineInfo> &public_routine_list,
const pl::ObPLRoutineTable &spec_routine_table,
const pl::ObPLRoutineTable &body_routine_table,
ObArray<const ObRoutineInfo *> &routine_infos);
private:
DISALLOW_COPY_AND_ASSIGN(ObCreatePackageBodyResolver);
};