diff --git a/src/sql/engine/expr/ob_expr_obj_access.cpp b/src/sql/engine/expr/ob_expr_obj_access.cpp index 1083139fc7..83cd6112cf 100644 --- a/src/sql/engine/expr/ob_expr_obj_access.cpp +++ b/src/sql/engine/expr/ob_expr_obj_access.cpp @@ -335,43 +335,45 @@ int ObExprObjAccess::ExtraInfo::get_attr_func(int64_t param_cnt, ObEvalCtx &ctx) const { int ret = OB_SUCCESS; - pl::ObPLComposite *composite_addr - = reinterpret_cast(params[access_idxs_.at(0).var_index_]); void *current_value = NULL; CK (OB_NOT_NULL(element_val)); CK (access_idxs_.count() > 0); - for (int64_t i = 1; OB_SUCC(ret) && i < access_idxs_.count(); ++i) { - const pl::ObPLDataType &parent_type = access_idxs_.at(i - 1).var_type_; - const pl::ObObjAccessIdx &parent_access = access_idxs_.at(i - 1); - const pl::ObObjAccessIdx ¤t_access = access_idxs_.at(i); - current_value = composite_addr; - if (parent_type.is_collection_type()) { - OZ (get_collection_attr(params, - current_access, - for_write_, - current_value)); - } else { - OZ (get_record_attr(current_access, - parent_type.get_user_type_id(), - for_write_, - current_value, - ctx));; + if (OB_SUCC(ret)) { + pl::ObPLComposite *composite_addr + = reinterpret_cast(params[access_idxs_.at(0).var_index_]); + for (int64_t i = 1; OB_SUCC(ret) && i < access_idxs_.count(); ++i) { + const pl::ObPLDataType &parent_type = access_idxs_.at(i - 1).var_type_; + const pl::ObObjAccessIdx &parent_access = access_idxs_.at(i - 1); + const pl::ObObjAccessIdx ¤t_access = access_idxs_.at(i); + current_value = composite_addr; + if (parent_type.is_collection_type()) { + OZ (get_collection_attr(params, + current_access, + for_write_, + current_value)); + } else { + OZ (get_record_attr(current_access, + parent_type.get_user_type_id(), + for_write_, + current_value, + ctx));; + } + if (OB_FAIL(ret)) { + } else if (current_access.var_type_.is_composite_type()) { + ObObj* value = reinterpret_cast(current_value); + CK (OB_NOT_NULL(value)); + CK (value->is_ext()); + OX (composite_addr = reinterpret_cast(value->get_ext())); + CK (OB_NOT_NULL(composite_addr)); + } } if (OB_FAIL(ret)) { - } else if (current_access.var_type_.is_composite_type()) { - ObObj* value = reinterpret_cast(current_value); - CK (OB_NOT_NULL(value)); - CK (value->is_ext()); - OX (composite_addr = reinterpret_cast(value->get_ext())); - CK (OB_NOT_NULL(composite_addr)); + } else if (pl::ObObjAccessIdx::get_final_type(access_idxs_).is_obj_type()) { + *element_val = reinterpret_cast(current_value); + } else { + *element_val = reinterpret_cast(composite_addr); } } - if (OB_FAIL(ret)) { - } else if (pl::ObObjAccessIdx::get_final_type(access_idxs_).is_obj_type()) { - *element_val = reinterpret_cast(current_value); - } else { - *element_val = reinterpret_cast(composite_addr); - } return ret; } diff --git a/src/sql/optimizer/ob_log_table_scan.cpp b/src/sql/optimizer/ob_log_table_scan.cpp index 48ce7cd1d0..75021d796f 100644 --- a/src/sql/optimizer/ob_log_table_scan.cpp +++ b/src/sql/optimizer/ob_log_table_scan.cpp @@ -559,10 +559,11 @@ int ObLogTableScan::extract_pushdown_filters(ObIArray &nonpushdown_f if (OB_FAIL(nonpushdown_filters.push_back(filters.at(i)))) { LOG_WARN("push dynamic filter to store non-pushdown filter failed", K(ret), K(i)); } - } else if (filters.at(i)->has_flag(CNT_PL_UDF)) { - //User Define Function filter do not push down to storage + } else if (filters.at(i)->has_flag(CNT_PL_UDF) || + filters.at(i)->has_flag(CNT_OBJ_ACCESS_EXPR)) { + //User Define Function/obj access expr filter do not push down to storage if (OB_FAIL(nonpushdown_filters.push_back(filters.at(i)))) { - LOG_WARN("push UDF filter store non-pushdown filter failed", K(ret), K(i)); + LOG_WARN("push UDF/obj access filter store non-pushdown filter failed", K(ret), K(i)); } } else if (filters.at(i)->has_flag(CNT_DYNAMIC_USER_VARIABLE) || filters.at(i)->has_flag(CNT_ASSIGN_EXPR)) { diff --git a/src/sql/resolver/dml/ob_dml_resolver.cpp b/src/sql/resolver/dml/ob_dml_resolver.cpp index 37be0c3ca0..895f1bd234 100755 --- a/src/sql/resolver/dml/ob_dml_resolver.cpp +++ b/src/sql/resolver/dml/ob_dml_resolver.cpp @@ -11157,6 +11157,136 @@ int ObDMLResolver::generate_check_constraint_exprs(const TableItem *table_item, return ret; } +int ObDMLResolver::collect_schema_version(ObRawExpr *expr) +{ + int ret = OB_SUCCESS; + ObDMLStmt *stmt = get_stmt(); + CK (OB_NOT_NULL(expr)); + CK (OB_NOT_NULL(stmt)); + + if (OB_FAIL(ret)) { + } else if (T_OP_GET_PACKAGE_VAR == expr->get_expr_type()) { + uint64_t package_id = OB_INVALID_ID; + const ObPackageInfo *spec_info = NULL; + const ObPackageInfo *body_info = NULL; + uint64_t dep_obj_id = view_ref_id_; + ObSchemaObjVersion ver; + CK (expr->get_param_count() >= 3); + OX (package_id = static_cast(expr->get_param_expr(0))->get_value().get_uint64()); + if (package_id != OB_INVALID_ID) { + OZ (pl::ObPLPackageManager::get_package_schema_info(*schema_checker_->get_schema_guard(), package_id, spec_info, body_info)); + } + if (OB_NOT_NULL(spec_info)) { + OX (ver.object_id_ = spec_info->get_package_id()); + OX (ver.version_ = spec_info->get_schema_version()); + OX (ver.object_type_ = DEPENDENCY_PACKAGE); + OZ (stmt->add_global_dependency_table(ver)); + OZ (stmt->add_ref_obj_version(dep_obj_id, spec_info->get_database_id(), ObObjectType::VIEW, ver, *allocator_)); + } + if (OB_NOT_NULL(body_info)) { + OX (ver.object_id_ = body_info->get_package_id()); + OX (ver.version_ = body_info->get_schema_version()); + OX (ver.object_type_ = DEPENDENCY_PACKAGE_BODY); + OZ (stmt->add_global_dependency_table(ver)); + OZ (stmt->add_ref_obj_version(dep_obj_id, body_info->get_database_id(), ObObjectType::VIEW, ver, *allocator_)); + } + } else if (T_FUN_UDF == expr->get_expr_type()) { + ObUDFRawExpr *udf_expr = static_cast(expr); + ObSchemaObjVersion udf_version; + share::schema::ObSchemaGetterGuard *schema_guard = NULL; + uint64_t database_id = OB_INVALID_ID; + CK (OB_NOT_NULL(udf_expr)); + if (OB_FAIL(ret)) { + } else if (OB_ISNULL(schema_guard = params_.schema_checker_->get_schema_guard())) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("table schema is null", K(ret), K(schema_guard)); + } else if (OB_FAIL(schema_guard->get_database_id(session_info_->get_effective_tenant_id(), + udf_expr->get_database_name().empty() ? session_info_->get_database_name() : udf_expr->get_database_name(), + database_id))) { + LOG_WARN("failed to get database id", K(ret)); + } else { + bool exist = false; + uint64_t object_db_id = OB_INVALID_ID; + ObSynonymChecker synonym_checker; + ObString object_name; + OZ (ObResolverUtils::resolve_synonym_object_recursively(*params_.schema_checker_, + synonym_checker, + session_info_->get_effective_tenant_id(), + database_id, + udf_expr->get_func_name(), + object_db_id, object_name, exist)); + if (OB_SUCC(ret) && exist) { + for (int64_t i = 0; OB_SUCC(ret) && i < synonym_checker.get_synonym_ids().count(); ++i) { + int64_t schema_version = OB_INVALID_VERSION; + uint64_t obj_id = synonym_checker.get_synonym_ids().at(i); + uint64_t dep_db_id = synonym_checker.get_database_ids().at(i); + ObSchemaObjVersion syn_version; + OZ (schema_guard->get_schema_version(SYNONYM_SCHEMA, + session_info_->get_effective_tenant_id(), + obj_id, + schema_version)); + OX (syn_version.object_id_ = obj_id); + OX (syn_version.version_ = schema_version); + OX (syn_version.object_type_ = DEPENDENCY_SYNONYM); + OZ (stmt->add_global_dependency_table(syn_version)); + OZ (stmt->add_ref_obj_version(obj_id, dep_db_id, ObObjectType::SYNONYM, syn_version, *allocator_)); + } + } + if (OB_SUCC(ret) && udf_expr->need_add_dependency()) { + uint64_t dep_obj_id = view_ref_id_; + uint64_t dep_db_id = database_id; + OZ (udf_expr->get_schema_object_version(udf_version)); + OZ (stmt->add_global_dependency_table(udf_version)); + OZ (stmt->add_ref_obj_version(dep_obj_id, dep_db_id, ObObjectType::VIEW, udf_version, *allocator_)); + //for udf without params, we just set called_in_sql = true, + //if this expr go through pl :: build_raw_expr later, + //the flag will change to false; + OX (expr->set_is_called_in_sql(true)); + } + OZ (ObResolverUtils::set_parallel_info(*params_.session_info_, + *params_.schema_checker_->get_schema_guard(), + *expr, + stmt_->get_query_ctx()->udf_has_select_stmt_)); + OX (stmt_->get_query_ctx()->disable_udf_parallel_ |= !udf_expr->is_parallel_enable()); + if (OB_SUCC(ret) && + udf_expr->get_result_type().is_ext() && + (pl::PL_RECORD_TYPE == udf_expr->get_result_type().get_extend_type() || + pl::PL_NESTED_TABLE_TYPE == udf_expr->get_result_type().get_extend_type() || + pl::PL_VARRAY_TYPE == udf_expr->get_result_type().get_extend_type())) { + OX (stmt_->get_query_ctx()->disable_udf_parallel_ |= true); + } + } + } else if (T_FUN_PL_OBJECT_CONSTRUCT == expr->get_expr_type()) { + ObObjectConstructRawExpr *object_expr = static_cast(expr); + CK (OB_NOT_NULL(object_expr)); + OX (stmt_->get_query_ctx()->disable_udf_parallel_ |= true); + if (OB_SUCC(ret) && object_expr->need_add_dependency()) { + uint64_t dep_obj_id = view_ref_id_; + ObSchemaObjVersion coll_schema_version; + OZ (object_expr->get_schema_object_version(coll_schema_version)); + OZ (stmt->add_global_dependency_table(coll_schema_version)); + OZ (stmt->add_ref_obj_version(dep_obj_id, object_expr->get_database_id(), ObObjectType::VIEW, coll_schema_version, *allocator_)); + } + } else if (T_FUN_PL_COLLECTION_CONSTRUCT == expr->get_expr_type()) { + ObCollectionConstructRawExpr *coll_expr = static_cast(expr); + CK (OB_NOT_NULL(coll_expr)); + OX (stmt_->get_query_ctx()->disable_udf_parallel_ |= true); + if (OB_SUCC(ret) && coll_expr->need_add_dependency()) { + uint64_t dep_obj_id = view_ref_id_; + ObSchemaObjVersion coll_schema_version; + OZ (coll_expr->get_schema_object_version(coll_schema_version)); + OZ (stmt->add_global_dependency_table(coll_schema_version)); + OZ (stmt->add_ref_obj_version(dep_obj_id, coll_expr->get_database_id(), ObObjectType::VIEW, coll_schema_version, *allocator_)); + } + } else if (T_OBJ_ACCESS_REF == expr->get_expr_type()) { + for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) { + OZ (collect_schema_version(expr->get_param_expr(i))); + } + } + + return ret; +} + int ObDMLResolver::resolve_external_name(ObQualifiedName &q_name, ObIArray &columns, ObIArray &real_exprs, @@ -11196,102 +11326,8 @@ int ObDMLResolver::resolve_external_name(ObQualifiedName &q_name, } else if (OB_ISNULL(expr)) { ret = OB_ERR_UNEXPECTED; LOG_WARN("Invalid expr", K(expr), K(ret)); - } else if (expr->is_udf_expr()) { - ObUDFRawExpr *udf_expr = static_cast(expr); - ObDMLStmt *stmt = get_stmt(); - ObSchemaObjVersion udf_version; - share::schema::ObSchemaGetterGuard *schema_guard = NULL; - uint64_t database_id = OB_INVALID_ID; - CK (OB_NOT_NULL(stmt)); - CK (OB_NOT_NULL(udf_expr)); - if (OB_FAIL(ret)) { - } else if (OB_ISNULL(schema_guard = params_.schema_checker_->get_schema_guard())) { - ret = OB_ERR_UNEXPECTED; - LOG_WARN("table schema is null", K(ret), K(schema_guard)); - } else if (OB_FAIL(schema_guard->get_database_id(session_info_->get_effective_tenant_id(), - udf_expr->get_database_name().empty() ? session_info_->get_database_name() : udf_expr->get_database_name(), - database_id))) { - LOG_WARN("failed to get database id", K(ret)); - } else { - bool exist = false; - uint64_t object_db_id = OB_INVALID_ID; - ObSynonymChecker synonym_checker; - ObString object_name; - OZ (ObResolverUtils::resolve_synonym_object_recursively(*params_.schema_checker_, - synonym_checker, - session_info_->get_effective_tenant_id(), - database_id, - udf_expr->get_func_name(), - object_db_id, object_name, exist)); - if (OB_SUCC(ret) && exist) { - for (int64_t i = 0; OB_SUCC(ret) && i < synonym_checker.get_synonym_ids().count(); ++i) { - int64_t schema_version = OB_INVALID_VERSION; - uint64_t obj_id = synonym_checker.get_synonym_ids().at(i); - uint64_t dep_db_id = synonym_checker.get_database_ids().at(i); - ObSchemaObjVersion syn_version; - OZ (schema_guard->get_schema_version(SYNONYM_SCHEMA, - session_info_->get_effective_tenant_id(), - obj_id, - schema_version)); - OX (syn_version.object_id_ = obj_id); - OX (syn_version.version_ = schema_version); - OX (syn_version.object_type_ = DEPENDENCY_SYNONYM); - OZ (stmt->add_global_dependency_table(syn_version)); - OZ (stmt->add_ref_obj_version(obj_id, dep_db_id, ObObjectType::SYNONYM, syn_version, *allocator_)); - } - } - if (OB_SUCC(ret) && udf_expr->need_add_dependency()) { - uint64_t dep_obj_id = view_ref_id_; - uint64_t dep_db_id = database_id; - OZ (udf_expr->get_schema_object_version(udf_version)); - OZ (stmt->add_global_dependency_table(udf_version)); - OZ (stmt->add_ref_obj_version(dep_obj_id, dep_db_id, ObObjectType::VIEW, udf_version, *allocator_)); - //for udf without params, we just set called_in_sql = true, - //if this expr go through pl :: build_raw_expr later, - //the flag will change to false; - OX (expr->set_is_called_in_sql(true)); - } - } - - OZ (ObResolverUtils::set_parallel_info(*params_.session_info_, - *params_.schema_checker_->get_schema_guard(), - *expr, - stmt_->get_query_ctx()->udf_has_select_stmt_)); - OX (stmt_->get_query_ctx()->disable_udf_parallel_ |= !udf_expr->is_parallel_enable()); - if (OB_SUCC(ret) && - udf_expr->get_result_type().is_ext() && - (pl::PL_RECORD_TYPE == udf_expr->get_result_type().get_extend_type() || - pl::PL_NESTED_TABLE_TYPE == udf_expr->get_result_type().get_extend_type() || - pl::PL_VARRAY_TYPE == udf_expr->get_result_type().get_extend_type())) { - OX (stmt_->get_query_ctx()->disable_udf_parallel_ |= true); - } - } else if (T_FUN_PL_OBJECT_CONSTRUCT == expr->get_expr_type()) { - ObDMLStmt *stmt = get_stmt(); - ObObjectConstructRawExpr *object_expr = static_cast(expr); - CK (OB_NOT_NULL(object_expr)); - CK (OB_NOT_NULL(stmt)); - if (OB_SUCC(ret) && object_expr->need_add_dependency()) { - uint64_t dep_obj_id = view_ref_id_; - ObSchemaObjVersion coll_schema_version; - OZ (object_expr->get_schema_object_version(coll_schema_version)); - OZ (stmt->add_global_dependency_table(coll_schema_version)); - OZ (stmt->add_ref_obj_version(dep_obj_id, object_expr->get_database_id(), ObObjectType::VIEW, coll_schema_version, *allocator_)); - } - OX (stmt_->get_query_ctx()->disable_udf_parallel_ |= true); - } else if (T_FUN_PL_COLLECTION_CONSTRUCT == expr->get_expr_type()) { - ObDMLStmt *stmt = get_stmt(); - ObCollectionConstructRawExpr *coll_expr = static_cast(expr); - CK (OB_NOT_NULL(coll_expr)); - CK (OB_NOT_NULL(stmt)); - if (OB_SUCC(ret) && coll_expr->need_add_dependency()) { - uint64_t dep_obj_id = view_ref_id_; - ObSchemaObjVersion coll_schema_version; - OZ (coll_expr->get_schema_object_version(coll_schema_version)); - OZ (stmt->add_global_dependency_table(coll_schema_version)); - OZ (stmt->add_ref_obj_version(dep_obj_id, coll_expr->get_database_id(), ObObjectType::VIEW, coll_schema_version, *allocator_)); - } - OX (stmt_->get_query_ctx()->disable_udf_parallel_ |= true); } + OZ (collect_schema_version(expr)); } if (OB_ERR_SP_UNDECLARED_VAR == ret) { ret = OB_ERR_BAD_FIELD_ERROR; diff --git a/src/sql/resolver/dml/ob_dml_resolver.h b/src/sql/resolver/dml/ob_dml_resolver.h index 29865c1d5b..7e57a9b2b5 100644 --- a/src/sql/resolver/dml/ob_dml_resolver.h +++ b/src/sql/resolver/dml/ob_dml_resolver.h @@ -611,6 +611,7 @@ protected: int resolve_generated_column_expr_temp(TableItem *table_item); int find_generated_column_expr(ObRawExpr *&expr, bool &is_found); int deduce_generated_exprs(common::ObIArray &exprs); + int collect_schema_version(ObRawExpr *expr); int resolve_external_name(ObQualifiedName &q_name, ObIArray &columns, ObIArray &real_exprs, diff --git a/src/sql/resolver/expr/ob_expr_info_flag.h b/src/sql/resolver/expr/ob_expr_info_flag.h index 5ed43ffe11..47277a36e5 100644 --- a/src/sql/resolver/expr/ob_expr_info_flag.h +++ b/src/sql/resolver/expr/ob_expr_info_flag.h @@ -103,6 +103,7 @@ enum ObExprInfoFlag CNT_ORA_ROWSCN_EXPR, CNT_OP_PSEUDO_COLUMN, CNT_ASSIGN_EXPR, + CNT_OBJ_ACCESS_EXPR, CNT_ASSOCIATED_FLAG_END, //add CNT_xxx flag before me BE_USED, // expression has been applied diff --git a/src/sql/resolver/expr/ob_raw_expr_info_extractor.cpp b/src/sql/resolver/expr/ob_raw_expr_info_extractor.cpp index ab8e265fef..b771e66ce2 100644 --- a/src/sql/resolver/expr/ob_raw_expr_info_extractor.cpp +++ b/src/sql/resolver/expr/ob_raw_expr_info_extractor.cpp @@ -320,6 +320,11 @@ int ObRawExprInfoExtractor::visit(ObOpRawExpr &expr) if (OB_SUCC(ret) && OB_FAIL(visit_subquery_node(expr))) { LOG_WARN("visit subquery node failed", K(ret)); } + if (OB_SUCC(ret) && expr.get_expr_type() == T_OBJ_ACCESS_REF) { + if (OB_FAIL(expr.add_flag(CNT_OBJ_ACCESS_EXPR))) { + LOG_WARN("failed to add flag IS_OR", K(ret)); + } + } return ret; }