hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
c949c5e01f0fafaecdd9318d15807f09d94cd701
oceanbase/src/sql/optimizer/ob_log_plan.cpp
obdev c949c5e01f patch bug fix to open source branch
2021-07-19 22:45:15 +08:00

7518 lines
305 KiB
C++
Raw Blame History

/**
* Copyright (c) 2021 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 SQL_OPT
#include <stdint.h>
#include "lib/container/ob_array.h"
#include "lib/container/ob_array_iterator.h"
#include "lib/hash/ob_hashset.h"
#include "share/ob_server_locality_cache.h"
#include "sql/resolver/expr/ob_raw_expr_util.h"
#include "sql/ob_sql_utils.h"
#include "sql/ob_sql_trans_control.h"
#include "sql/optimizer/ob_log_plan.h"
#include "sql/optimizer/ob_log_table_scan.h"
#include "sql/optimizer/ob_log_mv_table_scan.h"
#include "sql/optimizer/ob_log_join.h"
#include "sql/optimizer/ob_intersect_route_policy.h"
#include "sql/optimizer/ob_join_order.h"
#include "sql/optimizer/ob_log_plan_factory.h"
#include "sql/optimizer/ob_log_sort.h"
#include "sql/optimizer/ob_log_group_by.h"
#include "sql/optimizer/ob_log_distinct.h"
#include "sql/optimizer/ob_log_limit.h"
#include "sql/optimizer/ob_log_sequence.h"
#include "sql/optimizer/ob_log_set.h"
#include "sql/optimizer/ob_log_subplan_scan.h"
#include "sql/optimizer/ob_log_subplan_filter.h"
#include "sql/optimizer/ob_log_material.h"
#include "sql/optimizer/ob_log_select_into.h"
#include "sql/optimizer/ob_log_count.h"
#include "sql/optimizer/ob_log_table_lookup.h"
#include "sql/optimizer/ob_opt_est_cost.h"
#include "sql/optimizer/ob_optimizer.h"
#include "sql/optimizer/ob_log_del_upd.h"
#include "sql/optimizer/ob_log_expr_values.h"
#include "sql/optimizer/ob_log_function_table.h"
#include "sql/optimizer/ob_raw_expr_connectby_level_visitor.h"
#include "sql/rewrite/ob_transform_utils.h"
#include "storage/ob_partition_service.h"
#include "sql/optimizer/ob_log_exchange.h"
#include "sql/optimizer/ob_log_values.h"
#include "sql/optimizer/ob_log_temp_table_insert.h"
#include "sql/optimizer/ob_log_temp_table_access.h"
#include "sql/optimizer/ob_log_temp_table_transformation.h"
#include "sql/optimizer/ob_px_resource_analyzer.h"
#include "common/ob_smart_call.h"
using namespace oceanbase;
using namespace sql;
using namespace oceanbase::common;
using namespace oceanbase::share;
using namespace oceanbase::transaction;
using namespace oceanbase::storage;
using namespace oceanbase::sql::log_op_def;
using share::schema::ObColumnSchemaV2;
using share::schema::ObSchemaGetterGuard;
using share::schema::ObTableSchema;
#include "sql/optimizer/ob_join_property.map"
static const char* ExplainColumnName[] = {"ID", "OPERATOR", "NAME", "EST. ROWS", "COST"};
ObLogPlan::ObLogPlan(ObOptimizerContext& ctx, const ObDMLStmt* stmt)
: optimizer_context_(ctx),
allocator_(ctx.get_allocator()),
stmt_(stmt),
log_op_factory_(allocator_),
candidates_(),
phy_plan_type_(OB_PHY_PLAN_UNINITIALIZED),
location_type_(OB_PHY_PLAN_UNINITIALIZED),
group_replaced_exprs_(),
query_ref_(NULL),
root_(NULL),
sql_text_(),
hash_value_(0),
subplan_infos_(),
onetime_exprs_(),
acs_index_infos_(),
autoinc_params_(),
join_order_(NULL),
predicate_selectivities_(),
affected_last_insert_id_(false),
expected_worker_count_(0),
multi_stmt_rowkey_pos_(),
equal_sets_(),
all_exprs_(allocator_),
max_op_id_(OB_INVALID_ID),
require_local_execution_(false),
est_sel_info_(ctx, const_cast<ObDMLStmt*>(stmt)),
is_subplan_scan_(false),
const_exprs_()
{}
ObLogPlan::~ObLogPlan()
{
if (NULL != join_order_) {
join_order_->~ObJoinOrder();
join_order_ = NULL;
}
for (int64_t i = 0; i < subplan_infos_.count(); ++i) {
if (NULL != subplan_infos_.at(i)) {
subplan_infos_.at(i)->~SubPlanInfo();
subplan_infos_.at(i) = NULL;
} else { /* Do nothing */
}
}
}
double ObLogPlan::get_optimization_cost()
{
double opt_cost = 0.0;
if (OB_NOT_NULL(root_)) {
opt_cost = root_->get_cost();
}
return opt_cost;
}
int ObLogPlan::get_current_best_plan(ObLogicalOperator*& best_plan)
{
int ret = OB_SUCCESS;
best_plan = NULL;
if (OB_FAIL(candidates_.get_best_plan(best_plan))) {
LOG_WARN("failed to get best plan", K(ret));
} else if (OB_ISNULL(best_plan)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else {
LOG_TRACE("succeed to get best plan", K(best_plan->get_card()), K(best_plan->get_cost()), K(best_plan->get_type()));
}
return ret;
}
int ObLogPlan::set_final_plan_root(ObLogicalOperator* best_plan)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(best_plan)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(best_plan), K(ret));
} else {
set_plan_root(best_plan);
best_plan->mark_is_plan_root();
}
return ret;
}
int planText::init()
{
int ret = OB_SUCCESS;
#undef KEY_DEF
#define KEY_DEF(identifier, name) name
static const char* names[] = {KEYS_DEF};
#undef KEY_DEF
for (int i = 0; i < Max_Plan_Column; i++) {
formatter.column_width[i] = (int)strlen(names[i]);
formatter.column_name[i] = names[i];
}
// formatter.num_of_columns = (EXPLAIN_SIMPLE == format) ? SIMPLE_COLUMN_NUM : Max_Plan_Column;
if (EXPLAIN_BASIC == format) {
formatter.num_of_columns = SIMPLE_COLUMN_NUM;
} else if (EXPLAIN_PLANREGRESS == format) {
formatter.num_of_columns = SIMPLE_COLUMN_NUM;
} else {
formatter.num_of_columns = Max_Plan_Column;
}
is_inited_ = true;
return ret;
}
int ObLogPlan::plan_tree_copy(ObLogicalOperator* src, ObLogicalOperator*& dst)
{
int ret = OB_SUCCESS;
bool is_stack_overflow = false;
if (OB_ISNULL(src)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), K(src));
} else if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
LOG_WARN("check stack overflow failed", K(ret));
} else if (is_stack_overflow) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("too deep recursive", K(ret));
} else {
ObLogicalOperator* tmp = NULL;
if (OB_FAIL(src->copy_without_child(tmp))) {
LOG_WARN("failed to copy_without_child", K(src->get_type()), K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < src->get_num_of_child(); i++) {
ObLogicalOperator* sub_tree = NULL;
if (OB_FAIL(SMART_CALL(plan_tree_copy(src->get_child(i), sub_tree)))) {
LOG_WARN("failed to copy plan tree", K(ret));
} else if (OB_ISNULL(tmp) || OB_ISNULL(sub_tree)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), K(tmp), K(sub_tree));
} else {
tmp->set_child(i, sub_tree);
}
}
}
if (OB_SUCC(ret)) {
dst = tmp;
} else { /* Do nothing */
}
}
return ret;
}
#define NEW_LINE "\n"
#define SEPARATOR "|"
#define SPACE " "
#define PLAN_WRAPPER "="
#define LINE_SEPARATOR "-"
int64_t ObLogPlan::to_string(char* buf, const int64_t buf_len, ExplainType type) const
{
int ret = OB_SUCCESS;
planText plan(buf, buf_len, type);
plan.is_oneline_ = false;
int64_t& pos = plan.pos;
if (OB_FAIL(plan.init())) {
databuff_printf(buf, buf_len, pos, "WARN failed to plan.init(), ret=%d", ret);
} else if (OB_FAIL(const_cast<ObLogPlan*>(this)->plan_tree_traverse(EXPLAIN_COLLECT_WIDTH, &plan))) {
databuff_printf(buf, buf_len, pos, "WARN failed to traverse plan for collecting width, ret=%d", ret);
} else {
int64_t total_width = 0;
for (int i = 0; OB_SUCC(ret) && i < plan.formatter.num_of_columns; i++) {
total_width += plan.formatter.column_width[i];
}
// adding a separator between each column
total_width += plan.formatter.num_of_columns + 1;
// print plan text header line
for (int i = 0; OB_SUCC(ret) && i < total_width; i++) {
ret = BUF_PRINTF(PLAN_WRAPPER);
}
if (OB_FAIL(ret)) {
databuff_printf(buf, buf_len, pos, "WARN failed to previous step, ret=%d", ret);
} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */
} else { // print column names
ret = BUF_PRINTF(SEPARATOR);
}
for (int i = 0; OB_SUCC(ret) && i < plan.formatter.num_of_columns; i++) {
if (OB_FAIL(BUF_PRINTF("%-*s", plan.formatter.column_width[i], ExplainColumnName[i]))) { /* Do nothing */
} else {
ret = BUF_PRINTF(SEPARATOR);
}
}
if (OB_SUCC(ret)) {
ret = BUF_PRINTF(NEW_LINE);
} else { /* Do nothing */
}
// print line separator
for (int i = 0; OB_SUCC(ret) && i < total_width; i++) {
ret = BUF_PRINTF(LINE_SEPARATOR);
}
if (OB_SUCC(ret)) {
ret = BUF_PRINTF(NEW_LINE);
} else { /* Do nothing */
}
plan.level = 0;
if (OB_FAIL(ret)) {
databuff_printf(buf, buf_len, pos, "WARN failed to previous step, ret=%d", ret);
} else if (OB_FAIL(const_cast<ObLogPlan*>(this)->plan_tree_traverse(EXPLAIN_WRITE_BUFFER, &plan))) {
databuff_printf(buf, buf_len, pos, "WARN failed to traverse plan for writing buffer, ret=%d", ret);
} else {
// print plan text footer line
for (int i = 0; OB_SUCC(ret) && i < total_width; i++) {
ret = BUF_PRINTF(PLAN_WRAPPER);
}
if (OB_SUCC(ret)) {
ret = BUF_PRINTF(NEW_LINE);
} else { /* Do nothing */
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF("Outputs & filters: "))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF("-------------------------------------"))) { /* Do nothing */
} else if (FALSE_IT(plan.level = 0)) { /* Do nothing */
} else if (OB_FAIL(const_cast<ObLogPlan*>(this)->plan_tree_traverse(EXPLAIN_WRITE_BUFFER_OUTPUT, &plan))) {
databuff_printf(buf, buf_len, pos, "WARN failed to print output exprs, ret=%d", ret);
} else {
ret = BUF_PRINTF(NEW_LINE);
}
} else { /* Do nothing */
}
// print Used Hint
if (OB_SUCC(ret) && (EXPLAIN_EXTENDED == type)) {
plan.outline_type_ = USED_HINT;
if (OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF("Used Hint:"))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF("-------------------------------------\n"))) { /* Do nothing */
} else if (OB_FAIL(print_outline(plan))) {
databuff_printf(buf, buf_len, pos, "WARN failed to print outlien, ret=%d", ret);
} else {
ret = BUF_PRINTF(NEW_LINE);
}
} else { /* Do nothing */
}
// print Outline Data
if (OB_SUCC(ret) && (EXPLAIN_EXTENDED == type || EXPLAIN_OUTLINE == type)) {
plan.outline_type_ = OUTLINE_DATA;
if (OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF("Outline Data:"))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF("-------------------------------------\n"))) { /* Do nothing */
} else if (OB_FAIL(print_outline(plan))) {
databuff_printf(buf, buf_len, pos, "WARN failed to print outlien, ret=%d", ret);
} else {
ret = BUF_PRINTF(NEW_LINE);
}
} else { /* Do nothing */
}
// print log plan type
if (OB_SUCC(ret) && EXPLAIN_EXTENDED == type) {
if (OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF("Plan Type:"))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF("-------------------------------------\n"))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF(ob_plan_type_str(get_phy_plan_type())))) { /* Do nothing */
} else {
ret = BUF_PRINTF(NEW_LINE);
}
} else { /* Do nothing */
}
// print optimization info
if (OB_SUCC(ret) && EXPLAIN_EXTENDED == type) {
if (OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF("Optimization Info:"))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */
} else if (OB_FAIL(BUF_PRINTF("-------------------------------------\n"))) { /* Do nothing */
} else if (OB_FAIL(const_cast<ObLogPlan*>(this)->plan_tree_traverse(EXPLAIN_INDEX_SELECTION_INFO, &plan))) {
databuff_printf(buf, buf_len, pos, "WARN failed to print index selection info, ret=%d", ret);
}
} else { /* Do nothing */
}
// print params
if (OB_SUCC(ret) && EXPLAIN_EXTENDED == type) {
if (OB_FAIL(BUF_PRINTF("Parameters"))) {
} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) {
} else {
ret = BUF_PRINTF("-------------------------------------\n");
}
const ParamStore* params = NULL;
if (OB_ISNULL(params = get_optimizer_context().get_params())) {
ret = OB_ERR_UNEXPECTED;
databuff_printf(buf, buf_len, pos, "WARN Get unexpected null, ret=%d", ret);
} else { /* Do nothing */
}
for (int64_t i = 0; OB_SUCC(ret) && NULL != params && i < params->count(); i++) {
pos += params->at(i).to_string(buf + pos, buf_len - pos);
if (i < params->count() - 1) {
ret = BUF_PRINTF(", ");
} else { /* Do nothing */
}
}
} else { /* Do nothing */
}
}
if (OB_FAIL(ret)) {
databuff_printf(buf, buf_len, pos, "WARN Get unexpected error in to_string, ret=%d", ret);
} else { /* Do nothing */
}
return pos;
}
int ObLogPlan::get_table_items(const ObIArray<FromItem>& from_items, ObIArray<TableItem*>& table_items)
{
int ret = OB_SUCCESS;
ObDMLStmt* stmt = NULL;
if (OB_ISNULL(stmt = get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("null stmt", K(stmt), K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < from_items.count(); i++) {
const FromItem& from_item = from_items.at(i);
TableItem* temp_table_item = NULL;
if (!from_item.is_joined_) {
temp_table_item = stmt->get_table_item_by_id(from_item.table_id_);
} else {
temp_table_item = stmt->get_joined_table(from_item.table_id_);
}
if (OB_FAIL(table_items.push_back(temp_table_item))) {
LOG_WARN("failed to push back table item", K(ret));
} else { /*do nothing*/
}
}
}
return ret;
}
int ObLogPlan::get_table_ids(TableItem* table_item, ObRelIds& table_ids)
{
int ret = OB_SUCCESS;
ObDMLStmt* stmt = get_stmt();
if (OB_ISNULL(table_item) || OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null table item or stmt", K(ret));
} else if (!table_item->is_joined_table()) {
if (OB_FAIL(table_ids.add_member(stmt->get_table_bit_index(table_item->table_id_)))) {
LOG_WARN("failed to add members", K(ret));
}
} else {
JoinedTable* joined_table = static_cast<JoinedTable*>(table_item);
if (OB_FAIL(ObTransformUtils::get_rel_ids_from_join_table(stmt, joined_table, table_ids))) {
LOG_WARN("failed to get rel ids from joined table", K(ret));
}
}
return ret;
}
int ObLogPlan::get_table_ids(const ObIArray<uint64_t>& table_ids, ObRelIds& rel_ids)
{
int ret = OB_SUCCESS;
ObDMLStmt* stmt = NULL;
int32_t idx = OB_INVALID_INDEX;
if (OB_ISNULL(stmt = get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null stmt", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < table_ids.count(); ++i) {
idx = stmt->get_table_bit_index(table_ids.at(i));
if (OB_UNLIKELY(OB_INVALID_INDEX == idx)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null table item or stmt", K(ret));
} else if (OB_FAIL(rel_ids.add_member(idx))) {
LOG_WARN("failed to add members", K(ret));
}
}
return ret;
}
int ObLogPlan::get_table_ids(const ObIArray<TableItem*>& table_items, ObRelIds& table_ids)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < table_items.count(); ++i) {
TableItem* item = table_items.at(i);
if (OB_ISNULL(item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null table item", K(ret));
} else if (OB_FAIL(get_table_ids(item, table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
}
}
return ret;
}
int ObLogPlan::get_table_ids(const ObIArray<ObRawExpr*>& exprs, ObRelIds& table_ids)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < exprs.count(); ++i) {
ObRawExpr* expr = exprs.at(i);
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null expr", K(ret));
} else if (OB_FAIL(table_ids.add_members(expr->get_relation_ids()))) {
LOG_WARN("failed to add members", K(ret));
}
}
return ret;
}
int ObLogPlan::is_joined_table_filter(const ObIArray<TableItem*>& table_items, const ObRawExpr* expr, bool& is_filter)
{
int ret = OB_SUCCESS;
is_filter = false;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null expr or stmt", K(ret));
} else if (expr->get_relation_ids().is_empty()) {
// do nothing
} else {
for (int64_t i = 0; OB_SUCC(ret) && !is_filter && i < table_items.count(); ++i) {
TableItem* item = table_items.at(i);
ObRelIds joined_table_ids;
if (OB_ISNULL(item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null semi item", K(ret));
} else if (!item->is_joined_table()) {
// do nothing
} else if (OB_FAIL(get_table_ids(item, joined_table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (joined_table_ids.is_superset(expr->get_relation_ids())) {
is_filter = true;
}
}
}
return ret;
}
int ObLogPlan::find_inner_conflict_detector(
const ObIArray<ConflictDetector*>& inner_conflict_detectors, const ObRelIds& rel_ids, ConflictDetector*& detector)
{
int ret = OB_SUCCESS;
detector = NULL;
int64_t N = inner_conflict_detectors.count();
for (int64_t i = 0; OB_SUCC(ret) && NULL == detector && i < N; ++i) {
ConflictDetector* temp_detector = inner_conflict_detectors.at(i);
if (OB_ISNULL(temp_detector)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null detector", K(ret));
} else if (temp_detector->join_info_.join_type_ != INNER_JOIN) {
// do nothing
} else if (temp_detector->join_info_.table_set_.equal(rel_ids)) {
detector = temp_detector;
}
}
return ret;
}
int ObLogPlan::satisfy_associativity_rule(const ConflictDetector& left, const ConflictDetector& right, bool& is_satisfy)
{
int ret = OB_SUCCESS;
if (!ASSOC_PROPERTY[left.join_info_.join_type_][right.join_info_.join_type_]) {
is_satisfy = false;
} else if ((LEFT_OUTER_JOIN == left.join_info_.join_type_ || FULL_OUTER_JOIN == left.join_info_.join_type_) &&
LEFT_OUTER_JOIN == right.join_info_.join_type_) {
if (OB_FAIL(ObTransformUtils::is_null_reject_conditions(right.join_info_.on_condition_,
left.R_DS_.is_subset(right.L_DS_) ? left.R_DS_ : right.L_DS_,
is_satisfy))) {
LOG_WARN("failed to check is null reject conditions", K(ret));
}
} else if (FULL_OUTER_JOIN == left.join_info_.join_type_ && FULL_OUTER_JOIN == right.join_info_.join_type_) {
if (OB_FAIL(ObTransformUtils::is_null_reject_conditions(
left.join_info_.on_condition_, left.R_DS_.is_subset(right.L_DS_) ? left.R_DS_ : right.L_DS_, is_satisfy))) {
LOG_WARN("failed to check is null reject conditions", K(ret));
} else if (!is_satisfy) {
// do nothing
} else if (OB_FAIL(ObTransformUtils::is_null_reject_conditions(right.join_info_.on_condition_,
left.R_DS_.is_subset(right.L_DS_) ? left.R_DS_ : right.L_DS_,
is_satisfy))) {
LOG_WARN("failed to check is null reject conditions", K(ret));
}
} else {
is_satisfy = true;
}
return ret;
}
int ObLogPlan::satisfy_left_asscom_rule(const ConflictDetector& left, const ConflictDetector& right, bool& is_satisfy)
{
int ret = OB_SUCCESS;
if (!L_ASSCOM_PROPERTY[left.join_info_.join_type_][right.join_info_.join_type_]) {
is_satisfy = false;
} else if (LEFT_OUTER_JOIN == left.join_info_.join_type_ && FULL_OUTER_JOIN == right.join_info_.join_type_) {
if (OB_FAIL(ObTransformUtils::is_null_reject_conditions(left.join_info_.on_condition_, left.L_DS_, is_satisfy))) {
LOG_WARN("failed to check is null reject conditions", K(ret));
}
} else if (FULL_OUTER_JOIN == left.join_info_.join_type_ && LEFT_OUTER_JOIN == right.join_info_.join_type_) {
if (OB_FAIL(ObTransformUtils::is_null_reject_conditions(right.join_info_.on_condition_, left.L_DS_, is_satisfy))) {
LOG_WARN("failed to check is null reject conditions", K(ret));
}
} else if (FULL_OUTER_JOIN == left.join_info_.join_type_ && FULL_OUTER_JOIN == right.join_info_.join_type_) {
if (OB_FAIL(ObTransformUtils::is_null_reject_conditions(left.join_info_.on_condition_, left.L_DS_, is_satisfy))) {
LOG_WARN("failed to check is null reject conditions", K(ret));
} else if (!is_satisfy) {
// do nothing
} else if (OB_FAIL(ObTransformUtils::is_null_reject_conditions(
right.join_info_.on_condition_, left.L_DS_, is_satisfy))) {
LOG_WARN("failed to check is null reject conditions", K(ret));
}
} else {
is_satisfy = true;
}
LOG_TRACE("succeed to check l-asscom", K(left), K(right), K(is_satisfy));
return ret;
}
int ObLogPlan::satisfy_right_asscom_rule(const ConflictDetector& left, const ConflictDetector& right, bool& is_satisfy)
{
int ret = OB_SUCCESS;
if (!R_ASSCOM_PROPERTY[left.join_info_.join_type_][right.join_info_.join_type_]) {
is_satisfy = false;
} else if (FULL_OUTER_JOIN == left.join_info_.join_type_ && FULL_OUTER_JOIN == right.join_info_.join_type_) {
if (OB_FAIL(ObTransformUtils::is_null_reject_conditions(left.join_info_.on_condition_, right.R_DS_, is_satisfy))) {
LOG_WARN("failed to check is null reject conditions", K(ret));
} else if (!is_satisfy) {
// do nothing
} else if (OB_FAIL(ObTransformUtils::is_null_reject_conditions(
right.join_info_.on_condition_, right.R_DS_, is_satisfy))) {
LOG_WARN("failed to check is null reject conditions", K(ret));
}
} else {
is_satisfy = true;
}
LOG_TRACE("succeed to check r-asscom", K(left), K(right), K(is_satisfy));
return ret;
}
int ObLogPlan::add_conflict_rule(
const ObRelIds& left, const ObRelIds& right, ObIArray<std::pair<ObRelIds, ObRelIds>>& rules)
{
int ret = OB_SUCCESS;
ObRelIds* left_handle_rule = NULL;
ObRelIds* right_handle_rule = NULL;
bool find = false;
for (int64_t i = 0; !find && i < rules.count(); ++i) {
if (rules.at(i).first.equal(left) && rules.at(i).second.equal(right)) {
find = true;
} else if (rules.at(i).first.equal(left)) {
left_handle_rule = &rules.at(i).second;
} else if (rules.at(i).second.equal(right)) {
right_handle_rule = &rules.at(i).first;
}
}
if (find) {
// do nothing
} else if (NULL != left_handle_rule) {
if (OB_FAIL(left_handle_rule->add_members(right))) {
LOG_WARN("failed to add members", K(ret));
}
} else if (NULL != right_handle_rule) {
if (OB_FAIL(right_handle_rule->add_members(left))) {
LOG_WARN("failed to add members", K(ret));
}
} else {
std::pair<ObRelIds, ObRelIds> rule;
if (OB_FAIL(rule.first.add_members(left))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(rule.second.add_members(right))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(rules.push_back(rule))) {
LOG_WARN("failed to push back rule", K(ret));
}
}
return ret;
}
int ObLogPlan::generate_conflict_rule(ConflictDetector* parent, ConflictDetector* child, bool is_left_child,
ObIArray<std::pair<ObRelIds, ObRelIds>>& rules)
{
int ret = OB_SUCCESS;
bool is_satisfy = false;
ObRelIds ids;
if (OB_ISNULL(parent) || OB_ISNULL(child)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null detector", K(ret));
} else if (is_left_child) {
LOG_TRACE("generate left child conflict rule for ", K(*parent), K(*child));
// check assoc(o^a, o^b)
if (OB_FAIL(satisfy_associativity_rule(*child, *parent, is_satisfy))) {
LOG_WARN("failed to check satisfy assoc", K(ret));
} else if (is_satisfy) {
LOG_TRACE("satisfy assoc");
} else if (OB_FAIL(ids.intersect(child->L_DS_, child->join_info_.table_set_))) {
LOG_WARN("failed to cal intersect table ids", K(ret));
} else if (ids.is_empty()) {
// CR += T(right(o^a)) -> T(left(o^a))
if (OB_FAIL(add_conflict_rule(child->R_DS_, child->L_DS_, rules))) {
LOG_WARN("failed to add conflict rule", K(ret));
} else if (OB_FAIL(add_conflict_rule(child->R_DS_, child->R_DS_, rules))) {
LOG_WARN("failed to add conflict rule", K(ret));
} else {
LOG_TRACE("succeed to add condlict1", K(rules));
}
} else {
// CR += T(right(o^a)) -> T(left(o^a)) n T(quals)
if (OB_FAIL(add_conflict_rule(child->R_DS_, ids, rules))) {
LOG_WARN("failed to add conflict rule", K(ret));
} else if (OB_FAIL(add_conflict_rule(child->R_DS_, child->R_DS_, rules))) {
LOG_WARN("failed to add conflict rule", K(ret));
} else {
LOG_TRACE("succeed to add condlict2", K(rules));
}
}
// check l-asscom(o^a, o^b)
if (OB_FAIL(ret)) {
} else if (OB_FAIL(satisfy_left_asscom_rule(*child, *parent, is_satisfy))) {
LOG_WARN("failed to check satisfy assoc", K(ret));
} else if (is_satisfy) {
LOG_TRACE("satisfy l-asscom");
} else if (OB_FAIL(ids.intersect(child->R_DS_, child->join_info_.table_set_))) {
LOG_WARN("failed to cal intersect table ids", K(ret));
} else if (ids.is_empty()) {
// CR += T(left(o^a)) -> T(right(o^a))
if (OB_FAIL(add_conflict_rule(child->L_DS_, child->R_DS_, rules))) {
LOG_WARN("failed to add conflict rule", K(ret));
} else {
LOG_TRACE("succeed to add condlict3", K(rules));
}
} else {
// CR += T(left(o^a)) -> T(right(o^a)) n T(quals)
if (OB_FAIL(add_conflict_rule(child->L_DS_, ids, rules))) {
LOG_WARN("failed to add conflict rule", K(ret));
} else {
LOG_TRACE("succeed to add condlict4", K(rules));
}
}
} else {
LOG_TRACE("generate right child conflict rule for ", K(*parent), K(*child));
// check assoc(o^b, o^a)
if (OB_FAIL(satisfy_associativity_rule(*parent, *child, is_satisfy))) {
LOG_WARN("failed to check satisfy assoc", K(ret));
} else if (is_satisfy) {
LOG_TRACE("satisfy assoc");
} else if (OB_FAIL(ids.intersect(child->R_DS_, child->join_info_.table_set_))) {
LOG_WARN("failed to cal intersect table ids", K(ret));
} else if (ids.is_empty()) {
// CR += T(left(o^a)) -> T(right(o^a))
if (OB_FAIL(add_conflict_rule(child->L_DS_, child->R_DS_, rules))) {
LOG_WARN("failed to add conflict rule", K(ret));
} else {
LOG_TRACE("succeed to add condlict5", K(rules));
}
} else {
// CR += T(left(o^a)) -> T(right(o^a)) n T(quals)
if (OB_FAIL(add_conflict_rule(child->L_DS_, ids, rules))) {
LOG_WARN("failed to add conflict rule", K(ret));
} else {
LOG_TRACE("succeed to add condlict6", K(rules));
}
}
// check r-asscom(o^b, o^a)
if (OB_FAIL(ret)) {
} else if (OB_FAIL(satisfy_right_asscom_rule(*parent, *child, is_satisfy))) {
LOG_WARN("failed to check satisfy assoc", K(ret));
} else if (is_satisfy) {
LOG_TRACE("satisfy r-asscom");
} else if (OB_FAIL(ids.intersect(child->L_DS_, child->join_info_.table_set_))) {
LOG_WARN("failed to cal intersect table ids", K(ret));
} else if (ids.is_empty()) {
// CR += T(right(o^a)) -> T(left(o^a))
if (OB_FAIL(add_conflict_rule(child->R_DS_, child->L_DS_, rules))) {
LOG_WARN("failed to add conflict rule", K(ret));
} else {
LOG_TRACE("succeed to add condlict7", K(rules));
}
} else {
// CR += T(right(o^a)) -> T(left(o^a)) n T(quals)
if (OB_FAIL(add_conflict_rule(child->R_DS_, ids, rules))) {
LOG_WARN("failed to add conflict rule", K(ret));
} else {
LOG_TRACE("succeed to add condlict8", K(rules));
}
}
}
return ret;
}
int ObLogPlan::get_base_table_items(ObDMLStmt& stmt, const ObIArray<TableItem*>& table_items,
const ObIArray<SemiInfo*>& semi_infos, ObIArray<TableItem*>& base_tables)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < table_items.count(); ++i) {
TableItem* item = table_items.at(i);
if (OB_ISNULL(item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null table item", K(ret));
} else if (!item->is_joined_table()) {
ret = base_tables.push_back(item);
} else {
JoinedTable* joined_table = static_cast<JoinedTable*>(item);
for (int64_t j = 0; OB_SUCC(ret) && j < joined_table->single_table_ids_.count(); ++j) {
TableItem* table = stmt.get_table_item_by_id(joined_table->single_table_ids_.at(j));
ret = base_tables.push_back(table);
}
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < semi_infos.count(); ++i) {
if (OB_ISNULL(semi_infos.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null semi info", K(ret));
} else {
TableItem* table = stmt.get_table_item_by_id(semi_infos.at(i)->right_table_id_);
ret = base_tables.push_back(table);
}
}
return ret;
}
int ObLogPlan::generate_join_orders()
{
int ret = OB_SUCCESS;
ObDMLStmt* stmt = NULL;
ObSEArray<ObRawExpr*, 8> quals;
ObSEArray<SemiInfo*, 4> semi_infos;
ObSEArray<TableItem*, 4> table_items;
JoinOrderArray base_level;
int64_t join_level = 0;
common::ObArray<JoinOrderArray> join_rels;
ObSEArray<TableItem*, 8> base_tables;
if (OB_ISNULL(stmt = get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected NULL", K(stmt), K(ret));
} else if (OB_FAIL(semi_infos.assign(stmt->get_semi_infos()))) {
LOG_WARN("failed to assign semi infos", K(ret));
} else if (OB_FAIL(get_table_items(stmt->get_from_items(), table_items))) {
LOG_WARN("failed to get table items", K(ret));
} else if (stmt->is_insert_stmt()) {
/*do nothing*/
} else if (OB_FAIL(append(quals, get_stmt()->get_condition_exprs()))) {
LOG_WARN("failed to append exprs", K(ret));
} else if (OB_FAIL(append(quals, get_pushdown_filters()))) {
LOG_WARN("failed to append exprs", K(ret));
}
if (OB_SUCC(ret)) {
if (OB_FAIL(get_base_table_items(*stmt, table_items, semi_infos, base_tables))) {
LOG_WARN("failed to flatten table items", K(ret));
} else if (OB_FAIL(generate_base_level_join_order(base_tables, base_level))) {
LOG_WARN("fail to generate base level join order", K(ret));
} else if (OB_FAIL(pre_process_quals(table_items, semi_infos, quals))) {
LOG_WARN("failed to distribute special quals", K(ret));
} else if (OB_FAIL(generate_conflict_detectors(table_items, semi_infos, quals, base_level))) {
LOG_WARN("failed to generate conflict detectors", K(ret));
} else {
join_level = base_level.count();
if (OB_UNLIKELY(join_level < 1)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected join level", K(ret), K(join_level));
} else if (OB_FAIL(join_rels.prepare_allocate(join_level))) {
LOG_WARN("failed to prepare allocate join rels", K(ret));
} else if (OB_FAIL(join_rels.at(0).assign(base_level))) {
LOG_WARN("failed to assign base level join order", K(ret));
}
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < join_level; ++i) {
if (OB_ISNULL(join_rels.at(0).at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("join_rels_.at(0).at(i) is null", K(ret), K(i));
} else if (OB_FAIL(join_rels.at(0).at(i)->generate_base_paths())) {
LOG_WARN("failed to generate base path", K(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(init_leading_info(table_items, semi_infos))) {
LOG_WARN("failed to get leading hint info", K(ret));
} else if (OB_FAIL(init_bushy_tree_info(table_items))) {
LOG_WARN("failed to init bushy tree infos", K(ret));
} else if (join_rels.at(0).count() <= DEFAULT_SEARCH_SPACE_RELS || !leading_tables_.is_empty()) {
if (OB_FAIL(generate_join_levels_with_DP(join_rels, join_level))) {
LOG_WARN("failed to generate join levels with dynamic program", K(ret));
}
} else {
if (OB_FAIL(generate_join_levels_with_linear(join_rels, table_items, join_level))) {
LOG_WARN("failed to generate join levels with linear", K(ret));
}
}
}
if (OB_SUCC(ret)) {
if (1 != join_rels.at(join_level - 1).count()) {
ret = OB_ERR_NO_JOIN_ORDER_GENERATED;
LOG_WARN("No final JoinOrder generated", K(ret), K(join_rels.at(join_level - 1).count()));
} else if (OB_ISNULL(join_order_ = join_rels.at(join_level - 1).at(0))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("null join order", K(ret), K(join_order_));
} else if (OB_UNLIKELY(join_order_->get_interesting_paths().empty())) {
ret = OB_ERR_NO_PATH_GENERATED;
LOG_WARN("No final join path generated", K(ret), K(*join_order_));
} else {
LOG_TRACE("succeed to generate join order", K(ret));
}
}
return ret;
}
int ObLogPlan::generate_base_level_join_order(
const ObIArray<TableItem*>& table_items, ObIArray<ObJoinOrder*>& base_level)
{
int ret = OB_SUCCESS;
ObJoinOrder* this_jo = NULL;
int64_t N = table_items.count();
for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
if (OB_ISNULL(table_items.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("null table item", K(ret), K(i));
} else if (OB_ISNULL(this_jo = create_join_order(ACCESS))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("failed to allocate an ObJoinOrder", K(ret));
} else if (OB_FAIL(this_jo->init_base_join_order(table_items.at(i)))) {
LOG_WARN("fail to generate the base rel", K(ret), K(*table_items.at(i)));
this_jo->~ObJoinOrder();
this_jo = NULL;
} else if (OB_FAIL(base_level.push_back(this_jo))) {
LOG_WARN("fail to push back an ObJoinOrder", K(ret));
} else { /*do nothing*/
}
}
return ret;
}
int ObLogPlan::split_or_quals(const ObIArray<TableItem*>& table_items, ObIArray<ObRawExpr*>& quals)
{
int ret = OB_SUCCESS;
ObSEArray<ObRawExpr*, 8> new_quals;
for (int64_t i = 0; OB_SUCC(ret) && i < quals.count(); ++i) {
if (OB_FAIL(split_or_quals(table_items, quals.at(i), new_quals))) {
LOG_WARN("failed to split or quals", K(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(append(quals, new_quals))) {
LOG_WARN("failed to append quals", K(ret));
}
}
return ret;
}
int ObLogPlan::split_or_quals(const ObIArray<TableItem*>& table_items, ObRawExpr* qual, ObIArray<ObRawExpr*>& new_quals)
{
int ret = OB_SUCCESS;
ObRelIds table_ids;
bool is_filter = false;
if (OB_ISNULL(qual)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null qual", K(ret));
} else if (T_OP_OR != qual->get_expr_type()) {
// do nothing
} else if (!qual->has_flag(CNT_SUB_QUERY) && OB_FAIL(is_joined_table_filter(table_items, qual, is_filter))) {
LOG_WARN("failed to check is joined table filter", K(ret));
} else if (is_filter) {
} else {
ObOpRawExpr* or_qual = static_cast<ObOpRawExpr*>(qual);
for (int64_t j = 0; OB_SUCC(ret) && j < table_items.count(); ++j) {
TableItem* table_item = table_items.at(j);
table_ids.reuse();
if (OB_ISNULL(table_item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table item is null", K(ret));
} else if (OB_FAIL(get_table_ids(table_item, table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (!table_ids.overlap(or_qual->get_relation_ids())) {
// do nothing
} else if (qual->has_flag(CNT_SUB_QUERY) || (!table_ids.is_superset(or_qual->get_relation_ids()))) {
ret = try_split_or_qual(table_ids, *or_qual, new_quals);
}
}
}
return ret;
}
int ObLogPlan::pre_process_quals(
const ObIArray<TableItem*>& table_items, const ObIArray<SemiInfo*>& semi_infos, ObIArray<ObRawExpr*>& quals)
{
int ret = OB_SUCCESS;
ObSEArray<ObRawExpr*, 8> normal_quals;
ObDMLStmt* stmt = get_stmt();
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), K(stmt));
}
// 1. where conditions
for (int64_t i = 0; OB_SUCC(ret) && i < quals.count(); ++i) {
ObRawExpr* qual = quals.at(i);
bool can_distribute = false;
if (OB_ISNULL(qual)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null qual", K(ret));
} else if (qual->has_flag(CNT_ROWNUM)) {
ret = add_rownum_expr(qual);
} else if (qual->has_flag(CNT_RAND_FUNC)) {
ret = add_random_expr(qual);
} else if (qual->has_flag(CNT_USER_VARIABLE)) {
ret = add_user_var_filter(qual);
} else if (qual->has_flag(CNT_SUB_QUERY)) {
if (OB_FAIL(distribute_onetime_subquery(qual, can_distribute))) {
LOG_WARN("failed to check qual can pushdown", K(ret));
} else if (!can_distribute) {
if (OB_FAIL(split_or_quals(table_items, qual, quals))) {
LOG_WARN("failed to split or quals", K(ret));
} else {
ret = add_subquery_filter(qual);
}
} else {
ret = normal_quals.push_back(qual);
}
} else if (ObOptimizerUtil::has_hierarchical_expr(*qual)) {
ret = normal_quals.push_back(qual);
} else if (0 == qual->get_relation_ids().num_members() || is_upper_stmt_column_ref(*qual, *stmt)) {
ret = add_startup_filter(qual);
} else {
ret = normal_quals.push_back(qual);
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(quals.assign(normal_quals))) {
LOG_WARN("failed to assign quals", K(ret));
}
}
// 2. on conditions
for (int64_t i = 0; OB_SUCC(ret) && i < table_items.count(); ++i) {
ret = pre_process_quals(table_items.at(i));
}
// 3. semi conditions
for (int64_t i = 0; OB_SUCC(ret) && i < semi_infos.count(); ++i) {
ret = pre_process_quals(semi_infos.at(i));
}
return ret;
}
int ObLogPlan::pre_process_quals(SemiInfo* semi_info)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(semi_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null semi info", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < semi_info->semi_conditions_.count(); ++i) {
bool can_distribute = true;
ObRawExpr* expr = NULL;
if (OB_ISNULL(expr = semi_info->semi_conditions_.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected NULL", K(ret), K(expr));
} else if (expr->has_flag(CNT_ROWNUM) || expr->has_flag(CNT_RAND_FUNC) || expr->has_flag(CNT_USER_VARIABLE)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected expr in semi condition", K(ret), K(*expr));
} else if (expr->has_flag(CNT_SUB_QUERY) && OB_FAIL(distribute_subquery_qual(expr, can_distribute))) {
LOG_WARN("failed to distribute subquery expr", K(ret));
} else if (!can_distribute) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("correlated subquery in outer join condition is not supported", KPC(expr), K(ret));
} else {
semi_info->semi_conditions_.at(i) = expr;
}
}
return ret;
}
int ObLogPlan::pre_process_quals(TableItem* table_item)
{
int ret = OB_SUCCESS;
JoinedTable* joined_table = static_cast<JoinedTable*>(table_item);
if (OB_ISNULL(table_item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null table item", K(ret));
} else if (!table_item->is_joined_table()) {
// do nothing
} else if (OB_FAIL(SMART_CALL(pre_process_quals(joined_table->left_table_)))) {
LOG_WARN("failed to distribute special quals", K(ret));
} else if (OB_FAIL(SMART_CALL(pre_process_quals(joined_table->right_table_)))) {
LOG_WARN("failed to distribute special quals", K(ret));
} else {
if (FULL_OUTER_JOIN == joined_table->joined_type_ &&
!ObOptimizerUtil::has_equal_join_conditions(joined_table->join_conditions_)) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("full outer join without equal join conditions is not supported now", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < joined_table->join_conditions_.count(); ++i) {
bool can_distribute = true;
ObRawExpr* expr = NULL;
if (OB_ISNULL(expr = joined_table->join_conditions_.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected NULL", K(ret), K(expr));
} else if (expr->has_flag(CNT_SUB_QUERY) && OB_FAIL(distribute_subquery_qual(expr, can_distribute))) {
LOG_WARN("failed to distribute subquery expr", K(ret));
} else if (!can_distribute) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("correlated subquery in outer join condition is not supported", KPC(expr), K(ret));
} else {
joined_table->join_conditions_.at(i) = expr;
}
}
}
return ret;
}
int ObLogPlan::generate_conflict_detectors(const ObIArray<TableItem*>& table_items,
const ObIArray<SemiInfo*>& semi_infos, ObIArray<ObRawExpr*>& quals, ObIArray<ObJoinOrder*>& baserels)
{
int ret = OB_SUCCESS;
ObRelIds table_ids;
ObSEArray<ConflictDetector*, 8> semi_join_detectors;
ObSEArray<ConflictDetector*, 8> inner_join_detectors;
LOG_TRACE("start to generate conflict detector", K(table_items), K(semi_infos), K(quals));
conflict_detectors_.reuse();
if (OB_FAIL(get_table_ids(table_items, table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(generate_inner_join_detectors(table_items, quals, baserels, inner_join_detectors))) {
LOG_WARN("failed to generate inner join detectors", K(ret));
} else if (OB_FAIL(generate_semi_join_detectors(semi_infos, table_ids, inner_join_detectors, semi_join_detectors))) {
LOG_WARN("failed to generate semi join detectors", K(ret));
} else if (OB_FAIL(append(conflict_detectors_, semi_join_detectors))) {
LOG_WARN("failed to append detectors", K(ret));
} else if (OB_FAIL(append(conflict_detectors_, inner_join_detectors))) {
LOG_WARN("failed to append detectors", K(ret));
} else {
LOG_TRACE("succeed to generate confilct detectors", K(semi_join_detectors), K(inner_join_detectors));
}
return ret;
}
int ObLogPlan::generate_semi_join_detectors(const ObIArray<SemiInfo*>& semi_infos, ObRelIds& left_rel_ids,
const ObIArray<ConflictDetector*>& inner_join_detectors, ObIArray<ConflictDetector*>& semi_join_detectors)
{
int ret = OB_SUCCESS;
ObSqlBitSet<> right_rel_ids;
ObDMLStmt* stmt = get_stmt();
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), K(stmt));
}
for (int64_t i = 0; OB_SUCC(ret) && i < semi_infos.count(); ++i) {
right_rel_ids.reuse();
SemiInfo* info = semi_infos.at(i);
ConflictDetector* detector = NULL;
if (OB_ISNULL(info)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null semi info", K(ret));
// 1. create conflict detector
} else if (OB_FAIL(ConflictDetector::build_confict(get_allocator(), detector))) {
LOG_WARN("failed to build conflict detector", K(ret));
} else if (OB_ISNULL(detector)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null conflict detector", K(ret));
} else if (OB_FAIL(detector->L_DS_.add_members(left_rel_ids))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(ObTransformUtils::get_table_rel_ids(*stmt, info->right_table_id_, right_rel_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(detector->R_DS_.add_members(right_rel_ids))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(semi_join_detectors.push_back(detector))) {
LOG_WARN("failed to push back detector", K(ret));
} else {
detector->join_info_.join_type_ = info->join_type_;
// 2. add equal join conditions
ObRawExpr* expr = NULL;
for (int64_t j = 0; OB_SUCC(ret) && j < info->semi_conditions_.count(); ++j) {
if (OB_ISNULL(expr = info->semi_conditions_.at(j))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(expr));
} else if (OB_FAIL(detector->join_info_.table_set_.add_members(expr->get_relation_ids()))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(detector->join_info_.where_condition_.push_back(expr))) {
LOG_WARN("failed to push back exprs", K(ret));
} else if (expr->has_flag(IS_JOIN_COND) &&
OB_FAIL(detector->join_info_.equal_join_condition_.push_back(expr))) {
LOG_WARN("failed to push back qual", K(ret));
}
}
// 3. add other infos to conflict detector
if (OB_FAIL(ret)) {
} else if (OB_FAIL(detector->L_TES_.intersect(detector->join_info_.table_set_, detector->L_DS_))) {
LOG_WARN("failed to generate L-TES", K(ret));
} else if (OB_FAIL(detector->R_TES_.intersect(detector->join_info_.table_set_, detector->R_DS_))) {
LOG_WARN("failed to generate R-TES", K(ret));
} else if (detector->join_info_.table_set_.overlap(detector->L_DS_) &&
detector->join_info_.table_set_.overlap(detector->R_DS_)) {
detector->is_degenerate_pred_ = false;
detector->is_commutative_ = COMM_PROPERTY[detector->join_info_.join_type_];
} else {
detector->is_degenerate_pred_ = true;
detector->is_commutative_ = COMM_PROPERTY[detector->join_info_.join_type_];
}
}
for (int64_t j = 0; OB_SUCC(ret) && j < inner_join_detectors.count(); ++j) {
if (OB_FAIL(generate_conflict_rule(detector, inner_join_detectors.at(j), true, detector->CR_))) {
LOG_WARN("failed to generate conflict rule", K(ret));
}
}
}
return ret;
}
int ObLogPlan::generate_inner_join_detectors(const ObIArray<TableItem*>& table_items, ObIArray<ObRawExpr*>& quals,
ObIArray<ObJoinOrder*>& baserels, ObIArray<ConflictDetector*>& inner_join_detectors)
{
int ret = OB_SUCCESS;
ObSEArray<ConflictDetector*, 8> outer_join_detectors;
ObSEArray<ObRawExpr*, 4> all_table_filters;
ObSEArray<ObRawExpr*, 4> table_filters;
ObRelIds table_ids;
if (OB_FAIL(split_or_quals(table_items, quals))) {
LOG_WARN("failed to split or quals", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < table_items.count(); ++i) {
table_filters.reuse();
table_ids.reuse();
if (OB_FAIL(get_table_ids(table_items.at(i), table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
}
for (int64_t j = 0; OB_SUCC(ret) && j < quals.count(); ++j) {
ObRawExpr* expr = quals.at(j);
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null expr", K(ret));
} else if (!expr->get_relation_ids().is_subset(table_ids)) {
// do nothing
} else if (OB_FAIL(table_filters.push_back(expr))) {
LOG_WARN("failed to push back expr", K(ret));
} else if (OB_FAIL(all_table_filters.push_back(expr))) {
LOG_WARN("failed to push back expr", K(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(generate_outer_join_detectors(table_items.at(i), table_filters, baserels, outer_join_detectors))) {
LOG_WARN("failed to generate outer join detectors", K(ret));
}
}
}
ObRawExpr* expr = NULL;
ConflictDetector* detector = NULL;
ObSEArray<ObRawExpr*, 4> join_conditions;
for (int64_t i = 0; OB_SUCC(ret) && i < quals.count(); ++i) {
if (OB_ISNULL(expr = quals.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null expr", K(ret));
} else if (ObOptimizerUtil::find_item(all_table_filters, expr)) {
// do nothing
} else if (OB_FAIL(join_conditions.push_back(expr))) {
LOG_WARN("failed to push back expr", K(ret));
} else if (OB_FAIL(find_inner_conflict_detector(inner_join_detectors, expr->get_relation_ids(), detector))) {
LOG_WARN("failed to find conflict detector", K(ret));
} else if (NULL == detector) {
if (OB_FAIL(ConflictDetector::build_confict(get_allocator(), detector))) {
LOG_WARN("failed to build conflict detector", K(ret));
} else if (OB_ISNULL(detector)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null detector", K(ret));
} else if (OB_FAIL(detector->join_info_.where_condition_.push_back(expr))) {
LOG_WARN("failed to push back expr", K(ret));
} else if (expr->has_flag(IS_JOIN_COND) && OB_FAIL(detector->join_info_.equal_join_condition_.push_back(expr))) {
LOG_WARN("failed to push back qual", K(ret));
} else if (OB_FAIL(detector->join_info_.table_set_.add_members(expr->get_relation_ids()))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(inner_join_detectors.push_back(detector))) {
LOG_WARN("failed to push back detector", K(ret));
} else {
detector->is_degenerate_pred_ = false;
detector->is_commutative_ = COMM_PROPERTY[INNER_JOIN];
detector->join_info_.join_type_ = INNER_JOIN;
}
} else if (OB_FAIL(detector->join_info_.where_condition_.push_back(expr))) {
LOG_WARN("failed to push back expr", K(ret));
} else if (expr->has_flag(IS_JOIN_COND) && OB_FAIL(detector->join_info_.equal_join_condition_.push_back(expr))) {
LOG_WARN("failed to push back qual", K(ret));
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < inner_join_detectors.count(); ++i) {
ConflictDetector* inner_detector = inner_join_detectors.at(i);
const ObRelIds& table_set = inner_detector->join_info_.table_set_;
if (OB_ISNULL(inner_detector)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null detector", K(ret));
}
for (int64_t j = 0; OB_SUCC(ret) && j < table_items.count(); ++j) {
table_ids.reuse();
if (OB_FAIL(get_table_ids(table_items.at(j), table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (!table_ids.overlap(table_set)) {
// do nothing
} else if (OB_FAIL(inner_detector->L_DS_.add_members(table_ids))) {
LOG_WARN("failed to generate R-TES", K(ret));
} else if (OB_FAIL(inner_detector->R_DS_.add_members(table_ids))) {
LOG_WARN("failed to generate R-TES", K(ret));
}
}
//对于inner join来说，满足交换律，所以不需要区分L_TES、R_TES
//为了方便之后统一applicable算法，L_TES、R_TES都等于SES
if (OB_FAIL(ret)) {
} else if (OB_FAIL(inner_detector->L_TES_.add_members(table_set))) {
LOG_WARN("failed to generate L-TES", K(ret));
} else if (OB_FAIL(inner_detector->R_TES_.add_members(table_set))) {
LOG_WARN("failed to generate R-TES", K(ret));
}
for (int64_t j = 0; OB_SUCC(ret) && j < outer_join_detectors.count(); ++j) {
ConflictDetector* outer_detector = outer_join_detectors.at(j);
if (OB_ISNULL(outer_detector)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null detector", K(ret));
} else if (!IS_OUTER_OR_CONNECT_BY_JOIN(outer_detector->join_info_.join_type_)) {
} else if (OB_FAIL(generate_conflict_rule(inner_detector, outer_detector, true, inner_detector->CR_))) {
LOG_WARN("failed to generate conflict rule", K(ret));
} else if (OB_FAIL(generate_conflict_rule(inner_detector, outer_detector, false, inner_detector->CR_))) {
LOG_WARN("failed to generate conflict rule", K(ret));
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(append(inner_join_detectors, outer_join_detectors))) {
LOG_WARN("failed to append detectors", K(ret));
} else if (OB_FAIL(generate_cross_product_detector(table_items, join_conditions, inner_join_detectors))) {
LOG_WARN("failed to generate cross product detector", K(ret));
}
}
return ret;
}
int ObLogPlan::generate_outer_join_detectors(TableItem* table_item, ObIArray<ObRawExpr*>& table_filter,
ObIArray<ObJoinOrder*>& baserels, ObIArray<ConflictDetector*>& outer_join_detectors)
{
int ret = OB_SUCCESS;
JoinedTable* joined_table = static_cast<JoinedTable*>(table_item);
if (OB_ISNULL(table_item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null table item", K(ret));
} else if (!table_item->is_joined_table()) {
if (OB_FAIL(distribute_quals(table_item, table_filter, baserels))) {
LOG_WARN("failed to distribute table filter", K(ret));
}
} else if (INNER_JOIN == joined_table->joined_type_) {
ObSEArray<TableItem*, 4> table_items;
ObSEArray<ConflictDetector*, 4> detectors;
if (OB_FAIL(flatten_inner_join(table_item, table_filter, table_items))) {
LOG_WARN("failed to flatten inner join", K(ret));
} else if (OB_FAIL(generate_inner_join_detectors(table_items, table_filter, baserels, detectors))) {
LOG_WARN("failed to generate inner join detectors", K(ret));
} else if (OB_FAIL(append(outer_join_detectors, detectors))) {
LOG_WARN("failed to append detectors", K(ret));
}
} else if (OB_FAIL(inner_generate_outer_join_detectors(joined_table, table_filter, baserels, outer_join_detectors))) {
LOG_WARN("failed to generate outer join detectors", K(ret));
}
return ret;
}
int ObLogPlan::distribute_quals(
TableItem* table_item, const ObIArray<ObRawExpr*>& table_filter, ObIArray<ObJoinOrder*>& baserels)
{
int ret = OB_SUCCESS;
ObJoinOrder* cur_rel = NULL;
ObSEArray<int64_t, 8> relids;
ObRelIds table_ids;
if (OB_ISNULL(table_item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), K(table_item));
} else if (OB_FAIL(get_table_ids(table_item, table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(table_ids.to_array(relids))) {
LOG_WARN("to_array error", K(ret));
} else if (1 != relids.count()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expect basic table item", K(ret));
} else if (OB_FAIL(find_base_rel(baserels, relids.at(0), cur_rel))) {
LOG_WARN("find_base_rel fails", K(ret));
} else if (OB_ISNULL(cur_rel)) {
ret = OB_SQL_OPT_ERROR;
LOG_WARN("failed to distribute qual to rel", K(baserels), K(relids), K(ret));
} else if (OB_FAIL(append(cur_rel->get_restrict_infos(), table_filter))) {
LOG_WARN("failed to distribute qual to rel", K(ret));
}
return ret;
}
int ObLogPlan::flatten_table_items(
ObIArray<TableItem*>& table_items, ObIArray<ObRawExpr*>& table_filter, ObIArray<TableItem*>& flatten_table_items)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < table_items.count(); ++i) {
if (OB_FAIL(flatten_inner_join(table_items.at(i), table_filter, flatten_table_items))) {
LOG_WARN("failed to flatten inner join", K(ret));
}
}
return ret;
}
int ObLogPlan::flatten_inner_join(
TableItem* table_item, ObIArray<ObRawExpr*>& table_filter, ObIArray<TableItem*>& table_items)
{
int ret = OB_SUCCESS;
JoinedTable* joined_table = static_cast<JoinedTable*>(table_item);
if (OB_ISNULL(table_item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null table item", K(ret));
} else if (!table_item->is_joined_table() || INNER_JOIN != joined_table->joined_type_) {
ret = table_items.push_back(table_item);
} else if (OB_FAIL(SMART_CALL(flatten_inner_join(joined_table->left_table_, table_filter, table_items)))) {
LOG_WARN("failed to faltten inner join", K(ret));
} else if (OB_FAIL(SMART_CALL(flatten_inner_join(joined_table->right_table_, table_filter, table_items)))) {
LOG_WARN("failed to faltten inner join", K(ret));
} else if (OB_FAIL(append(table_filter, joined_table->join_conditions_))) {
LOG_WARN("failed to append exprs", K(ret));
}
return ret;
}
int ObLogPlan::inner_generate_outer_join_detectors(JoinedTable* joined_table, ObIArray<ObRawExpr*>& table_filter,
ObIArray<ObJoinOrder*>& baserels, ObIArray<ConflictDetector*>& outer_join_detectors)
{
int ret = OB_SUCCESS;
ObRelIds table_set;
ObRelIds left_table_ids;
ObRelIds right_table_ids;
ConflictDetector* detector = NULL;
ObSEArray<ObRawExpr*, 4> left_quals;
ObSEArray<ObRawExpr*, 4> right_quals;
ObSEArray<ConflictDetector*, 4> left_detectors;
ObSEArray<ConflictDetector*, 4> right_detectors;
if (OB_ISNULL(joined_table)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null table item", K(ret));
} else if (OB_FAIL(get_table_ids(joined_table->join_conditions_, table_set))) {
LOG_WARN("failed to get table ids", K(ret));
// 1. pushdown where condition
} else if (OB_FAIL(pushdown_where_filters(joined_table, table_filter, left_quals, right_quals))) {
LOG_WARN("failed to pushdown where filters", K(ret));
// 2. pushdown on condition
} else if (OB_FAIL(pushdown_on_conditions(joined_table, left_quals, right_quals))) {
LOG_WARN("failed to pushdown on conditions", K(ret));
// 3. generate left child detectors
} else if (OB_FAIL(generate_outer_join_detectors(joined_table->left_table_, left_quals, baserels, left_detectors))) {
LOG_WARN("failed to generate outer join detectors", K(ret));
} else if (OB_FAIL(append(outer_join_detectors, left_detectors))) {
LOG_WARN("failed to append detectors", K(ret));
// 4. generate right child detectors
} else if (OB_FAIL(
generate_outer_join_detectors(joined_table->right_table_, right_quals, baserels, right_detectors))) {
LOG_WARN("failed to generate outer join detectors", K(ret));
} else if (OB_FAIL(append(outer_join_detectors, right_detectors))) {
LOG_WARN("failed to append detectors", K(ret));
// 5. create outer join detector
} else if (OB_FAIL(ConflictDetector::build_confict(get_allocator(), detector))) {
LOG_WARN("failed to build conflict detector", K(ret));
} else if (OB_ISNULL(detector)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null detector", K(ret));
} else if (OB_FAIL(get_table_ids(joined_table->left_table_, left_table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(get_table_ids(joined_table->right_table_, right_table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(detector->join_info_.table_set_.add_members(table_set))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(detector->L_DS_.add_members(left_table_ids))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(detector->R_DS_.add_members(right_table_ids))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(append(detector->join_info_.on_condition_, joined_table->join_conditions_))) {
LOG_WARN("failed to append exprs", K(ret));
} else if (OB_FAIL(outer_join_detectors.push_back(detector))) {
LOG_WARN("failed to push back detecotor", K(ret));
} else {
detector->is_commutative_ = COMM_PROPERTY[joined_table->joined_type_];
detector->join_info_.join_type_ = joined_table->joined_type_;
if (table_set.overlap(left_table_ids) && table_set.overlap(right_table_ids)) {
detector->is_degenerate_pred_ = false;
} else {
detector->is_degenerate_pred_ = true;
}
if (CONNECT_BY_JOIN == joined_table->joined_type_) {
if (OB_FAIL(detector->join_info_.table_set_.add_members(left_table_ids))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(detector->join_info_.table_set_.add_members(right_table_ids))) {
LOG_WARN("failed to add members", K(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(detector->L_TES_.intersect(detector->join_info_.table_set_, detector->L_DS_))) {
LOG_WARN("failed to generate L-TES", K(ret));
} else if (OB_FAIL(detector->R_TES_.intersect(detector->join_info_.table_set_, detector->R_DS_))) {
LOG_WARN("failed to generate R-TES", K(ret));
}
}
int64_t N = joined_table->join_conditions_.count();
for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
ObRawExpr* expr = joined_table->join_conditions_.at(i);
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null expr", K(ret));
} else if (expr->has_flag(IS_JOIN_COND) && OB_FAIL(detector->join_info_.equal_join_condition_.push_back(expr))) {
LOG_WARN("failed to push back qual", K(ret));
}
}
// 6. generate conflict rules
for (int64_t i = 0; OB_SUCC(ret) && i < left_detectors.count(); ++i) {
if (OB_FAIL(generate_conflict_rule(detector, left_detectors.at(i), true, detector->CR_))) {
LOG_WARN("failed to generate conflict rule", K(ret));
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < right_detectors.count(); ++i) {
if (OB_FAIL(generate_conflict_rule(detector, right_detectors.at(i), false, detector->CR_))) {
LOG_WARN("failed to generate conflict rule", K(ret));
}
}
// 7. generate conflict detector for table filter
if (OB_SUCC(ret) && !table_filter.empty()) {
if (OB_FAIL(ConflictDetector::build_confict(get_allocator(), detector))) {
LOG_WARN("failed to build conflict detector", K(ret));
} else if (OB_ISNULL(detector)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null detector", K(ret));
} else if (OB_FAIL(append(detector->join_info_.where_condition_, table_filter))) {
LOG_WARN("failed to append expr", K(ret));
} else if (OB_FAIL(detector->join_info_.table_set_.add_members(left_table_ids))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(detector->join_info_.table_set_.add_members(right_table_ids))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(outer_join_detectors.push_back(detector))) {
LOG_WARN("failed to push back detector", K(ret));
} else {
detector->is_degenerate_pred_ = false;
detector->is_commutative_ = COMM_PROPERTY[INNER_JOIN];
detector->join_info_.join_type_ = INNER_JOIN;
}
}
}
return ret;
}
int ObLogPlan::pushdown_where_filters(JoinedTable* joined_table, ObIArray<ObRawExpr*>& table_filter,
ObIArray<ObRawExpr*>& left_quals, ObIArray<ObRawExpr*>& right_quals)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(joined_table)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null param", K(ret));
} else {
ObRelIds left_table_set;
ObRelIds right_table_set;
int64_t N = table_filter.count();
ObSEArray<ObRawExpr*, 4> new_quals;
ObJoinType join_type = joined_table->joined_type_;
if (OB_FAIL(get_table_ids(joined_table->left_table_, left_table_set))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(get_table_ids(joined_table->right_table_, right_table_set))) {
LOG_WARN("failed to get table ids", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < N; i++) {
ObRawExpr* qual = table_filter.at(i);
if (OB_ISNULL(qual)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("null expr", K(qual), K(ret));
} else if (qual->get_relation_ids().is_empty() && !ObOptimizerUtil::has_hierarchical_expr(*qual)) {
if (OB_FAIL(left_quals.push_back(qual))) {
LOG_WARN("failed to push back expr", K(ret));
} else if (OB_FAIL(right_quals.push_back(qual))) {
LOG_WARN("failed to push back expr", K(ret));
}
} else if (LEFT_OUTER_JOIN == join_type && qual->get_relation_ids().is_subset(left_table_set)) {
if (OB_FAIL(left_quals.push_back(qual))) {
LOG_WARN("failed to push back expr", K(ret));
}
} else if (RIGHT_OUTER_JOIN == join_type && qual->get_relation_ids().is_subset(right_table_set)) {
if (OB_FAIL(right_quals.push_back(qual))) {
LOG_WARN("failed to push back expr", K(ret));
}
} else if (OB_FAIL(new_quals.push_back(qual))) {
LOG_WARN("failed to push back expr", K(ret));
} else if (T_OP_OR == qual->get_expr_type()) {
ObOpRawExpr* or_qual = static_cast<ObOpRawExpr*>(qual);
if (LEFT_OUTER_JOIN == join_type && OB_FAIL(try_split_or_qual(left_table_set, *or_qual, left_quals))) {
LOG_WARN("failed to split or qual on left table", K(ret));
} else if (RIGHT_OUTER_JOIN == join_type &&
OB_FAIL(try_split_or_qual(right_table_set, *or_qual, right_quals))) {
LOG_WARN("failed to split or qual on right table", K(ret));
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(table_filter.assign(new_quals))) {
LOG_WARN("failed to assign exprs", K(ret));
}
}
}
return ret;
}
int ObLogPlan::pushdown_on_conditions(
JoinedTable* joined_table, ObIArray<ObRawExpr*>& left_quals, ObIArray<ObRawExpr*>& right_quals)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(joined_table)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null param", K(ret));
} else {
ObRawExpr* qual = NULL;
ObRelIds left_table_set;
ObRelIds right_table_set;
ObSEArray<ObRawExpr*, 4> new_quals;
ObJoinType join_type = joined_table->joined_type_;
int64_t N = joined_table->join_conditions_.count();
if (OB_FAIL(get_table_ids(joined_table->left_table_, left_table_set))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(get_table_ids(joined_table->right_table_, right_table_set))) {
LOG_WARN("failed to get table ids", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < N; i++) {
if (OB_ISNULL(qual = joined_table->join_conditions_.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("null expr", K(qual), K(ret));
} else if (RIGHT_OUTER_JOIN == join_type &&
qual->get_relation_ids().is_subset(left_table_set)) {
if (OB_FAIL(left_quals.push_back(qual))) {
LOG_WARN("failed to push back expr", K(ret));
}
} else if (LEFT_OUTER_JOIN == join_type &&
qual->get_relation_ids().is_subset(right_table_set)) {
if (OB_FAIL(right_quals.push_back(qual))) {
LOG_WARN("failed to push back expr", K(ret));
}
} else if (CONNECT_BY_JOIN == join_type && !qual->get_relation_ids().is_empty() &&
qual->get_relation_ids().is_subset(right_table_set) && !qual->has_flag(CNT_LEVEL) &&
!qual->has_flag(CNT_PRIOR) && !qual->has_flag(CNT_ROWNUM)) {
if (OB_FAIL(right_quals.push_back(qual))) {
LOG_WARN("failed to push back expr", K(ret));
}
} else if (OB_FAIL(new_quals.push_back(qual))) {
LOG_WARN("failed to push back expr", K(ret));
} else if (!qual->get_relation_ids().is_empty() && T_OP_OR == qual->get_expr_type()) {
ObOpRawExpr* or_qual = static_cast<ObOpRawExpr*>(qual);
if (LEFT_OUTER_JOIN == join_type && OB_FAIL(try_split_or_qual(right_table_set, *or_qual, right_quals))) {
LOG_WARN("failed to split or qual on right table", K(ret));
} else if (RIGHT_OUTER_JOIN == join_type && OB_FAIL(try_split_or_qual(left_table_set, *or_qual, left_quals))) {
LOG_WARN("failed to split or qual on left table", K(ret));
} else if (CONNECT_BY_JOIN == join_type && !qual->has_flag(CNT_LEVEL) && !qual->has_flag(CNT_ROWNUM) &&
!qual->has_flag(CNT_PRIOR) && OB_FAIL(try_split_or_qual(right_table_set, *or_qual, right_quals))) {
LOG_WARN("failed to split or qual on right table", K(ret));
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(joined_table->join_conditions_.assign(new_quals))) {
LOG_WARN("failed to assign exprs", K(ret));
}
}
}
return ret;
}
int ObLogPlan::generate_cross_product_detector(const ObIArray<TableItem*>& table_items, ObIArray<ObRawExpr*>& quals,
ObIArray<ConflictDetector*>& inner_join_detectors)
{
int ret = OB_SUCCESS;
ObRelIds table_ids;
ConflictDetector* detector = NULL;
if (table_items.count() < 2) {
// do nothing
} else if (OB_FAIL(get_table_ids(table_items, table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(ConflictDetector::build_confict(get_allocator(), detector))) {
LOG_WARN("failed to build conflict detector", K(ret));
} else if (OB_ISNULL(detector)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null conflict detector", K(ret));
} else if (OB_FAIL(detector->L_DS_.add_members(table_ids))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(detector->R_DS_.add_members(table_ids))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(generate_cross_product_conflict_rule(detector, table_items, quals))) {
LOG_WARN("failed to generate cross product conflict rule", K(ret));
} else if (OB_FAIL(inner_join_detectors.push_back(detector))) {
LOG_WARN("failed to push back detector", K(ret));
} else {
detector->join_info_.join_type_ = INNER_JOIN;
detector->is_degenerate_pred_ = true;
detector->is_commutative_ = true;
}
return ret;
}
int ObLogPlan::check_join_info(
const ObRelIds& left, const ObRelIds& right, const ObIArray<ObRelIds>& base_table_ids, bool& is_connected)
{
int ret = OB_SUCCESS;
ObRelIds table_ids;
is_connected = false;
if (OB_FAIL(table_ids.except(left, right))) {
LOG_WARN("failed to cal except for rel ids", K(ret));
} else if (table_ids.is_empty()) {
is_connected = true;
} else {
int64_t N = base_table_ids.count();
for (int64_t i = 0; OB_SUCC(ret) && !is_connected && i < N; ++i) {
if (table_ids.is_subset(base_table_ids.at(i))) {
is_connected = true;
}
}
}
return ret;
}
int ObLogPlan::generate_cross_product_conflict_rule(ConflictDetector* cross_product_detector,
const ObIArray<TableItem*>& table_items, const ObIArray<ObRawExpr*>& join_conditions)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(cross_product_detector)) {
ret = OB_SUCCESS;
LOG_WARN("unexpect null detector", K(ret));
} else {
ObRelIds table_ids;
bool have_new_connect_info = true;
ObSEArray<ObRelIds, 8> base_table_ids;
ObSEArray<ObRelIds, 8> connect_infos;
LOG_TRACE("start generate cross product conflict rule", K(table_items), K(join_conditions));
for (int64_t i = 0; OB_SUCC(ret) && i < table_items.count(); ++i) {
table_ids.reuse();
if (OB_FAIL(get_table_ids(table_items.at(i), table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(base_table_ids.push_back(table_ids))) {
LOG_WARN("failed to push back rel ids", K(ret));
} else if (OB_FAIL(connect_infos.push_back(table_ids))) {
LOG_WARN("failed to push back rel ids", K(ret));
}
}
ObSqlBitSet<> used_join_conditions;
while (have_new_connect_info) {
have_new_connect_info = false;
for (int64_t i = 0; OB_SUCC(ret) && i < join_conditions.count(); ++i) {
ObRawExpr* expr = join_conditions.at(i);
if (used_join_conditions.has_member(i)) {
// do nothing
} else if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null expr", K(ret));
} else {
ObSqlBitSet<> used_infos;
ObRelIds connect_tables;
if (OB_FAIL(connect_tables.add_members(expr->get_relation_ids()))) {
LOG_WARN("failed to add members", K(ret));
}
for (int64_t j = 0; OB_SUCC(ret) && j < connect_infos.count(); ++j) {
bool is_connected = false;
if (OB_FAIL(check_join_info(expr->get_relation_ids(), connect_infos.at(j), base_table_ids, is_connected))) {
LOG_WARN("failed to check join info", K(ret));
} else if (!is_connected) {
// do nothing
} else if (OB_FAIL(used_infos.add_member(j))) {
LOG_WARN("failed to add member", K(ret));
} else if (connect_tables.add_members(connect_infos.at(j))) {
LOG_WARN("failed to add members", K(ret));
}
}
if (OB_SUCC(ret) && !used_infos.is_empty()) {
have_new_connect_info = true;
if (OB_FAIL(used_join_conditions.add_member(i))) {
LOG_WARN("failed to add member", K(ret));
}
for (int64_t j = 0; OB_SUCC(ret) && j < connect_infos.count(); ++j) {
if (!used_infos.has_member(j)) {
// do nothing
} else if (OB_FAIL(connect_infos.at(j).add_members(connect_tables))) {
LOG_WARN("failed to add members", K(ret));
}
}
LOG_TRACE("succeed to add new connect info", K(*expr), K(connect_infos));
}
}
}
}
ObSEArray<ObRelIds, 8> new_connect_infos;
for (int64_t i = 0; OB_SUCC(ret) && i < connect_infos.count(); ++i) {
bool find = false;
for (int64_t j = 0; !find && j < new_connect_infos.count(); ++j) {
if (new_connect_infos.at(j).equal(connect_infos.at(i))) {
find = true;
}
}
if (!find) {
ret = new_connect_infos.push_back(connect_infos.at(i));
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < base_table_ids.count(); ++i) {
if (base_table_ids.at(i).num_members() < 2) {
// do nothing
} else if (OB_FAIL(add_conflict_rule(
base_table_ids.at(i), base_table_ids.at(i), cross_product_detector->cross_product_rule_))) {
LOG_WARN("failed to add conflict rule", K(ret));
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < new_connect_infos.count(); ++i) {
if (new_connect_infos.at(i).num_members() < 2) {
// do nothing
} else if (OB_FAIL(add_conflict_rule(new_connect_infos.at(i),
new_connect_infos.at(i),
cross_product_detector->delay_cross_product_rule_))) {
LOG_WARN("failed to add conflict rule", K(ret));
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < new_connect_infos.count(); ++i) {
if (new_connect_infos.at(i).num_members() > 1) {
for (int64_t j = i + 1; OB_SUCC(ret) && j < new_connect_infos.count(); ++j) {
if (new_connect_infos.at(j).num_members() > 1) {
ObRelIds bushy_info;
if (OB_FAIL(bushy_info.add_members(new_connect_infos.at(i)))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(bushy_info.add_members(new_connect_infos.at(j)))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(bushy_tree_infos_.push_back(bushy_info))) {
LOG_WARN("failed to push back info", K(ret));
}
}
}
}
}
if (OB_SUCC(ret)) {
if (new_connect_infos.count() == 1) {
cross_product_detector->is_redundancy_ = true;
}
}
LOG_TRACE("update bushy tree info", K(bushy_tree_infos_));
}
return ret;
}
int ObLogPlan::select_location(ObIArray<ObTablePartitionInfo*>& tbl_part_info_list)
{
int ret = OB_SUCCESS;
ObExecContext* exec_ctx = optimizer_context_.get_exec_ctx();
ObSEArray<const ObTableLocation*, 1> tbl_loc_list;
ObSEArray<ObPhyTableLocationInfo*, 1> phy_tbl_loc_info_list;
if (OB_ISNULL(exec_ctx)) {
LOG_ERROR("exec ctx is NULL", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < tbl_part_info_list.count(); ++i) {
ObTablePartitionInfo* tbl_part_info = tbl_part_info_list.at(i);
if (OB_ISNULL(tbl_part_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("tbl part info is NULL", K(ret), K(i), K(tbl_part_info_list.count()));
} else if (OB_FAIL(tbl_loc_list.push_back(&tbl_part_info->get_table_location()))) {
LOG_WARN("fail to push back table location list", K(ret), K(tbl_part_info->get_table_location()));
} else if (OB_FAIL(phy_tbl_loc_info_list.push_back(&tbl_part_info->get_phy_tbl_location_info_for_update()))) {
LOG_WARN("fail to push back phy tble loc info", K(ret), K(tbl_part_info->get_phy_tbl_location_info_for_update()));
}
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(ObLogPlan::select_replicas(
*exec_ctx, tbl_loc_list, optimizer_context_.get_local_server_addr(), phy_tbl_loc_info_list))) {
LOG_WARN("fail to select replicas",
K(ret),
K(tbl_loc_list.count()),
K(optimizer_context_.get_local_server_addr()),
K(phy_tbl_loc_info_list.count()));
}
return ret;
}
int ObLogPlan::select_replicas(ObExecContext& exec_ctx, const ObIArray<const ObTableLocation*>& tbl_loc_list,
const ObAddr& local_server, ObIArray<ObPhyTableLocationInfo*>& phy_tbl_loc_info_list)
{
int ret = OB_SUCCESS;
bool is_weak = true;
if (OB_ISNULL(exec_ctx.get_my_session())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else {
is_weak = !ObDMLStmt::is_dml_write_stmt(exec_ctx.get_my_session()->get_stmt_type());
}
for (int64_t i = 0; OB_SUCC(ret) && is_weak && i < tbl_loc_list.count(); i++) {
bool is_weak_read = false;
const ObTableLocation* table_location = tbl_loc_list.at(i);
if (OB_ISNULL(table_location)) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("table location is NULL", K(ret), K(i), K(tbl_loc_list.count()));
} else if (OB_FAIL(table_location->get_is_weak_read(exec_ctx, is_weak_read))) {
LOG_WARN("fail to get is weak read", K(ret), K(*table_location));
} else if (!is_weak_read) {
is_weak = false;
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(select_replicas(exec_ctx, is_weak, local_server, phy_tbl_loc_info_list))) {
LOG_WARN("select replicas failed", K(ret));
}
}
return ret;
}
int ObLogPlan::select_replicas(ObExecContext& exec_ctx, bool is_weak, const ObAddr& local_server,
ObIArray<ObPhyTableLocationInfo*>& phy_tbl_loc_info_list)
{
int ret = OB_SUCCESS;
ObSQLSessionInfo* session = exec_ctx.get_my_session();
ObTaskExecutorCtx& task_exec_ctx = exec_ctx.get_task_exec_ctx();
ObPartitionService* partition_service = NULL;
bool is_hit_partition = false;
ObFollowerFirstFeedbackType follower_first_feedback = FFF_HIT_MIN;
int64_t route_policy_type = 0;
bool proxy_priority_hit_support = false;
if (OB_ISNULL(session) || OB_ISNULL(partition_service = task_exec_ctx.get_partition_service())) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("session is NULL", K(ret), K(session), K(partition_service));
} else if (OB_FAIL(session->get_sys_variable(SYS_VAR_OB_ROUTE_POLICY, route_policy_type))) {
LOG_WARN("fail to get sys variable", K(ret));
} else {
proxy_priority_hit_support = session->get_proxy_cap_flags().is_priority_hit_support();
}
if (OB_FAIL(ret)) {
} else if (is_weak) {
if (OB_FAIL(ObLogPlan::weak_select_replicas(*partition_service,
local_server,
static_cast<ObRoutePolicyType>(route_policy_type),
proxy_priority_hit_support,
phy_tbl_loc_info_list,
is_hit_partition,
follower_first_feedback))) {
LOG_WARN("fail to weak select intersect replicas", K(ret), K(local_server), K(phy_tbl_loc_info_list.count()));
} else {
ObPartitionKey part_key;
session->partition_hit().try_set_bool(is_hit_partition);
if (FFF_HIT_MIN != follower_first_feedback) {
if (OB_FAIL(session->set_follower_first_feedback(follower_first_feedback))) {
LOG_WARN("fail to set_follower_first_feedback", K(follower_first_feedback), K(ret));
}
}
if (OB_SUCC(ret)) {
task_exec_ctx.set_need_renew_location_cache(!is_hit_partition);
if (task_exec_ctx.is_need_renew_location_cache()) {
for (int64_t i = 0; OB_SUCC(ret) && i < phy_tbl_loc_info_list.count(); ++i) {
const ObPhyTableLocationInfo* phy_tbl_loc_info = phy_tbl_loc_info_list.at(i);
if (OB_ISNULL(phy_tbl_loc_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("phy tbl loc info is NULL", K(ret), K(i));
} else {
const ObPhyPartitionLocationInfoIArray& phy_part_loc_info_list =
phy_tbl_loc_info->get_phy_part_loc_info_list();
for (int64_t j = 0; OB_SUCC(ret) && j < phy_part_loc_info_list.count(); ++j) {
part_key.reset();
const ObPhyPartitionLocationInfo& phy_part_loc_info = phy_part_loc_info_list.at(j);
if (OB_FAIL(phy_part_loc_info.get_partition_location().get_partition_key(part_key))) {
LOG_WARN("fail to get part key", K(ret), K(phy_part_loc_info.get_partition_location()));
} else if (OB_FAIL(task_exec_ctx.add_need_renew_partition_keys_distinctly(part_key))) {
LOG_WARN("fail to add need renew partition key", K(ret), K(part_key));
}
}
}
}
}
}
}
} else {
const bool sess_in_retry = session->get_is_in_retry_for_dup_tbl();
if (OB_FAIL(
ObLogPlan::strong_select_replicas(local_server, phy_tbl_loc_info_list, is_hit_partition, sess_in_retry))) {
LOG_WARN("fail to strong select replicas", K(ret), K(local_server), K(phy_tbl_loc_info_list.count()));
int tmp_ret = set_table_location(task_exec_ctx, phy_tbl_loc_info_list);
if (OB_SUCCESS != tmp_ret) {
LOG_WARN("fail to set table location", K(tmp_ret), K(phy_tbl_loc_info_list));
}
} else {
session->partition_hit().try_set_bool(is_hit_partition);
task_exec_ctx.set_need_renew_location_cache(false);
}
}
return ret;
}
int ObLogPlan::set_table_location(
ObTaskExecutorCtx& task_exec_ctx, ObIArray<ObPhyTableLocationInfo*>& phy_tbl_loc_info_list)
{
int ret = OB_SUCCESS;
ObPhyTableLocation location;
ObPartitionKey key;
ObPartitionReplicaLocation partition_replica_location;
for (int64_t i = 0; i < phy_tbl_loc_info_list.count() && OB_SUCC(ret); i++) {
ObPhyTableLocationInfo*& info = phy_tbl_loc_info_list.at(i);
location.reset();
for (int64_t j = 0; j < info->get_phy_part_loc_info_list().count() && OB_SUCC(ret); j++) {
const ObPhyPartitionLocationInfo& partition_location_info = info->get_phy_part_loc_info_list().at(j);
const ObOptPartLoc& part_loc = partition_location_info.get_partition_location();
if (OB_FAIL(part_loc.get_partition_key(key))) {
LOG_WARN("fail to get partition key", K(ret), K(part_loc));
} else {
partition_replica_location.set_table_id(key.get_table_id());
partition_replica_location.set_partition_id(key.get_partition_id());
partition_replica_location.set_partition_cnt(key.get_partition_cnt());
if (OB_FAIL(location.add_partition_location(partition_replica_location))) {
LOG_WARN("fail to add partition location", K(ret));
}
}
} // end for
if (OB_SUCC(ret)) {
if (OB_FAIL(task_exec_ctx.get_table_locations().push_back(location))) {
LOG_WARN("fail to push back", K(ret), K(location));
}
}
} // end for
LOG_TRACE("finish set table location", "table_locaiont", task_exec_ctx.get_table_locations());
return ret;
}
int ObLogPlan::strong_select_replicas(const ObAddr& local_server,
ObIArray<ObPhyTableLocationInfo*>& phy_tbl_loc_info_list, bool& is_hit_partition, bool sess_in_retry)
{
int ret = OB_SUCCESS;
bool all_is_on_same_server = true;
ObAddr all_same_server = local_server;
ObAddr cur_same_server;
for (int64_t i = 0; OB_SUCC(ret) && i < phy_tbl_loc_info_list.count(); ++i) {
cur_same_server.reset();
ObPhyTableLocationInfo* phy_tbl_loc_info = phy_tbl_loc_info_list.at(i);
bool is_on_same_server = false;
if (OB_ISNULL(phy_tbl_loc_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("phy_tbl_loc_info is NULL", K(ret), K(i), K(phy_tbl_loc_info_list.count()));
} else if (0 == phy_tbl_loc_info->get_partition_cnt()) {
} else {
if (!sess_in_retry && phy_tbl_loc_info->is_duplicate_table_not_in_dml()) {
if (OB_FAIL(phy_tbl_loc_info->all_select_local_replica_or_leader(
is_on_same_server, cur_same_server, local_server))) {
LOG_WARN("fail to all select leader", K(ret), K(*phy_tbl_loc_info));
} else {
LOG_TRACE("succeed to select replica for duplicate table", K(*phy_tbl_loc_info), K(is_on_same_server));
}
} else {
if (OB_FAIL(phy_tbl_loc_info->all_select_leader(is_on_same_server, cur_same_server))) {
LOG_WARN("fail to all select leader", K(ret), K(*phy_tbl_loc_info));
}
}
if (OB_FAIL(ret)) {
// do nothing...
} else if (all_is_on_same_server) {
if (is_on_same_server) {
if (0 == i) {
all_same_server = cur_same_server;
} else if (all_same_server != cur_same_server) {
all_is_on_same_server = false;
}
} else {
all_is_on_same_server = false;
}
}
}
}
if (OB_SUCC(ret)) {
if (all_is_on_same_server && local_server != all_same_server) {
is_hit_partition = false;
} else {
is_hit_partition = true;
}
}
return ret;
}
int ObLogPlan::get_global_phy_tbl_location_info(ObPhyTableLocationInfoIArray& tbl_infos) const
{
int ret = OB_SUCCESS;
if (OB_ISNULL(get_stmt()) || OB_ISNULL(get_stmt()->get_query_ctx())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("stmt is null", K(get_stmt()));
} else {
const ObTablePartitionInfoArray& tbl_part_infos = get_stmt()->get_query_ctx()->table_partition_infos_;
ARRAY_FOREACH(tbl_part_infos, i)
{
if (OB_ISNULL(tbl_part_infos.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table partition info is null");
} else if (OB_FAIL(tbl_infos.push_back(tbl_part_infos.at(i)->get_phy_tbl_location_info()))) {
LOG_WARN("add phy table location info failed", K(ret));
}
}
}
return ret;
}
int ObLogPlan::weak_select_replicas(ObPartitionService& partition_service, const ObAddr& local_server,
ObRoutePolicyType route_type, bool proxy_priority_hit_support,
ObIArray<ObPhyTableLocationInfo*>& phy_tbl_loc_info_list, bool& is_hit_partition,
ObFollowerFirstFeedbackType& follower_first_feedback)
{
int ret = OB_SUCCESS;
is_hit_partition = true;
ObPhyTableLocationInfo* phy_tbl_loc_info = nullptr;
ObArenaAllocator allocator(ObModIds::OB_SQL_OPTIMIZER_SELECT_REPLICA);
ObList<ObRoutePolicy::CandidateReplica, ObArenaAllocator> intersect_server_list(allocator);
ObRoutePolicy route_policy(local_server, partition_service);
ObRoutePolicyCtx route_policy_ctx;
route_policy_ctx.policy_type_ = route_type;
route_policy_ctx.consistency_level_ = WEAK;
route_policy_ctx.is_proxy_priority_hit_support_ = proxy_priority_hit_support;
if (OB_FAIL(route_policy.init())) {
LOG_WARN("fail to init route policy", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < phy_tbl_loc_info_list.count(); ++i) {
if (OB_ISNULL(phy_tbl_loc_info = phy_tbl_loc_info_list.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("phy table loc info is NULL", K(phy_tbl_loc_info), K(i), K(ret));
} else {
ObPhyPartitionLocationInfoIArray& phy_part_loc_info_list =
phy_tbl_loc_info->get_phy_part_loc_info_list_for_update();
for (int64_t j = 0; OB_SUCC(ret) && j < phy_part_loc_info_list.count(); ++j) {
ObPhyPartitionLocationInfo& phy_part_loc_info = phy_part_loc_info_list.at(j);
if (phy_part_loc_info.has_selected_replica()) { // do nothing
} else {
ObIArray<ObRoutePolicy::CandidateReplica>& replica_array =
phy_part_loc_info.get_partition_location().get_replica_locations();
if (OB_FAIL(route_policy.init_candidate_replicas(replica_array))) {
LOG_WARN("fail to init candidate replicas", K(replica_array), K(ret));
} else if (OB_FAIL(route_policy.calculate_replica_priority(replica_array, route_policy_ctx))) {
LOG_WARN("fail to calculate replica priority", K(replica_array), K(route_policy_ctx), K(ret));
} else if (OB_FAIL(route_policy.select_replica_with_priority(
route_policy_ctx, replica_array, phy_part_loc_info))) {
LOG_WARN("fail to select replica", K(replica_array), K(ret));
}
}
}
}
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(route_policy.select_intersect_replica(
route_policy_ctx, phy_tbl_loc_info_list, intersect_server_list, is_hit_partition))) {
LOG_WARN("fail to select intersect replica",
K(route_policy_ctx),
K(phy_tbl_loc_info_list),
K(intersect_server_list),
K(ret));
}
if (OB_SUCC(ret)) {
if (proxy_priority_hit_support) {
// nothing, current doesn't support
} else {
ObArenaAllocator allocator(ObModIds::OB_SQL_OPTIMIZER_SELECT_REPLICA);
ObAddrList intersect_servers(allocator);
if (OB_FAIL(calc_hit_partition_for_compat(
phy_tbl_loc_info_list, local_server, is_hit_partition, intersect_servers))) {
LOG_WARN("fail to calc hit partition for compat", K(ret));
} else {
if (is_hit_partition && route_policy.is_follower_first_route_policy_type(route_policy_ctx)) {
if (OB_FAIL(calc_follower_first_feedback(
phy_tbl_loc_info_list, local_server, intersect_servers, follower_first_feedback))) {
LOG_WARN("fail to calc follower first feedback", K(ret));
}
}
}
}
}
if (REACH_TIME_INTERVAL(10 * 1000 * 1000)) {
LOG_INFO("selected replica ",
"intersect_server_list",
intersect_server_list,
"\n phy_tbl_loc_info_list",
phy_tbl_loc_info_list,
"\n route_policy",
route_policy,
"\n route_policy_ctx",
route_policy_ctx,
"\n follower_first_feedback",
follower_first_feedback,
"\n is_hit_partition",
is_hit_partition);
}
return ret;
}
int ObLogPlan::calc_follower_first_feedback(const ObIArray<ObPhyTableLocationInfo*>& phy_tbl_loc_info_list,
const ObAddr& local_server, const ObAddrList& intersect_servers,
ObFollowerFirstFeedbackType& follower_first_feedback)
{
INIT_SUCC(ret);
follower_first_feedback = FFF_HIT_MIN;
if (intersect_servers.empty()) {
// nothing, no need feedback
} else {
bool is_leader_replica = true;
for (int64_t i = 0; OB_SUCC(ret) && is_leader_replica && (i < phy_tbl_loc_info_list.count()); ++i) {
const ObPhyTableLocationInfo* phy_tbl_loc_info = phy_tbl_loc_info_list.at(i);
if (OB_ISNULL(phy_tbl_loc_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("phy_tbl_loc_info is NULL", K(ret), K(i), K(phy_tbl_loc_info_list.count()));
} else {
const ObPhyPartitionLocationInfoIArray& phy_part_loc_info_list = phy_tbl_loc_info->get_phy_part_loc_info_list();
if (phy_part_loc_info_list.empty()) {
// juest defense, when partition location list is empty, treat as it's not leader replica
is_leader_replica = false;
}
for (int64_t j = 0; OB_SUCC(ret) && is_leader_replica && (j < phy_part_loc_info_list.count()); ++j) {
bool found_server = false;
const ObPhyPartitionLocationInfo& phy_part_loc_info = phy_part_loc_info_list.at(j);
const ObIArray<ObRoutePolicy::CandidateReplica>& replica_loc_list =
phy_part_loc_info.get_partition_location().get_replica_locations();
for (int64_t k = 0; !found_server && (k < replica_loc_list.count()); ++k) {
const ObRoutePolicy::CandidateReplica& tmp_replica = replica_loc_list.at(k);
if (local_server == tmp_replica.server_) {
found_server = true;
is_leader_replica = (is_strong_leader(tmp_replica.role_));
}
}
if (!found_server) { // if not found, just treat as it's not leader
is_leader_replica = false;
}
}
}
}
if (is_leader_replica) {
follower_first_feedback = FFF_HIT_LEADER;
} else {
// nothing, no need feedback
}
LOG_TRACE("after calc follower first feedback",
K(follower_first_feedback),
K(is_leader_replica),
K(local_server),
K(intersect_servers));
}
return ret;
}
int ObLogPlan::calc_hit_partition_for_compat(const ObIArray<ObPhyTableLocationInfo*>& phy_tbl_loc_info_list,
const ObAddr& local_server, bool& is_hit_partition, ObAddrList& intersect_servers)
{
int ret = OB_SUCCESS;
bool can_select_local_server = false;
is_hit_partition = false;
if (OB_FAIL(calc_intersect_servers(phy_tbl_loc_info_list, intersect_servers))) {
LOG_WARN("fail to calc hit partition for compat", K(ret));
} else if (intersect_servers.empty()) {
is_hit_partition = true;
} else {
ObAddrList::iterator candidate_server_list_iter = intersect_servers.begin();
for (; OB_SUCC(ret) && !can_select_local_server && candidate_server_list_iter != intersect_servers.end();
candidate_server_list_iter++) {
const ObAddr& candidate_server = *candidate_server_list_iter;
if (local_server == candidate_server) {
is_hit_partition = true;
can_select_local_server = true;
}
}
}
return ret;
}
int ObLogPlan::calc_intersect_servers(
const ObIArray<ObPhyTableLocationInfo*>& phy_tbl_loc_info_list, ObAddrList& candidate_server_list)
{
int ret = OB_SUCCESS;
bool can_select_one_server = true;
ObRoutePolicy::CandidateReplica tmp_replica;
candidate_server_list.reset();
for (int64_t i = 0; OB_SUCC(ret) && can_select_one_server && i < phy_tbl_loc_info_list.count(); ++i) {
const ObPhyTableLocationInfo* phy_tbl_loc_info = phy_tbl_loc_info_list.at(i);
if (OB_ISNULL(phy_tbl_loc_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("phy_tbl_loc_info is NULL", K(ret), K(i), K(phy_tbl_loc_info_list.count()));
} else {
const ObPhyPartitionLocationInfoIArray& phy_part_loc_info_list = phy_tbl_loc_info->get_phy_part_loc_info_list();
for (int64_t j = 0; OB_SUCC(ret) && can_select_one_server && j < phy_part_loc_info_list.count(); ++j) {
const ObPhyPartitionLocationInfo& phy_part_loc_info = phy_part_loc_info_list.at(j);
const ObIArray<ObRoutePolicy::CandidateReplica>& replica_loc_list =
phy_part_loc_info.get_partition_location().get_replica_locations();
if (0 == i && 0 == j) {
for (int64_t k = 0; OB_SUCC(ret) && k < replica_loc_list.count(); ++k) {
if (OB_FAIL(candidate_server_list.push_back(replica_loc_list.at(k).server_))) {
LOG_WARN("fail to push back candidate server", K(ret), K(k), K(replica_loc_list.at(k)));
}
}
} else {
ObAddrList::iterator candidate_server_list_iter = candidate_server_list.begin();
for (; OB_SUCC(ret) && candidate_server_list_iter != candidate_server_list.end();
candidate_server_list_iter++) {
const ObAddr& candidate_server = *candidate_server_list_iter;
bool has_replica = false;
for (int64_t k = 0; OB_SUCC(ret) && !has_replica && k < replica_loc_list.count(); ++k) {
if (replica_loc_list.at(k).server_ == candidate_server) {
has_replica = true;
}
}
if (OB_SUCC(ret) && !has_replica) {
if (OB_FAIL(candidate_server_list.erase(candidate_server_list_iter))) {
LOG_WARN("fail to erase from list", K(ret), K(replica_loc_list), K(candidate_server));
}
}
}
if (OB_SUCC(ret) && candidate_server_list.empty()) {
can_select_one_server = false;
}
}
}
}
}
return ret;
}
int ObLogPlan::select_one_server(
const ObAddr& selected_server, ObIArray<ObPhyTableLocationInfo*>& phy_tbl_loc_info_list)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < phy_tbl_loc_info_list.count(); ++i) {
ObPhyTableLocationInfo* phy_tbl_loc_info = phy_tbl_loc_info_list.at(i);
if (OB_ISNULL(phy_tbl_loc_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("phy_tbl_loc_info is NULL", K(ret), K(i), K(phy_tbl_loc_info_list.count()));
} else {
ObPhyPartitionLocationInfoIArray& phy_part_loc_info_list =
phy_tbl_loc_info->get_phy_part_loc_info_list_for_update();
for (int64_t j = 0; OB_SUCC(ret) && j < phy_part_loc_info_list.count(); ++j) {
ObPhyPartitionLocationInfo& phy_part_loc_info = phy_part_loc_info_list.at(j);
if (phy_part_loc_info.has_selected_replica()) {
} else {
const ObIArray<ObRoutePolicy::CandidateReplica>& replica_loc_list =
phy_part_loc_info.get_partition_location().get_replica_locations();
bool replica_is_selected = false;
for (int64_t k = 0; OB_SUCC(ret) && !replica_is_selected && k < replica_loc_list.count(); ++k) {
if (selected_server == replica_loc_list.at(k).server_) {
if (OB_FAIL(phy_part_loc_info.set_selected_replica_idx(k))) {
LOG_WARN("fail to set selected replica idx", K(ret), K(k), K(phy_part_loc_info));
} else {
replica_is_selected = true;
}
}
}
if (OB_SUCC(ret) && OB_UNLIKELY(!replica_is_selected)) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("has no selected replica", K(ret), K(selected_server), K(replica_loc_list));
}
}
}
}
}
return ret;
}
int ObLogPlan::init_leading_info_from_joined_tables(TableItem* table)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(table)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null table item", K(ret));
} else if (!table->is_joined_table()) {
// do nothing
} else {
JoinedTable* joined_table = static_cast<JoinedTable*>(table);
LeadingInfo hint_info;
if (OB_FAIL(get_table_ids(table, hint_info.table_set_))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(get_table_ids(joined_table->left_table_, hint_info.left_table_set_))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(get_table_ids(joined_table->right_table_, hint_info.right_table_set_))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(leading_infos_.push_back(hint_info))) {
LOG_WARN("failed to push back hint info", K(ret));
} else if (OB_FAIL(SMART_CALL(init_leading_info_from_joined_tables(joined_table->left_table_)))) {
LOG_WARN("failed to get leading hint info", K(ret));
} else if (OB_FAIL(SMART_CALL(init_leading_info_from_joined_tables(joined_table->right_table_)))) {
LOG_WARN("failed to get leading hint info", K(ret));
}
}
return ret;
}
int ObLogPlan::init_leading_info_from_tables(
const ObIArray<TableItem*>& table_items, const ObIArray<SemiInfo*>& semi_infos)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < table_items.count(); ++i) {
TableItem* table = table_items.at(i);
LeadingInfo hint_info;
ObRelIds table_ids;
if (OB_FAIL(get_table_ids(table, table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(init_leading_info_from_joined_tables(table))) {
LOG_WARN("failed to get leading hint infos", K(ret));
} else if (i == 0) {
ret = leading_tables_.add_members(table_ids);
} else if (OB_FAIL(hint_info.left_table_set_.add_members(leading_tables_))) {
LOG_WARN("failed to add table ids", K(ret));
} else if (OB_FAIL(hint_info.right_table_set_.add_members(table_ids))) {
LOG_WARN("failed to add table ids", K(ret));
} else if (OB_FAIL(leading_tables_.add_members(table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(hint_info.table_set_.add_members(leading_tables_))) {
LOG_WARN("failed to add table ids", K(ret));
} else if (OB_FAIL(leading_infos_.push_back(hint_info))) {
LOG_WARN("failed to push back hint info", K(ret));
}
}
ObSqlBitSet<> right_rel_ids;
ObDMLStmt* stmt = get_stmt();
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null stmt", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < semi_infos.count(); ++i) {
SemiInfo* semi_info = semi_infos.at(i);
LeadingInfo hint_info;
right_rel_ids.reuse();
if (OB_ISNULL(semi_info)) {
LOG_WARN("unexpect null semi info", K(ret));
} else if (OB_FAIL(ObTransformUtils::get_table_rel_ids(*stmt, semi_info->right_table_id_, right_rel_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(hint_info.left_table_set_.add_members(leading_tables_))) {
LOG_WARN("failed to add table ids", K(ret));
} else if (OB_FAIL(hint_info.right_table_set_.add_members(right_rel_ids))) {
LOG_WARN("failed to add table ids", K(ret));
} else if (OB_FAIL(leading_tables_.add_members(right_rel_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(hint_info.table_set_.add_members(leading_tables_))) {
LOG_WARN("failed to add table ids", K(ret));
} else if (OB_FAIL(leading_infos_.push_back(hint_info))) {
LOG_WARN("failed to push back hint info", K(ret));
}
}
return ret;
}
int ObLogPlan::find_join_order_pair(
uint8_t beg_pos, uint8_t& end_pos, uint8_t ignore_beg_pos, uint8_t& ignore_end_pos, bool& found)
{
int ret = OB_SUCCESS;
ObDMLStmt* stmt = get_stmt();
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null stmt", K(ret));
} else {
const ObStmtHint& hint = stmt->get_stmt_hint();
const ObIArray<std::pair<uint8_t, uint8_t>>& join_order_pairs = hint.join_order_pairs_;
for (int64_t i = 0; i < join_order_pairs.count(); ++i) {
if (join_order_pairs.at(i).first == ignore_beg_pos && join_order_pairs.at(i).second == ignore_end_pos) {
// do nothing
} else if (join_order_pairs.at(i).second > ignore_end_pos) {
// do nothing
} else if (join_order_pairs.at(i).first == beg_pos) {
if (found && end_pos < join_order_pairs.at(i).second) {
end_pos = join_order_pairs.at(i).second;
} else if (!found) {
end_pos = join_order_pairs.at(i).second;
found = true;
}
}
}
}
return ret;
}
int ObLogPlan::get_table_ids_from_leading(uint8_t pos, ObRelIds& table_ids)
{
int ret = OB_SUCCESS;
ObDMLStmt* stmt = get_stmt();
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null stmt", K(ret));
} else {
int32_t id = OB_INVALID;
const ObStmtHint& hint = stmt->get_stmt_hint();
const ObIArray<uint64_t>& join_order_ids = hint.join_order_ids_;
if (pos >= join_order_ids.count()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect join order id", K(ret));
} else if ((id = stmt->get_table_bit_index(join_order_ids.at(pos))) == OB_INVALID) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid table id", K(ret));
} else if (OB_FAIL(table_ids.add_member(id))) {
LOG_WARN("failed to add table id", K(ret));
}
}
return ret;
}
int ObLogPlan::init_leading_info_from_leading_pair(uint8_t beg_pos, uint8_t end_pos, ObRelIds& table_set)
{
int ret = OB_SUCCESS;
uint8_t pair_end = 0;
for (int64_t i = beg_pos; OB_SUCC(ret) && i <= end_pos; ++i) {
LeadingInfo hint_info;
ObRelIds table_ids;
bool found = false;
if (OB_FAIL(find_join_order_pair(i, pair_end, beg_pos, end_pos, found))) {
LOG_WARN("failed to find join order pair", K(ret));
} else if (!found && OB_FAIL(get_table_ids_from_leading(i, table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (found && OB_FAIL(SMART_CALL(init_leading_info_from_leading_pair(i, pair_end, table_ids)))) {
LOG_WARN("failed to get leading hint info from leading pair", K(ret));
} else if (i == beg_pos) {
ret = table_set.add_members(table_ids);
} else if (OB_FAIL(hint_info.left_table_set_.add_members(table_set))) {
LOG_WARN("failed to add table ids", K(ret));
} else if (OB_FAIL(hint_info.right_table_set_.add_members(table_ids))) {
LOG_WARN("failed to add table ids", K(ret));
} else if (OB_FAIL(table_set.add_members(table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(hint_info.table_set_.add_members(table_set))) {
LOG_WARN("failed to add table ids", K(ret));
} else if (OB_FAIL(leading_infos_.push_back(hint_info))) {
LOG_WARN("failed to push back hint info", K(ret));
}
if (OB_SUCC(ret) && found) {
i = pair_end;
}
}
return ret;
}
int ObLogPlan::init_leading_info_from_leading()
{
int ret = OB_SUCCESS;
ObDMLStmt* stmt = get_stmt();
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null stmt", K(ret));
} else {
const ObStmtHint& hint = stmt->get_stmt_hint();
const ObIArray<uint64_t>& join_order_ids = hint.join_order_ids_;
if (join_order_ids.count() == 0) {
// do nothing
} else if (OB_FAIL(init_leading_info_from_leading_pair(0, join_order_ids.count() - 1, leading_tables_))) {
LOG_WARN("failed to get leading hint", K(ret));
}
}
return ret;
}
int ObLogPlan::init_leading_info(const ObIArray<TableItem*>& table_items, const ObIArray<SemiInfo*>& semi_infos)
{
int ret = OB_SUCCESS;
ObDMLStmt* stmt = get_stmt();
leading_tables_.reuse();
leading_infos_.reuse();
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null stmt", K(ret));
} else if (stmt->get_stmt_hint().join_ordered_) {
ret = init_leading_info_from_tables(table_items, semi_infos);
} else if (stmt->get_stmt_hint().join_order_ids_.count() > 0) {
ret = init_leading_info_from_leading();
}
if (OB_SUCC(ret)) {
LOG_TRACE("succeed to get leading infos", K(leading_tables_), K(leading_infos_));
}
return ret;
}
int ObLogPlan::init_bushy_tree_info(const ObIArray<TableItem*>& table_items)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < leading_infos_.count(); ++i) {
const LeadingInfo& info = leading_infos_.at(i);
if (info.left_table_set_.num_members() > 1 && info.right_table_set_.num_members() > 1) {
ret = bushy_tree_infos_.push_back(info.table_set_);
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < table_items.count(); ++i) {
if (OB_FAIL(init_bushy_tree_info_from_joined_tables(table_items.at(i)))) {
LOG_WARN("failed to init bushy tree info", K(ret));
}
}
if (OB_SUCC(ret)) {
LOG_TRACE("succeed to get bushy infos", K(bushy_tree_infos_));
}
return ret;
}
int ObLogPlan::init_bushy_tree_info_from_joined_tables(TableItem* table)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(table)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null table item", K(ret));
} else if (!table->is_joined_table()) {
// do nothing
} else {
JoinedTable* joined_table = static_cast<JoinedTable*>(table);
if (OB_ISNULL(joined_table->left_table_) || OB_ISNULL(joined_table->right_table_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null table item", K(ret));
} else if (joined_table->left_table_->is_joined_table() && joined_table->right_table_->is_joined_table()) {
ObRelIds table_ids;
if (OB_FAIL(get_table_ids(table, table_ids))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(bushy_tree_infos_.push_back(table_ids))) {
LOG_WARN("failed to push back table ids", K(ret));
}
}
if (OB_FAIL(ret)) {
// do nothing
} else if (OB_FAIL(SMART_CALL(init_bushy_tree_info_from_joined_tables(joined_table->left_table_)))) {
LOG_WARN("failed to init bushy tree infos", K(ret));
} else if (OB_FAIL(SMART_CALL(init_bushy_tree_info_from_joined_tables(joined_table->right_table_)))) {
LOG_WARN("failed to init bushy tree infos", K(ret));
}
}
return ret;
}
int ObLogPlan::check_need_bushy_tree(common::ObIArray<JoinOrderArray>& join_rels, const int64_t level, bool& need)
{
int ret = OB_SUCCESS;
need = false;
if (level >= join_rels.count()) {
ret = OB_INDEX_OUT_OF_RANGE;
LOG_WARN("Index out of range", K(ret), K(join_rels.count()), K(level));
} else if (join_rels.at(level).empty()) {
need = true;
}
for (int64_t i = 0; OB_SUCC(ret) && !need && i < bushy_tree_infos_.count(); ++i) {
const ObRelIds& table_ids = bushy_tree_infos_.at(i);
if (table_ids.num_members() != level + 1) {
// do nothing
} else {
bool has_generated = false;
int64_t N = join_rels.at(level).count();
for (int64_t j = 0; OB_SUCC(ret) && !has_generated && j < N; ++j) {
ObJoinOrder* join_order = join_rels.at(level).at(j);
if (OB_ISNULL(join_order)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null join order", K(ret));
} else if (table_ids.is_subset(join_order->get_tables())) {
has_generated = true;
}
}
if (OB_SUCC(ret)) {
need = !has_generated;
}
}
}
return ret;
}
int ObLogPlan::generate_join_levels_with_DP(common::ObIArray<JoinOrderArray>& join_rels, const int64_t join_level)
{
int ret = OB_SUCCESS;
if (!leading_tables_.is_empty() && OB_FAIL(inner_generate_join_levels_with_DP(join_rels, join_level, false))) {
LOG_WARN("failed to generate join levels with hint", K(ret));
} else if (1 == join_rels.at(join_level - 1).count()) {
} else if (OB_FAIL(inner_generate_join_levels_with_DP(join_rels, join_level, true))) {
LOG_WARN("failed to generate join level in generate_join_orders", K(ret), K(join_level));
}
return ret;
}
int ObLogPlan::generate_join_levels_with_linear(
common::ObIArray<JoinOrderArray>& join_rels, const ObIArray<TableItem*>& table_items, const int64_t join_level)
{
int ret = OB_SUCCESS;
if (OB_FAIL(preprocess_for_linear(table_items, join_rels))) {
LOG_WARN("failed to preprocess for linear", K(ret));
} else if (OB_FAIL(inner_generate_join_levels_with_linear(join_rels, join_level))) {
LOG_WARN("failed to generate join level in generate_join_orders", K(ret), K(join_level));
}
return ret;
}
int ObLogPlan::inner_generate_join_levels_with_DP(
common::ObIArray<JoinOrderArray>& join_rels, const int64_t join_level, bool ignore_hint)
{
int ret = OB_SUCCESS;
bool abort = false;
for (uint32_t base_level = 1; OB_SUCC(ret) && !abort && base_level < join_level; ++base_level) {
LOG_TRACE("start to generate one level join order with DP", K(base_level));
for (uint32_t i = 0; OB_SUCC(ret) && !abort && i <= base_level / 2; ++i) {
uint32_t right_level = i;
uint32_t left_level = base_level - 1 - right_level;
if (right_level > left_level) {
// do nothing
} else if (OB_FAIL(THIS_WORKER.check_status())) {
LOG_WARN("check status fail", K(ret));
} else if (OB_FAIL(generate_single_join_level_with_DP(
join_rels, left_level, right_level, base_level, ignore_hint, abort))) {
LOG_WARN("failed to generate join order with dynamic program", K(ret));
}
bool need_bushy = false;
if (OB_FAIL(ret) || right_level > left_level) {
} else if (abort) {
LOG_TRACE("abort generate join order", K(ret));
} else if (join_rels.count() <= base_level) {
ret = OB_INDEX_OUT_OF_RANGE;
LOG_WARN("Index out of range", K(ret), K(join_rels.count()), K(base_level));
} else if (OB_FAIL(check_need_bushy_tree(join_rels, base_level, need_bushy))) {
LOG_WARN("failed to check need bushy tree", K(ret));
} else if (need_bushy) {
LOG_TRACE("no valid ZigZag tree or leading hint required, we will enumerate bushy tree");
} else {
LOG_TRACE("there is valid ZigZag tree, we will not enumerate bushy tree");
break;
}
}
LOG_TRACE("succeed to generate on level join order", K(base_level), K(join_rels.at(base_level).count()));
}
return ret;
}
int ObLogPlan::inner_generate_join_levels_with_linear(
common::ObIArray<JoinOrderArray>& join_rels, const int64_t join_level)
{
int ret = OB_SUCCESS;
for (uint32_t base_level = 1; OB_SUCC(ret) && base_level < join_level; ++base_level) {
LOG_TRACE("start to generate one level join order with linear", K(base_level));
for (uint32_t i = 0; OB_SUCC(ret) && i <= base_level / 2; ++i) {
uint32_t right_level = i;
uint32_t left_level = base_level - 1 - right_level;
if (right_level > left_level) {
// do nothing
} else if (OB_FAIL(THIS_WORKER.check_status())) {
LOG_WARN("check status fail", K(ret));
} else if (OB_FAIL(generate_single_join_level_with_linear(join_rels, left_level, right_level, base_level))) {
LOG_WARN("failed to generate join order with linear", K(ret));
}
bool need_bushy = false;
if (OB_FAIL(ret) || right_level > left_level) {
} else if (join_rels.count() <= base_level) {
ret = OB_INDEX_OUT_OF_RANGE;
LOG_WARN("Index out of range", K(ret), K(join_rels.count()), K(base_level));
} else if (OB_FAIL(check_need_bushy_tree(join_rels, base_level, need_bushy))) {
LOG_WARN("failed to check need bushy tree", K(ret));
} else if (need_bushy) {
LOG_TRACE("no valid ZigZag tree or leading hint required, we will enumerate bushy tree");
} else {
LOG_TRACE("there is valid ZigZag tree, we will not enumerate bushy tree");
break;
}
}
LOG_TRACE("succeed to generate on level join order", K(base_level), K(join_rels.at(base_level).count()));
}
return ret;
}
int ObLogPlan::preprocess_for_linear(const ObIArray<TableItem*>& table_items, ObIArray<JoinOrderArray>& join_rels)
{
int ret = OB_SUCCESS;
if (join_rels.empty()) {
ret = OB_INDEX_OUT_OF_RANGE;
LOG_WARN("join_rels is empty", K(ret), K(join_rels.count()));
}
for (int64_t i = 0; OB_SUCC(ret) && i < table_items.count(); ++i) {
ObJoinOrder* join_tree = NULL;
if (OB_FAIL(generate_join_order_with_table_tree(join_rels, table_items.at(i), join_tree))) {
LOG_WARN("failed to generate join order", K(ret));
}
}
return ret;
}
int ObLogPlan::generate_join_order_with_table_tree(
ObIArray<JoinOrderArray>& join_rels, TableItem* table, ObJoinOrder*& join_tree)
{
int ret = OB_SUCCESS;
JoinedTable* joined_table = NULL;
ObJoinOrder* left_tree = NULL;
ObJoinOrder* right_tree = NULL;
join_tree = NULL;
if (OB_ISNULL(table) || join_rels.empty()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null param", K(ret));
} else if (!table->is_joined_table()) {
// find base join rels
ObIArray<ObJoinOrder*>& single_join_rels = join_rels.at(0);
for (int64_t i = 0; OB_SUCC(ret) && NULL == join_tree && i < single_join_rels.count(); ++i) {
ObJoinOrder* base_rel = single_join_rels.at(i);
if (OB_ISNULL(base_rel)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null base rel", K(ret));
} else if (table->table_id_ == base_rel->get_table_id()) {
join_tree = base_rel;
}
}
} else if (OB_FALSE_IT(joined_table = static_cast<JoinedTable*>(table))) {
} else if (OB_FAIL(
SMART_CALL(generate_join_order_with_table_tree(join_rels, joined_table->left_table_, left_tree)))) {
LOG_WARN("failed to generate join order", K(ret));
} else if (OB_FAIL(
SMART_CALL(generate_join_order_with_table_tree(join_rels, joined_table->right_table_, right_tree)))) {
LOG_WARN("failed to generate join order", K(ret));
} else if (OB_ISNULL(left_tree) || OB_ISNULL(right_tree)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null join order", K(ret));
} else {
bool is_valid_join = false;
ObRelIds cur_relids;
int64_t level = left_tree->get_tables().num_members() + right_tree->get_tables().num_members() - 1;
if (OB_FAIL(inner_generate_join_order(join_rels, left_tree, right_tree, level, false, false, is_valid_join))) {
LOG_WARN("failed to generated join order", K(ret));
} else if (OB_FAIL(cur_relids.add_members(left_tree->get_tables()))) {
LOG_WARN("fail to add left tree' table ids", K(ret));
} else if (OB_FAIL(cur_relids.add_members(right_tree->get_tables()))) {
LOG_WARN("fail to add right tree' table ids", K(ret));
} else if (OB_FAIL(find_join_rel(join_rels.at(level), cur_relids, join_tree))) {
LOG_WARN("find_join_rel fails", K(ret), K(level));
} else if (OB_ISNULL(join_tree)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null join order", K(ret));
}
}
return ret;
}
int ObLogPlan::generate_single_join_level_with_DP(ObIArray<JoinOrderArray>& join_rels, uint32_t left_level,
uint32_t right_level, uint32_t level, bool ignore_hint, bool& abort)
{
int ret = OB_SUCCESS;
abort = false;
if (join_rels.empty() || left_level >= join_rels.count() || right_level >= join_rels.count() ||
level >= join_rels.count()) {
ret = OB_INDEX_OUT_OF_RANGE;
LOG_WARN("Index out of range", K(ret), K(join_rels.count()), K(left_level), K(right_level), K(level));
} else {
ObIArray<ObJoinOrder*>& left_rels = join_rels.at(left_level);
ObIArray<ObJoinOrder*>& right_rels = join_rels.at(right_level);
ObJoinOrder* left_tree = NULL;
ObJoinOrder* right_tree = NULL;
for (int64_t i = 0; OB_SUCC(ret) && !abort && i < left_rels.count(); ++i) {
left_tree = left_rels.at(i);
if (OB_ISNULL(left_tree)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null join tree", K(ret));
} else {
for (int64_t j = 0; OB_SUCC(ret) && !abort && j < right_rels.count(); ++j) {
right_tree = right_rels.at(j);
bool match_hint = false;
bool is_legal = true;
bool is_strict_order = true;
bool is_valid_join = false;
if (OB_ISNULL(right_tree)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null join tree", K(ret));
} else if (!ignore_hint &&
OB_FAIL(check_join_hint(
left_tree->get_tables(), right_tree->get_tables(), match_hint, is_legal, is_strict_order))) {
LOG_WARN("failed to check join hint", K(ret));
} else if (!is_legal) {
LOG_TRACE("join order conflict with leading hint", K(left_tree->get_tables()), K(right_tree->get_tables()));
} else if (OB_FAIL(inner_generate_join_order(join_rels,
is_strict_order ? left_tree : right_tree,
is_strict_order ? right_tree : left_tree,
level,
match_hint,
!match_hint,
is_valid_join))) {
LOG_WARN("failed to generate join order", K(level), K(ret));
} else if (match_hint && !leading_tables_.is_subset(left_tree->get_tables()) && !is_valid_join) {
abort = true;
} else {
LOG_TRACE("succeed to check join order",
K(left_tree->get_tables()),
K(right_tree->get_tables()),
K(is_valid_join));
}
}
}
}
}
return ret;
}
int ObLogPlan::generate_single_join_level_with_linear(
ObIArray<JoinOrderArray>& join_rels, uint32_t left_level, uint32_t right_level, uint32_t level)
{
int ret = OB_SUCCESS;
if (join_rels.empty() || left_level >= join_rels.count() || right_level >= join_rels.count() ||
level >= join_rels.count()) {
ret = OB_INDEX_OUT_OF_RANGE;
LOG_WARN("Index out of range", K(ret), K(join_rels.count()), K(left_level), K(right_level), K(level));
} else {
ObIArray<ObJoinOrder*>& left_rels = join_rels.at(left_level);
ObIArray<ObJoinOrder*>& right_rels = join_rels.at(right_level);
ObJoinOrder* left_tree = NULL;
ObJoinOrder* right_tree = NULL;
if (OB_FAIL(sort_cur_rels(left_rels))) {
LOG_WARN("failed to sort rels", K(left_rels.count()), K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < left_rels.count() && join_rels.at(level).empty(); ++i) {
left_tree = left_rels.at(i);
for (int64_t j = 0; OB_SUCC(ret) && j < right_rels.count(); ++j) {
right_tree = right_rels.at(j);
bool is_valid_join = false;
if (OB_FAIL(inner_generate_join_order(join_rels, left_tree, right_tree, level, false, true, is_valid_join))) {
LOG_WARN("failed to generate join order", K(level), K(ret));
} else {
LOG_TRACE(
"succeed to check join order", K(left_tree->get_tables()), K(right_tree->get_tables()), K(is_valid_join));
}
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < left_rels.count() && join_rels.at(level).empty(); ++i) {
left_tree = left_rels.at(i);
for (int64_t j = 0; OB_SUCC(ret) && j < right_rels.count(); ++j) {
right_tree = right_rels.at(j);
bool is_valid_join = false;
if (OB_FAIL(inner_generate_join_order(join_rels, left_tree, right_tree, level, false, false, is_valid_join))) {
LOG_WARN("failed to generate join order", K(level), K(ret));
} else {
LOG_TRACE(
"succeed to check join order", K(left_tree->get_tables()), K(right_tree->get_tables()), K(is_valid_join));
}
}
}
}
return ret;
}
int ObLogPlan::inner_generate_join_order(ObIArray<JoinOrderArray>& join_rels, ObJoinOrder* left_tree,
ObJoinOrder* right_tree, uint32_t level, bool hint_force_order, bool delay_cross_product, bool& is_valid_join)
{
int ret = OB_SUCCESS;
is_valid_join = false;
if (join_rels.empty() || level >= join_rels.count() || OB_ISNULL(left_tree) || OB_ISNULL(right_tree)) {
ret = OB_INDEX_OUT_OF_RANGE;
LOG_WARN("Index out of range", K(ret), K(join_rels.count()), K(left_tree), K(right_tree), K(level));
} else {
ObSEArray<ConflictDetector*, 4> valid_detectors;
ObRelIds cur_relids;
JoinInfo join_info;
ObJoinOrder* join_tree = NULL;
bool is_strict_order = true;
if (left_tree->get_tables().overlap(right_tree->get_tables())) {
} else if (OB_FAIL(
choose_join_info(left_tree, right_tree, valid_detectors, delay_cross_product, is_strict_order))) {
LOG_WARN("failed to choose join info", K(ret));
} else if (valid_detectors.empty()) {
LOG_TRACE("there is no valid join info for ", K(left_tree->get_tables()), K(right_tree->get_tables()));
} else if (OB_FAIL(cur_relids.add_members(left_tree->get_tables()))) {
LOG_WARN("fail to add left tree' table ids", K(ret));
} else if (OB_FAIL(cur_relids.add_members(right_tree->get_tables()))) {
LOG_WARN("fail to add right tree' table ids", K(ret));
} else if (OB_FAIL(find_join_rel(join_rels.at(level), cur_relids, join_tree))) {
LOG_WARN("find_join_rel fails", K(ret), K(level));
} else if (OB_FAIL(merge_join_info(valid_detectors, join_info))) {
LOG_WARN("failed to merge join info", K(ret));
} else if (NULL != join_tree && level <= 1 && !hint_force_order) {
is_valid_join = true;
} else {
if (!is_strict_order) {
if (!hint_force_order) {
std::swap(left_tree, right_tree);
} else {
join_info.join_type_ = get_opposite_join_type(join_info.join_type_);
}
}
if (NULL == join_tree) {
if (OB_ISNULL(join_tree = create_join_order(JOIN))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("failed to create join tree", K(ret));
} else if (OB_FAIL(join_tree->init_join_order(left_tree, right_tree, &join_info))) {
LOG_WARN("failed to init join order", K(ret));
} else if (OB_FAIL(join_rels.at(level).push_back(join_tree))) {
LOG_WARN("failed to push back join order", K(ret));
}
}
if (OB_FAIL(ret)) {
// do nothing
} else if (OB_FAIL(join_tree->merge_conflict_detectors(left_tree, right_tree, valid_detectors))) {
LOG_WARN("failed to merge conflict detectors", K(ret));
} else if (OB_FAIL(join_tree->generate_join_paths(left_tree, right_tree, &join_info, hint_force_order))) {
LOG_WARN("failed to generate join paths for left_tree", K(level), K(ret));
} else {
is_valid_join = true;
LOG_TRACE("succeed to generate join order for ",
K(left_tree->get_tables()),
K(right_tree->get_tables()),
K(is_strict_order),
K(join_info));
}
}
}
return ret;
}
int ObLogPlan::is_detector_used(
ObJoinOrder* left_tree, ObJoinOrder* right_tree, ConflictDetector* detector, bool& is_used)
{
int ret = OB_SUCCESS;
is_used = false;
if (OB_ISNULL(left_tree) || OB_ISNULL(right_tree) || OB_ISNULL(detector)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null param", K(ret));
} else if (INNER_JOIN == detector->join_info_.join_type_ && detector->join_info_.where_condition_.empty()) {
} else if (ObOptimizerUtil::find_item(left_tree->get_conflict_detectors(), detector)) {
is_used = true;
} else if (ObOptimizerUtil::find_item(right_tree->get_conflict_detectors(), detector)) {
is_used = true;
}
return ret;
}
int ObLogPlan::choose_join_info(ObJoinOrder* left_tree, ObJoinOrder* right_tree,
ObIArray<ConflictDetector*>& valid_detectors, bool delay_cross_product, bool& is_strict_order)
{
int ret = OB_SUCCESS;
bool is_legal = false;
if (OB_ISNULL(left_tree) || OB_ISNULL(right_tree)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect empty conflict detectors", K(ret));
}
is_strict_order = true;
for (int64_t i = 0; OB_SUCC(ret) && i < conflict_detectors_.count(); ++i) {
ConflictDetector* detector = conflict_detectors_.at(i);
bool is_used = false;
if (OB_ISNULL(detector)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("conflict detector is null", K(ret));
} else if (OB_FAIL(is_detector_used(left_tree, right_tree, detector, is_used))) {
LOG_WARN("failed to check detector is used", K(ret));
} else if (is_used) {
// do nothing
} else if (OB_FAIL(check_join_legal(
left_tree->get_tables(), right_tree->get_tables(), detector, delay_cross_product, is_legal))) {
LOG_WARN("failed to check join legal", K(ret));
} else if (!is_legal) {
LOG_TRACE("left tree join right tree is not legal",
K(left_tree->get_tables()),
K(right_tree->get_tables()),
K(*detector));
if (OB_FAIL(check_join_legal(
right_tree->get_tables(), left_tree->get_tables(), detector, delay_cross_product, is_legal))) {
LOG_WARN("failed to check join legal", K(ret));
} else if (!is_legal) {
LOG_TRACE("right tree join left tree is not legal",
K(right_tree->get_tables()),
K(left_tree->get_tables()),
K(*detector));
} else if (OB_FAIL(valid_detectors.push_back(detector))) {
LOG_WARN("failed to push back detector", K(ret));
} else {
is_strict_order = false;
LOG_TRACE("succeed to find join info for ",
K(left_tree->get_tables()),
K(right_tree->get_tables()),
K(left_tree->get_conflict_detectors()),
K(right_tree->get_conflict_detectors()),
K(*detector));
}
} else if (OB_FAIL(valid_detectors.push_back(detector))) {
LOG_WARN("failed to push back detector", K(ret));
} else {
LOG_TRACE("succeed to find join info for ",
K(left_tree->get_tables()),
K(right_tree->get_tables()),
K(left_tree->get_conflict_detectors()),
K(right_tree->get_conflict_detectors()),
K(*detector));
}
}
return ret;
}
int ObLogPlan::check_join_info(
const ObIArray<ConflictDetector*>& valid_detectors, ObJoinType& join_type, bool& is_valid)
{
int ret = OB_SUCCESS;
ConflictDetector* detector = NULL;
bool has_non_inner_join = false;
is_valid = true;
join_type = INNER_JOIN;
if (valid_detectors.empty()) {
is_valid = false;
}
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < valid_detectors.count(); ++i) {
detector = valid_detectors.at(i);
if (OB_ISNULL(detector)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null detectors", K(ret));
} else if (INNER_JOIN == detector->join_info_.join_type_) {
// do nothing
} else if (has_non_inner_join) {
is_valid = false;
} else {
has_non_inner_join = true;
join_type = detector->join_info_.join_type_;
}
}
return ret;
}
int ObLogPlan::merge_join_info(const ObIArray<ConflictDetector*>& valid_detectors, JoinInfo& join_info)
{
int ret = OB_SUCCESS;
bool is_valid = false;
if (OB_FAIL(check_join_info(valid_detectors, join_info.join_type_, is_valid))) {
LOG_WARN("failed to check join info", K(ret));
} else if (!is_valid) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect different join info", K(valid_detectors), K(ret));
} else {
ConflictDetector* detector = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < valid_detectors.count(); ++i) {
detector = valid_detectors.at(i);
if (OB_ISNULL(detector)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null detectors", K(ret));
} else if (OB_FAIL(join_info.table_set_.add_members(detector->join_info_.table_set_))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(append_array_no_dup(join_info.where_condition_, detector->join_info_.where_condition_))) {
LOG_WARN("failed to append exprs", K(ret));
} else if (OB_FAIL(append_array_no_dup(join_info.on_condition_, detector->join_info_.on_condition_))) {
LOG_WARN("failed to append exprs", K(ret));
}
}
if (OB_SUCC(ret)) {
if (INNER_JOIN == join_info.join_type_) {
for (int64_t i = 0; OB_SUCC(ret) && i < join_info.where_condition_.count(); ++i) {
ObRawExpr* qual = join_info.where_condition_.at(i);
if (OB_ISNULL(qual)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null join qual", K(ret));
} else if (!qual->has_flag(IS_JOIN_COND)) {
// do nothing
} else if (OB_FAIL(join_info.equal_join_condition_.push_back(qual))) {
LOG_WARN("failed to push back join qual", K(ret));
}
}
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < join_info.on_condition_.count(); ++i) {
ObRawExpr* qual = join_info.on_condition_.at(i);
if (OB_ISNULL(qual)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null join qual", K(ret));
} else if (!qual->has_flag(IS_JOIN_COND)) {
// do nothing
} else if (OB_FAIL(join_info.equal_join_condition_.push_back(qual))) {
LOG_WARN("failed to push back join qual", K(ret));
}
}
}
}
}
return ret;
}
int ObLogPlan::distribute_onetime_subquery(ObRawExpr*& qual, bool& can_distribute)
{
int ret = OB_SUCCESS;
ObDMLStmt* stmt = get_stmt();
can_distribute = false;
ObRawExpr* new_qual = NULL;
if (OB_ISNULL(qual) || OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), K(qual), K(stmt));
} else if (!qual->has_flag(CNT_SUB_QUERY)) {
can_distribute = true;
} else if (OB_FAIL(check_qual_can_distribute(qual, stmt, can_distribute))) {
LOG_WARN("failed to check subquery can pushdown", K(ret));
} else if (!can_distribute) {
// do nothing
} else if (qual->get_relation_ids().is_empty()) {
can_distribute = false;
} else if (OB_FAIL(extract_params_for_subplan_filter(qual, new_qual))) {
LOG_WARN("failed to extract params for subplan filter", K(ret));
} else if (OB_ISNULL(new_qual)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null expr", K(ret));
} else if (OB_FAIL(new_qual->extract_info())) {
LOG_WARN("failed extract info", K(ret));
} else if (OB_FAIL(add_subquery_filter(new_qual))) {
LOG_WARN("failed to add expr", K(ret));
} else {
qual = new_qual;
}
return ret;
}
int ObLogPlan::distribute_subquery_qual(ObRawExpr*& qual, bool& can_distribute)
{
int ret = OB_SUCCESS;
bool is_semi_subquery = false;
can_distribute = false;
if (OB_ISNULL(qual)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), K(qual));
} else if (!qual->has_flag(CNT_SUB_QUERY)) {
can_distribute = true;
} else if (OB_FAIL(distribute_onetime_subquery(qual, can_distribute))) {
LOG_WARN("failed to check qual can pushdown", K(ret));
} else if (can_distribute) {
// do nothing
} else if (OB_FAIL(add_subquery_filter(qual))) {
LOG_WARN("failed to add expr", K(ret));
} else {
LOG_TRACE("succeed to distribute subquery qual", K(is_semi_subquery), K(can_distribute));
}
return ret;
}
int ObLogPlan::check_qual_can_distribute(ObRawExpr* qual, ObDMLStmt* stmt, bool& can_distribute)
{
int ret = OB_SUCCESS;
bool is_onetime_expr = false;
can_distribute = true;
if (OB_ISNULL(qual) || OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(qual), K(stmt), K(ret));
} else if (!qual->has_flag(CNT_SUB_QUERY)) {
// do nothing
} else if (OB_FAIL(ObOptimizerUtil::check_is_onetime_expr(get_onetime_exprs(), qual, stmt, is_onetime_expr))) {
LOG_WARN("failed to check is onetime expr", K(ret));
} else if (is_onetime_expr) {
// do nothing
} else if (!is_onetime_expr && qual->has_flag(IS_SUB_QUERY)) {
can_distribute = false;
} else {
for (int64_t i = 0; OB_SUCC(ret) && can_distribute && i < qual->get_param_count(); ++i) {
if (OB_FAIL(SMART_CALL(check_qual_can_distribute(qual->get_param_expr(i), stmt, can_distribute)))) {
LOG_WARN("failed to check qual can push down", K(ret));
}
}
}
return ret;
}
int ObLogPlan::extract_params_for_subplan_filter(ObRawExpr* expr, ObRawExpr*& new_expr)
{
int ret = OB_SUCCESS;
new_expr = expr;
ObDMLStmt* stmt = NULL;
ObOptimizerContext* opt_ctx = NULL;
bool is_onetime_expr = false;
if (OB_ISNULL(expr) || OB_ISNULL(stmt = get_stmt()) || OB_ISNULL(opt_ctx = &get_optimizer_context())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("get unexpected null", K(expr), K(stmt), K(opt_ctx), K(ret));
} else if (expr->has_flag(CNT_SUB_QUERY) &&
OB_FAIL(ObOptimizerUtil::check_is_onetime_expr(get_onetime_exprs(), expr, stmt, is_onetime_expr))) {
LOG_WARN("failed to check is onetime expr", K(ret));
} else if (is_onetime_expr) {
ObSQLSessionInfo* session_info = const_cast<ObSQLSessionInfo*>(opt_ctx->get_session_info());
int64_t param_num = ObOptimizerUtil::find_exec_param(get_onetime_exprs(), expr);
if (param_num >= 0) {
ObRawExpr* param_expr = ObOptimizerUtil::find_param_expr(stmt->get_exec_param_ref_exprs(), param_num);
if (param_expr != NULL) {
new_expr = param_expr;
}
} else {
std::pair<int64_t, ObRawExpr*> init_expr;
if (OB_FAIL(ObRawExprUtils::create_exec_param_expr(
stmt, opt_ctx->get_expr_factory(), new_expr, session_info, init_expr))) {
LOG_WARN("create param for stmt error", K(ret));
} else if (OB_FAIL(onetime_exprs_.push_back(init_expr))) {
LOG_WARN("push back error", K(ret));
}
}
} else if (expr->has_flag(CNT_SUB_QUERY)) {
ObRawExpr::ExprClass expr_class = expr->get_expr_class();
switch (expr_class) {
case ObRawExpr::EXPR_QUERY_REF: {
break;
}
case ObRawExpr::EXPR_CASE_OPERATOR: {
ObCaseOpRawExpr* case_expr = NULL;
if (OB_FAIL(opt_ctx->get_expr_factory().create_raw_expr(expr->get_expr_type(), case_expr))) {
LOG_WARN("create case operator expr failed", K(ret));
} else if (OB_ISNULL(new_expr = case_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("case_expr is null", K(case_expr));
} else {
ret = case_expr->assign(static_cast<ObCaseOpRawExpr&>(*expr));
if (OB_SUCC(ret)) {
case_expr->clear_child();
if (OB_FAIL(extract_params_for_subplan_expr(new_expr, expr))) {
LOG_WARN("failed to extract child expr info", K(ret), K(*new_expr));
} else { /*do nothing*/
}
}
}
break;
}
case ObRawExpr::EXPR_AGGR: {
ObAggFunRawExpr* aggr_expr = NULL;
if (OB_FAIL(opt_ctx->get_expr_factory().create_raw_expr(expr->get_expr_type(), aggr_expr))) {
LOG_WARN("create aggr expr failed", K(ret));
} else if (OB_ISNULL(new_expr = aggr_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("aggr_expr is null", K(aggr_expr));
} else {
ret = aggr_expr->assign(static_cast<ObAggFunRawExpr&>(*expr));
if (OB_SUCC(ret)) {
aggr_expr->clear_child();
if (OB_FAIL(extract_params_for_subplan_expr(new_expr, expr))) {
LOG_WARN("failed to extract child expr info", K(ret), K(*new_expr));
} else { /*do nothing*/
}
}
}
break;
}
case ObRawExpr::EXPR_SYS_FUNC: {
ObSysFunRawExpr* func_expr = NULL;
if (OB_FAIL(opt_ctx->get_expr_factory().create_raw_expr(expr->get_expr_type(), func_expr))) {
LOG_WARN("create system function expr failed", K(ret));
} else if (OB_ISNULL(new_expr = func_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("func_expr is null", K(func_expr));
} else {
ret = func_expr->assign(static_cast<ObSysFunRawExpr&>(*expr));
if (OB_SUCC(ret)) {
func_expr->clear_child();
if (OB_FAIL(extract_params_for_subplan_expr(new_expr, expr))) {
LOG_WARN("failed to extract child expr info", K(ret), K(*new_expr));
} else { /*do nothing*/
}
}
}
break;
}
case ObRawExpr::EXPR_UDF: {
ret = OB_NOT_SUPPORTED;
break;
}
case ObRawExpr::EXPR_OPERATOR: {
ObOpRawExpr* op_expr = NULL;
if (OB_FAIL(opt_ctx->get_expr_factory().create_raw_expr(expr->get_expr_type(), op_expr))) {
LOG_WARN("create operator expr failed", K(ret));
} else if (OB_ISNULL(new_expr = op_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("op_expr is null", K(op_expr));
} else {
ret = op_expr->assign(static_cast<ObOpRawExpr&>(*expr));
if (OB_SUCC(ret)) {
op_expr->clear_child();
if (OB_FAIL(extract_params_for_subplan_expr(new_expr, expr))) {
LOG_WARN("failed to extract child expr info", K(ret), K(*new_expr));
} else { /*do nothing*/
}
}
}
break;
}
case ObRawExpr::EXPR_INVALID_CLASS:
default:
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid expr class", K(expr_class), K(ret));
// should not reach here
break;
} // switch case end
}
return ret;
}
int ObLogPlan::extract_params_for_subplan_expr(ObRawExpr*& new_expr, ObRawExpr* expr)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(new_expr) || OB_ISNULL(expr)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("get unexpected null", K(new_expr), K(expr), K(ret));
} else {
int64_t count = expr->get_param_count();
for (int64_t i = 0; OB_SUCC(ret) && i < count; ++i) {
ObRawExpr* expr_element = expr->get_param_expr(i);
if (OB_ISNULL(expr_element)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("null poiner passed in", K(i), K(expr_element), K(ret));
} else if (!expr_element->has_flag(CNT_SUB_QUERY)) {
if (OB_FAIL(ObOptimizerUtil::add_parameterized_expr(new_expr, expr, expr_element, i))) {
LOG_WARN("fail to push raw expr", K(ret), K(new_expr));
} else { /*do nothing*/
}
} else {
ObRawExpr* dest_element = NULL;
// recursive to child expr extract params
if (OB_FAIL(SMART_CALL(extract_params_for_subplan_filter(expr_element, dest_element)))) {
LOG_WARN("failed to extract params", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::add_parameterized_expr(new_expr, expr, dest_element, i))) {
LOG_WARN("fail to push raw expr", K(ret), K(new_expr));
} else { /*do nothing*/
}
}
}
}
return ret;
}
int ObLogPlan::try_split_or_qual(const ObRelIds& table_ids, ObOpRawExpr& or_qual, ObIArray<ObRawExpr*>& table_quals)
{
int ret = OB_SUCCESS;
ObOpRawExpr* new_expr = NULL;
if (OB_FAIL(
ObOptimizerUtil::split_or_qual_on_table(get_stmt(), get_optimizer_context(), table_ids, or_qual, new_expr))) {
LOG_WARN("failed to split or qual on table", K(ret));
} else if (NULL == new_expr) {
/* do nothing */
} else if (new_expr->get_relation_ids().num_members() > 1) {
// do nothing
} else if (ObOptimizerUtil::find_equal_expr(table_quals, new_expr)) {
/* do nothing */
} else if (OB_FAIL(table_quals.push_back(new_expr))) {
LOG_WARN("failed to push back new expr", K(ret));
}
return ret;
}
int ObLogPlan::generate_subplan(ObRawExpr*& expr)
{
int ret = OB_SUCCESS;
ObArray<ObQueryRefRawExpr*> query_refs;
if (OB_ISNULL(expr) || OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), K(expr), K(get_stmt()));
} else if (OB_FAIL(get_query_ref_in_expr_tree(expr, get_stmt()->get_current_level(), query_refs))) {
LOG_WARN("get query reference in expr tree failed", K(ret));
} else {
LOG_TRACE("number of subquery ref", K(query_refs.count()), K(get_stmt()->get_current_level()));
}
for (int64_t i = 0; OB_SUCC(ret) && i < query_refs.count(); ++i) {
if (OB_FAIL(generate_subplan_for_query_ref(query_refs.at(i)))) {
LOG_WARN("generate subplan for query ref failed", K(ret));
} else {
LOG_TRACE("succeed to generate subplan for query ref", K(get_stmt()->get_current_level()), K(query_refs.at(i)));
}
}
return ret;
}
int ObLogPlan::generate_subplan_for_query_ref(ObQueryRefRawExpr* query_ref)
{
int ret = OB_SUCCESS;
// check if sub plan has been generated
SubPlanInfo* subplan_info = NULL;
ObOptimizerContext& opt_ctx = get_optimizer_context();
if (OB_FAIL(get_subplan(query_ref, subplan_info))) {
LOG_WARN("get_subplan() fails", K(ret));
} else if (NULL == subplan_info && query_ref->is_ref_stmt()) {
ObSelectStmt* subquery = query_ref->get_ref_stmt();
if (NULL != subquery) {
ObArray<std::pair<int64_t, ObRawExpr*>> exec_params;
ObLogPlan* logical_plan = NULL;
if (OB_ISNULL(logical_plan = opt_ctx.get_log_plan_factory().create(opt_ctx, *subquery))) {
LOG_WARN("failed to create plan", K(ret), K(subquery->get_sql_stmt()));
} else if (OB_FAIL(logical_plan->init_plan_info())) {
LOG_WARN("failed to init equal sets", K(ret));
} else if (OB_FAIL(
logical_plan->extract_params_for_subplan_in_stmt(get_stmt()->get_current_level(), exec_params))) {
LOG_WARN("failed to extract params from subplan", K(ret));
} else if (OB_FAIL(static_cast<ObSelectLogPlan*>(logical_plan)->generate_raw_plan())) {
LOG_WARN("failed to optimize sub-select", K(ret));
} else {
SubPlanInfo* info = static_cast<SubPlanInfo*>(get_allocator().alloc(sizeof(SubPlanInfo)));
bool has_ref_assign_user_var = false;
if (OB_ISNULL(info)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("failed to alloc semi info", K(ret));
} else if (OB_FAIL(subquery->has_ref_assign_user_var(has_ref_assign_user_var))) {
LOG_WARN("faield to check stmt has assignment ref user var", K(ret));
} else {
bool is_initplan = exec_params.empty() && !has_ref_assign_user_var;
info = new (info) SubPlanInfo(query_ref, logical_plan, is_initplan);
if (OB_FAIL(info->add_sp_params(exec_params))) {
LOG_WARN("failed to add sp params to SubPlanInfo", K(ret));
} else if (OB_FAIL(add_subplan(info))) {
LOG_WARN("failed to add sp params to rel", K(ret));
} else {
query_ref->set_ref_id(get_subplan_size() - 1);
query_ref->set_ref_operator(logical_plan->get_plan_root());
logical_plan->set_query_ref(query_ref);
LOG_TRACE("succ to generate logical plan of sub-select");
}
}
if (OB_FAIL(ret) && NULL != info) {
info->subplan_ = NULL; // we leave logical plan to be freed later
info->~SubPlanInfo();
info = NULL;
} else { /* Do nothing */
}
}
} else { /* Do nothing */
}
} else { /* Do nothing */
}
return ret;
}
int ObLogPlan::get_query_ref_in_expr_tree(
ObRawExpr* expr, int32_t expr_level, ObIArray<ObQueryRefRawExpr*>& query_refs) const
{
int ret = OB_SUCCESS;
bool is_stack_overflow = false;
if (OB_ISNULL(expr)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("root is null");
} else if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
LOG_WARN("check stack overflow failed", K(ret));
} else if (is_stack_overflow) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("too deep recursive", K(ret));
} else if (!expr->has_flag(CNT_SUB_QUERY)) {
/*do nothing if no subquery*/
} else if (expr->is_query_ref_expr()) {
ObQueryRefRawExpr* query_ref = static_cast<ObQueryRefRawExpr*>(expr);
if (query_ref->get_ref_stmt() != NULL) {
if (query_ref->get_expr_level() == expr_level) {
if (OB_FAIL(query_refs.push_back(query_ref))) {
LOG_WARN("add query ref to array failed", K(ret));
} else {
LOG_TRACE("subquery belong to current level", K(query_ref), K(expr_level), K(*query_ref));
}
} else {
LOG_TRACE("subquery does not belong to current level",
K(expr_level),
K(query_ref->get_expr_level()),
K(query_ref),
K(*query_ref));
}
}
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
if (OB_FAIL(SMART_CALL(get_query_ref_in_expr_tree(expr->get_param_expr(i), expr_level, query_refs)))) {
LOG_WARN("get query reference in expr tree", K(ret));
}
}
}
return ret;
}
int ObLogPlan::extract_params_for_subplan_in_stmt(
const int32_t level, ObIArray<std::pair<int64_t, ObRawExpr*>>& exec_params)
{
int ret = OB_SUCCESS;
ret = resolve_unsolvable_exprs(level, get_stmt(), exec_params);
return ret;
}
int ObLogPlan::resolve_unsolvable_exprs(
const int32_t level, ObDMLStmt* stmt, ObIArray<std::pair<int64_t, ObRawExpr*>>& params)
{
int ret = OB_SUCCESS;
bool is_stack_overflow = false;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), K(stmt));
} else if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
LOG_WARN("check stack overflow failed", K(ret));
} else if (is_stack_overflow) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("too deep recursive", K(ret));
} else {
ObArray<ObSelectStmt*> child_stmts;
if (OB_FAIL(extract_stmt_params(stmt, level, params))) {
LOG_WARN("fail to extract param from raw expr", K(ret));
} else if (OB_FAIL(stmt->get_child_stmts(child_stmts))) {
LOG_WARN("get child stmt failed", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < child_stmts.count(); ++i) {
if (OB_FAIL(SMART_CALL(resolve_unsolvable_exprs(level, child_stmts.at(i), params)))) {
LOG_WARN("fail to extract param from child stmts", K(ret));
} else { /* Do nothing */
}
}
}
}
return ret;
}
int ObLogPlan::extract_stmt_params(
ObDMLStmt* stmt, const int32_t level, ObIArray<std::pair<int64_t, ObRawExpr*>>& params)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(stmt));
} else if (stmt->get_current_level() <= level) {
} else if (!stmt->is_select_stmt()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Invalid SubQuery type", K(ret), K(stmt->get_stmt_type()));
} else {
ObSelectStmt* select_stmt = static_cast<ObSelectStmt*>(stmt);
// 1, Select Clause
for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_select_item_size(); ++i) {
if (OB_FAIL(extract_params(select_stmt->get_select_item(i).expr_, level, params))) {
LOG_WARN("fail to resolve ref param for select clause", K(ret));
} else { /* Do nothing */
}
}
// 2.1, join table
if (OB_SUCC(ret) && select_stmt->get_joined_tables().count() > 0) {
for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_joined_tables().count(); ++i) {
JoinedTable* join_table = select_stmt->get_joined_tables().at(i);
if (OB_ISNULL(join_table)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("join_table is null", K(ret));
} else if (OB_FAIL(extract_join_table_condition_params(*join_table, level, params))) {
LOG_WARN("extract join table condition params failed", K(ret));
} else { /* Do nothing */
}
}
} else { /* Do nothing */
}
// 2.2, semi info
if (OB_SUCC(ret) && select_stmt->get_semi_info_size() > 0) {
ObIArray<SemiInfo*>& semi_infos = select_stmt->get_semi_infos();
for (int64_t i = 0; OB_SUCC(ret) && i < semi_infos.count(); ++i) {
if (OB_ISNULL(semi_infos.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(semi_infos));
} else if (OB_FAIL(extract_params(semi_infos.at(i)->semi_conditions_, level, params))) {
LOG_WARN("extract semi condition params failed", K(ret));
} else { /* Do nothing */
}
}
} else { /* Do nothing */
}
// 3, Where Clause
if (OB_SUCC(ret)) {
ret = extract_params(select_stmt->get_condition_exprs(), level, params);
} else { /* Do nothing */
}
// 4.1, Group Clause
if (OB_SUCC(ret)) {
ret = extract_params(select_stmt->get_group_exprs(), level, params);
}
// 4.2, Rollup Clause
if (OB_SUCC(ret)) {
ret = extract_params(select_stmt->get_rollup_exprs(), level, params);
}
// 4.3, Agg Clause aggregate expr
for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_aggr_item_size(); ++i) {
ObRawExpr* aggr_expr = select_stmt->get_aggr_item(i);
ret = extract_params(aggr_expr, level, params);
}
// 5, Having Clause
if (OB_SUCC(ret)) {
ret = extract_params(select_stmt->get_having_exprs(), level, params);
} else { /* Do nothing */
}
// 6, Order Clause
for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_order_item_size(); ++i) {
ret = extract_params(select_stmt->get_order_item(i).expr_, level, params);
}
// 7, Limit Clause
if (OB_SUCC(ret) && select_stmt->get_limit_expr()) {
ret = extract_params(select_stmt->get_limit_expr(), level, params);
} else { /* Do nothing */
}
if (OB_SUCC(ret) && select_stmt->get_offset_expr()) {
ret = extract_params(select_stmt->get_offset_expr(), level, params);
} else { /* Do nothing */
}
// 8, start with Clause
if (OB_SUCC(ret)) {
ret = extract_params(select_stmt->get_start_with_exprs(), level, params);
} else { /* Do nothing */
}
// 9. connect_by_prior exprs
if (OB_SUCC(ret)) {
ret = extract_params(select_stmt->get_connect_by_prior_exprs(), level, params);
} else { /* Do nothing */
}
if (OB_SUCC(ret)) {
ret = extract_params(get_rownum_exprs(), level, params);
} else { /* Do nothing */
}
}
return ret;
}
int ObLogPlan::extract_join_table_condition_params(
JoinedTable& join_table, int32_t level, ObIArray<std::pair<int64_t, ObRawExpr*>>& params)
{
int ret = OB_SUCCESS;
bool is_stack_overflow = false;
if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
LOG_WARN("check stack overflow failed", K(ret));
} else if (is_stack_overflow) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("too deep recursive", K(ret));
} else if (OB_FAIL(extract_params(join_table.join_conditions_, level, params))) {
LOG_WARN("extract join condition params failed", K(ret));
} else {
if (NULL != join_table.left_table_ && TableItem::JOINED_TABLE == join_table.left_table_->type_) {
JoinedTable& left_table = *static_cast<JoinedTable*>(join_table.left_table_);
if (OB_FAIL(SMART_CALL(extract_join_table_condition_params(left_table, level, params)))) {
LOG_WARN("extract left join table condition param failed", K(ret));
} else { /* Do nothing */
}
} else { /* Do nothing */
}
if (OB_SUCC(ret) && NULL != join_table.right_table_ && TableItem::JOINED_TABLE == join_table.right_table_->type_) {
JoinedTable& right_table = *static_cast<JoinedTable*>(join_table.right_table_);
if (OB_FAIL(SMART_CALL(extract_join_table_condition_params(right_table, level, params)))) {
LOG_WARN("extract right join table condition param failed", K(ret));
} else { /* Do nothing */
}
} else { /* Do nothing */
}
}
return ret;
}
int ObLogPlan::extract_params(
common::ObIArray<ObRawExpr*>& exprs, const int32_t level, ObIArray<std::pair<int64_t, ObRawExpr*>>& params)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < exprs.count(); ++i) {
if (OB_FAIL(extract_params(exprs.at(i), level, params))) {
LOG_WARN("extract expr params failed", K(ret));
} else { /* Do nothing */
}
}
return ret;
}
int ObLogPlan::extract_params(ObRawExpr*& expr, const int32_t level, ObIArray<std::pair<int64_t, ObRawExpr*>>& params)
{
int ret = OB_SUCCESS;
bool is_stack_overflow = false;
bool can_produce = false;
if (OB_ISNULL(expr) || OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), KP(expr), KP(get_stmt()));
} else if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
LOG_WARN("check stack overflow failed", K(ret));
} else if (is_stack_overflow) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("too deep recursive", K(ret));
} else if (!expr->get_expr_levels().has_member(level) && !expr->is_set_op_expr()) {
// do nothing
} else if (OB_FAIL(can_produce_by_upper_stmt(expr, level, can_produce))) {
LOG_WARN("failed to check expr can produce by stmt", K(ret));
} else if (can_produce) {
if (OB_FAIL(extract_param_for_generalized_column(expr, params))) {
LOG_WARN("extract param for generalized column failed", K(ret));
}
} else {
int64_t count = expr->get_param_count();
for (int64_t i = 0; OB_SUCC(ret) && i < count; ++i) {
if (OB_ISNULL(expr->get_param_expr(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expr->get_param_expr(i) returns null", K(ret), K(i));
} else if (OB_FAIL(SMART_CALL(extract_params(expr->get_param_expr(i), level, params)))) {
LOG_WARN("fail to extract param from raw expr", K(ret), K(expr->get_param_expr(i)));
} else { /* Do nothing */
}
}
}
if (OB_SUCC(ret) && OB_FAIL(expr->extract_info())) {
LOG_WARN("failed to extract expr info", K(ret));
}
return ret;
}
int ObLogPlan::can_produce_by_upper_stmt(ObRawExpr* expr, const int32_t stmt_level, bool& can_produce)
{
int ret = OB_SUCCESS;
can_produce = false;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null expr", K(ret));
} else if (expr->get_expr_level() == stmt_level || expr->is_const_expr()) {
can_produce = true;
} else if (ObOptimizerUtil::has_psedu_column(*expr) || ObOptimizerUtil::has_hierarchical_expr(*expr) ||
expr->is_set_op_expr() || expr->has_flag(IS_AGG) || expr->has_flag(IS_WINDOW_FUNC) ||
T_OP_ROW == expr->get_expr_type()) {
can_produce = false;
} else if (expr->get_param_count() > 0) {
can_produce = true;
int64_t count = expr->get_param_count();
for (int64_t i = 0; OB_SUCC(ret) && can_produce && i < count; ++i) {
if (OB_ISNULL(expr->get_param_expr(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expr->get_param_expr(i) returns null", K(ret), K(i));
} else if (OB_FAIL(SMART_CALL(can_produce_by_upper_stmt(expr->get_param_expr(i), stmt_level, can_produce)))) {
LOG_WARN("fail to check expr can produce by stmt", K(ret), K(expr->get_param_expr(i)));
} else { /* Do nothing */
}
}
}
return ret;
}
int ObLogPlan::extract_param_for_generalized_column(
ObRawExpr*& general_expr, ObIArray<std::pair<int64_t, ObRawExpr*>>& params)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(general_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("general expr is null");
} else {
int64_t param_num = ObOptimizerUtil::find_exec_param(params, general_expr);
if (param_num >= 0) {
// stmt all_exprs contain all questionmark exprs
ObRawExpr* param_expr = ObOptimizerUtil::find_param_expr(get_stmt()->get_exec_param_ref_exprs(), param_num);
if (NULL != param_expr) {
general_expr = param_expr;
} else { /* Do nothing */
}
} else {
std::pair<int64_t, ObRawExpr*> init_expr;
if (OB_FAIL(ObRawExprUtils::create_exec_param_expr(
get_stmt(), optimizer_context_.get_expr_factory(), general_expr, NULL, init_expr))) {
LOG_WARN("create param for stmt error in extract_params_for_nl", K(ret));
} else if (OB_FAIL(params.push_back(init_expr))) {
LOG_WARN("push back error", K(ret));
} else { /*do nothing*/
}
}
}
return ret;
}
int ObLogPlan::get_subplan(const ObRawExpr* expr, SubPlanInfo*& info)
{
int ret = OB_SUCCESS;
info = NULL;
bool found = false;
for (int64_t i = 0; OB_SUCC(ret) && !found && i < get_subplans().count(); ++i) {
if (OB_ISNULL(get_subplans().at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get_subplans().at(i) returns null", K(ret), K(i));
} else if (get_subplans().at(i)->init_expr_ == expr) {
info = get_subplans().at(i);
found = true;
} else { /* Do nothing */
}
}
return ret;
}
int ObLogPlan::get_subplan_info(const ObRawExpr* expr, ObIArray<SubPlanInfo*>& subplans)
{
int ret = OB_SUCCESS;
bool is_stack_overflow = false;
if (OB_ISNULL(expr)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid raw expr", K(ret), K(expr));
} else if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
LOG_WARN("check stack overflow failed", K(ret));
} else if (is_stack_overflow) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("too deep recursive", K(ret));
} else {
if (expr->is_query_ref_expr()) {
SubPlanInfo* info = NULL;
if (OB_FAIL(get_subplan(expr, info))) {
LOG_WARN("get_subplan() fails", K(ret));
} else if (NULL != info) {
ret = subplans.push_back(info);
} else { /* Do nothing */
}
} else if (expr->is_const_expr()) {
if (expr->has_flag(IS_PARAM)) {
int64_t param_value = static_cast<const ObConstRawExpr*>(expr)->get_value().get_unknown();
ObRawExpr* init_expr = NULL;
if (NULL == (init_expr = ObOptimizerUtil::find_exec_param(get_onetime_exprs(), param_value))) {
} else {
ret = SMART_CALL(get_subplan_info(init_expr, subplans));
}
} else { /* Do nothing */
}
} else {
int64_t N = expr->get_param_count();
for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
if (expr->get_param_expr(i)->has_flag(CNT_SUB_QUERY) || expr->get_param_expr(i)->has_flag(CNT_PARAM)) {
ret = SMART_CALL(get_subplan_info(expr->get_param_expr(i), subplans));
}
}
}
}
return ret;
}
int ObLogPlan::find_base_rel(ObIArray<ObJoinOrder*>& base_level, int64_t table_idx, ObJoinOrder*& base_rel)
{
int ret = OB_SUCCESS;
ObJoinOrder* cur_rel = NULL;
bool find = false;
base_rel = NULL;
for (int64_t i = 0; OB_SUCC(ret) && !find && i < base_level.count(); ++i) {
if (OB_ISNULL(cur_rel = base_level.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(cur_rel));
} else if (cur_rel->get_tables().has_member(table_idx)) {
find = true;
base_rel = cur_rel;
LOG_TRACE("succeed to find base rel", K(cur_rel->get_tables()), K(table_idx));
} else { /* do nothing */
}
}
return ret;
}
int ObLogPlan::find_join_rel(ObIArray<ObJoinOrder*>& join_level, ObRelIds& relids, ObJoinOrder*& join_rel)
{
int ret = OB_SUCCESS;
join_rel = NULL;
ObJoinOrder* cur_rel = NULL;
int32_t i = 0;
bool found = false;
for (i = 0; OB_SUCC(ret) && !found && i < join_level.count(); ++i) {
cur_rel = join_level.at(i);
if (OB_ISNULL(cur_rel)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("cur_rel is null", K(ret), K(cur_rel));
} else if (cur_rel->get_tables().equal(relids)) {
join_rel = cur_rel;
LOG_TRACE("join rel is found");
found = true;
} else { /* Do nothing */
}
}
return ret;
}
int ObLogPlan::sort_cur_rels(ObIArray<ObJoinOrder*>& cur_rels)
{
int ret = OB_SUCCESS;
int64_t N = cur_rels.count();
bool swap = true;
for (int64_t i = 0; OB_SUCC(ret) && swap && i < N; ++i) {
swap = false;
for (int64_t j = 0; OB_SUCC(ret) && j < N - 1 - i; ++j) {
if (OB_ISNULL(cur_rels.at(j)) || OB_ISNULL(cur_rels.at(j + 1))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("rel is null", K(cur_rels), K(ret));
} else if (cur_rels.at(j)->get_output_rows() > cur_rels.at(j + 1)->get_output_rows()) {
ObJoinOrder* tmp = cur_rels.at(j);
cur_rels.at(j) = cur_rels.at(j + 1);
cur_rels.at(j + 1) = tmp;
swap = true;
} else { /*do nothing*/
}
}
}
return ret;
}
int ObLogPlan::allocate_function_table_path(AccessPath* ap, ObLogicalOperator*& out_access_path_op)
{
int ret = OB_SUCCESS;
ObLogFunctionTable* op = NULL;
if (OB_ISNULL(op = static_cast<ObLogFunctionTable*>(get_log_op_factory().allocate(*this, LOG_FUNCTION_TABLE)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("allocate memory for ObLogFunctionTableScan failed", K(ret));
} else {
const TableItem* table_item = NULL;
CK(OB_NOT_NULL(get_stmt()));
CK(OB_NOT_NULL(table_item = get_stmt()->get_table_item_by_id(ap->get_table_id())));
CK(OB_NOT_NULL(table_item));
CK(table_item->is_function_table());
CK(OB_NOT_NULL(table_item->function_table_expr_));
if (OB_SUCC(ret) && table_item->function_table_expr_->has_flag(CNT_SUB_QUERY)) {
ObLogExprValues* values_op = NULL;
if (OB_ISNULL(values_op = static_cast<ObLogExprValues*>(log_op_factory_.allocate(*this, LOG_EXPR_VALUES)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("Allocate memory for ObLogInsertValues failed", K(ret));
} else {
values_op->set_card(1);
values_op->set_cost(ObOptEstCost::get_cost_params().CPU_TUPLE_COST);
values_op->set_op_cost(values_op->get_cost());
values_op->set_est_sel_info(&get_est_sel_info());
values_op->set_need_columnlized(true);
op->add_child(values_op);
}
ObArray<ObRawExpr*> subquery_exprs;
OZ(subquery_exprs.push_back(table_item->function_table_expr_));
OZ(allocate_subplan_filter_as_below(subquery_exprs, op));
}
if (OB_SUCC(ret)) {
// compute property anyway
OX(op->add_values_expr(table_item->function_table_expr_));
OX(op->set_table_id(ap->get_table_id()));
OZ(append(op->get_filter_exprs(), ap->filter_));
if (OB_FAIL(op->compute_property(ap))) {
LOG_WARN("failed to compute property", K(ret));
}
}
OX(out_access_path_op = op);
}
return ret;
}
int ObLogPlan::allocate_temp_table_path(AccessPath* ap, ObLogicalOperator*& out_access_path_op)
{
int ret = OB_SUCCESS;
const TableItem* table_item = NULL;
ObLogTempTableAccess* op = NULL;
if (OB_ISNULL(ap) || OB_ISNULL(get_stmt()) ||
OB_ISNULL(table_item = get_stmt()->get_table_item_by_id(ap->get_table_id()))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ap), K(get_stmt()), K(table_item), K(ret));
} else if (OB_ISNULL(
op = static_cast<ObLogTempTableAccess*>(log_op_factory_.allocate(*this, LOG_TEMP_TABLE_ACCESS)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("allocate memory for ObLogFunctionTableScan failed", K(ret));
} else {
op->set_table_id(ap->get_table_id());
op->set_ref_table_id(ap->get_ref_table_id());
op->get_table_name().assign_ptr(table_item->table_name_.ptr(), table_item->table_name_.length());
op->set_last_access(static_cast<ObSelectStmt*>(get_stmt())->is_last_access());
if (OB_FAIL(op->get_filter_exprs().assign(ap->filter_))) {
LOG_WARN("failed to assign filter exprs", K(ret));
} else if (OB_FAIL(op->compute_property(ap))) {
LOG_WARN("failed to compute property", K(ret));
} else {
out_access_path_op = op;
}
}
return ret;
}
int ObLogPlan::allocate_access_path(AccessPath* ap, ObLogicalOperator*& out_access_path_op)
{
int ret = OB_SUCCESS;
ObLogTableScan* scan = NULL;
ObJoinOrder* join_order = NULL;
ObSqlSchemaGuard* schema_guard = NULL;
ObLogOpType op_type = LOG_TABLE_SCAN;
const ObTableSchema* table_schema = NULL;
const TableItem* table_item = NULL;
if (OB_ISNULL(ap) || OB_ISNULL(get_stmt()) || OB_ISNULL(join_order = ap->parent_) ||
OB_ISNULL(ap->get_sharding_info()) || OB_ISNULL(schema_guard = get_optimizer_context().get_sql_schema_guard()) ||
OB_ISNULL(table_item = get_stmt()->get_table_item_by_id(ap->get_table_id()))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ap), K(get_stmt()), K(schema_guard), K(join_order), K(table_item), K(ret));
} else if (OB_FAIL(schema_guard->get_table_schema(ap->table_id_, table_schema))) {
LOG_WARN("fail to get_table_schema", K(ret));
} else if (!table_schema) {
// do nothing
} else if (share::schema::MATERIALIZED_VIEW == table_schema->get_table_type()) {
op_type = LOG_MV_TABLE_SCAN;
} else { /*do nothing*/
}
if (OB_SUCC(ret)) {
if (OB_UNLIKELY(NULL == (scan = static_cast<ObLogTableScan*>(get_log_op_factory().allocate(*this, op_type))))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("failed to allocate table/index operator", K(ret));
} else if (OB_FAIL(scan->set_est_row_count_record(ap->est_records_))) {
LOG_WARN("failed to set estimation info", K(ret));
} else if (OB_FAIL(append(scan->get_pushdown_filter_exprs(), ap->pushdown_filters_))) {
LOG_WARN("failed to append pushdown filters", K(ret));
} else {
bool is_index_back = ap->est_cost_info_.index_meta_info_.is_index_back_;
ObSEArray<ObRawExpr*, 4> global_index_filters;
ObSEArray<ObRawExpr*, 4> remaining_filters;
scan->set_est_cost_info(&ap->get_cost_table_scan_info());
scan->set_table_id(ap->get_table_id());
scan->set_ref_table_id(ap->get_ref_table_id());
scan->set_index_table_id(ap->get_index_table_id());
scan->set_scan_direction(ap->order_direction_);
scan->set_is_index_global(ap->is_global_index_);
scan->set_is_global_index_back(is_index_back);
scan->set_phy_location_type(ap->get_sharding_info()->get_location_type());
scan->set_table_opt_info(ap->table_opt_info_);
if (is_index_back && ap->is_global_index_) {
scan->set_index_back(false);
} else {
scan->set_index_back(is_index_back);
}
if (ap->is_global_index_) {
if (OB_ISNULL(ap->table_partition_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else {
scan->set_table_partition_info(const_cast<ObTablePartitionInfo*>(ap->table_partition_info_));
}
} else {
scan->set_table_partition_info(&join_order->get_table_partition_info());
}
scan->set_sample_info(ap->sample_info_);
if (NULL != table_schema && table_schema->is_tmp_table()) {
scan->set_session_id(table_schema->get_session_id());
}
if (LOG_MV_TABLE_SCAN == op_type) {
ObLogMVTableScan* mv_scan = static_cast<ObLogMVTableScan*>(scan);
const ObIArray<uint64_t>& depend_tids = table_schema->get_depend_table_ids();
if (depend_tids.count() != 1) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("depend_tid count is not 1", K(depend_tids.count()));
} else {
uint64_t depend_tid = depend_tids.at(0);
mv_scan->set_depend_table_id(depend_tid);
}
}
scan->set_table_row_count(ap->table_row_count_);
scan->set_output_row_count(ap->output_row_count_);
scan->set_phy_query_range_row_count(ap->phy_query_range_row_count_);
scan->set_query_range_row_count(ap->query_range_row_count_);
scan->set_index_back_row_count(ap->index_back_row_count_);
scan->set_estimate_method(ap->est_cost_info_.row_est_method_);
scan->set_is_fake_cte_table(ap->is_cte_path());
scan->set_pre_query_range(ap->pre_query_range_);
if (OB_FAIL(scan->set_update_info())) {
LOG_WARN("Fail to set_update_info", K(ret));
} else if (!ap->is_inner_path_ && OB_FAIL(scan->set_query_ranges(ap->get_cost_table_scan_info().ranges_))) {
LOG_WARN("failed to set query ranges", K(ret));
} else if (OB_FAIL(scan->set_range_columns(ap->get_cost_table_scan_info().range_columns_))) {
LOG_WARN("failed to set range column", K(ret));
} else { // set table name and index name
scan->set_table_name(table_item->get_table_name());
scan->set_diverse_path_count(ap->parent_->get_diverse_path_count());
if (ap->get_index_table_id() != ap->get_ref_table_id()) {
if (OB_FAIL(store_index_column_ids(*schema_guard, *scan, ap->get_index_table_id()))) {
LOG_WARN("Failed to store index column id", K(ret));
}
}
}
if (OB_SUCC(ret)) {
if (ap->is_global_index_ && is_index_back && ap->est_cost_info_.table_filters_.count() > 0) {
if (OB_FAIL(get_global_index_filters(*ap, global_index_filters, remaining_filters))) {
LOG_WARN("failed to get global index filters", K(ret));
} else if (OB_FAIL(scan->set_filters(global_index_filters))) {
LOG_WARN("failed to set filters", K(ret));
} else { /*do nothing*/
}
} else {
if (OB_FAIL(scan->set_filters(ap->filter_))) {
LOG_WARN("failed to set filters", K(ret));
} else { /* do nothing */
}
}
} else { /*do nothing*/
}
if (OB_SUCC(ret)) {
// If assign partitions to scan, set partitions
if (!ap->is_global_index_ && get_stmt()->get_stmt_hint().part_hints_.count() > 0) {
scan->set_part_hint(get_stmt()->get_stmt_hint().get_part_hint(ap->get_table_id()));
} else { /* Do nothing */
}
} else { /* Do nothing */
}
// Get ObRpcScanHint
if (OB_SUCC(ret)) {
const ObQueryHint& query_hint = get_optimizer_context().get_query_hint();
if (INVALID_CONSISTENCY != query_hint.read_consistency_) {
scan->set_exist_hint(true);
scan->get_hint().read_consistency_ = query_hint.read_consistency_;
if (FROZEN == query_hint.read_consistency_) {
scan->get_hint().frozen_version_ = query_hint.frozen_version_;
} else { /* Do nothing */
}
} else { /* Do nothing */
}
// TODO in 052dev, else hint.read_consistency_ = table_schema->get_consistency_level()
if (query_hint.force_refresh_lc_) {
scan->set_exist_hint(true);
scan->get_hint().force_refresh_lc_ = true;
}
} else { /* Do nothing */
}
// compute equal set
if (OB_SUCC(ret)) {
if (OB_FAIL(scan->compute_property(ap))) {
LOG_WARN("failed to compute property", K(ret));
}
}
// init part/subpart expr for query range prune
if (OB_SUCC(ret)) {
uint64_t table_id = scan->get_table_id();
uint64_t ref_table_id = scan->get_location_table_id();
share::schema::ObPartitionLevel part_level = share::schema::PARTITION_LEVEL_MAX;
if (is_virtual_table(ref_table_id) || is_inner_table(ref_table_id) || is_cte_table(ref_table_id) ||
is_link_table_id(ref_table_id)) {
// do nothing
} else {
ObRawExpr* part_expr = NULL;
ObRawExpr* subpart_expr = NULL;
OZ(scan->get_part_exprs(table_id, ref_table_id, part_level, part_expr, subpart_expr));
scan->set_part_expr(part_expr);
scan->set_subpart_expr(subpart_expr);
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(append(scan->get_startup_exprs(), get_startup_filters()))) {
LOG_WARN("failed to append startup filters", K(ret));
}
}
if (OB_SUCC(ret)) {
if (ap->is_global_index_ && is_index_back) {
ObLogicalOperator* temp_op = NULL;
if (OB_FAIL(allocate_table_lookup(
*ap, scan->get_table_name(), scan->get_index_name(), scan, remaining_filters, temp_op))) {
LOG_WARN("failed to allocate table lookup operator", K(ret));
} else if (OB_ISNULL(temp_op)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("null operator", K(ret));
} else {
out_access_path_op = temp_op;
}
} else {
out_access_path_op = scan;
}
}
}
}
return ret;
}
int ObLogPlan::get_global_index_filters(
const AccessPath& ap, ObIArray<ObRawExpr*>& global_index_filters, ObIArray<ObRawExpr*>& remaining_filters)
{
int ret = OB_SUCCESS;
ObSEArray<bool, 4> filter_before_index_back;
if (OB_FAIL(ObOptimizerUtil::check_filter_before_indexback(ap.index_id_,
get_optimizer_context().get_schema_guard(),
ap.filter_,
false,
OB_INVALID_ID,
filter_before_index_back))) {
LOG_WARN("Failed to check filter before index back", K(ret));
} else if (OB_UNLIKELY(filter_before_index_back.count() != ap.filter_.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unequal array size", K(filter_before_index_back.count()), K(ap.filter_.count()), K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < filter_before_index_back.count(); i++) {
if (OB_ISNULL(ap.filter_.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("null expr", K(ret));
} else if (filter_before_index_back.at(i) && !ap.filter_.at(i)->has_flag(CNT_SUB_QUERY)) {
if (OB_FAIL(global_index_filters.push_back(ap.filter_.at(i)))) {
LOG_WARN("failed to push back filter", K(ret));
} else { /*do nothing*/
}
} else {
if (OB_FAIL(remaining_filters.push_back(ap.filter_.at(i)))) {
LOG_WARN("failed to push back filter", K(ret));
} else { /*do nothing*/
}
}
}
}
return ret;
}
int ObLogPlan::allocate_table_lookup(AccessPath& ap, ObString& table_name, ObString& index_name,
ObLogicalOperator* child_node, ObIArray<ObRawExpr*>& filter_exprs, ObLogicalOperator*& output_op)
{
int ret = OB_SUCCESS;
ObLogTableLookup* table_lookup = NULL;
ObLogTableScan* table_scan = NULL;
if (OB_ISNULL(child_node) || OB_ISNULL(get_stmt()) || OB_ISNULL(ap.parent_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(child_node), K(get_stmt()), K(ap.parent_), K(ret));
} else if (OB_UNLIKELY(!ap.is_global_index_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("not global index", K(ap.is_global_index_), K(ret));
} else if (OB_UNLIKELY(!ap.est_cost_info_.index_meta_info_.is_index_back_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("is not index back", K(ret));
} else if (OB_ISNULL(table_lookup = static_cast<ObLogTableLookup*>(
get_log_op_factory().allocate(*this, log_op_def::LOG_TABLE_LOOKUP)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("failed to allocate operator", K(ret));
} else if (OB_ISNULL(table_scan = static_cast<ObLogTableScan*>(
get_log_op_factory().allocate(*this, log_op_def::LOG_TABLE_SCAN)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("failed to allocate operator", K(ret));
} else {
// set up table look up operator
table_lookup->set_table_id(ap.table_id_);
table_lookup->set_ref_table_id(ap.ref_table_id_);
table_lookup->set_index_id(ap.index_id_);
table_lookup->set_table_name(table_name);
table_lookup->set_index_name(index_name);
table_lookup->set_index_back_scan(table_scan);
table_lookup->set_child(0, child_node);
// set up index back op
table_scan->set_table_id(ap.table_id_);
table_scan->set_ref_table_id(ap.ref_table_id_);
table_scan->set_index_table_id(ap.ref_table_id_);
table_scan->set_is_index_global(false);
table_scan->set_is_global_index_back(false);
table_scan->set_index_back(false);
table_scan->set_is_multi_part_table_scan(true);
table_scan->set_table_partition_info(&ap.parent_->get_table_partition_info());
table_scan->set_scan_direction(ap.order_direction_);
table_scan->set_update_info();
// set up filter
if (OB_SUCC(ret)) {
if (OB_FAIL(append(table_scan->get_filter_exprs(), filter_exprs))) {
LOG_WARN("failed to append exprs", K(ret));
} else if (OB_FAIL(append(table_lookup->get_pushdown_filter_exprs(), ap.pushdown_filters_))) {
LOG_WARN("failed to append exprs", K(ret));
} else if (OB_FAIL(table_lookup->init_calc_part_id_expr())) {
LOG_WARN("fail to init calc part id expr", K(ret));
} else {
output_op = table_lookup;
}
}
// compute property
if (OB_SUCC(ret)) {
if (OB_FAIL(output_op->compute_property(&ap))) {
LOG_WARN("faield to compute property", K(ret));
}
}
}
return ret;
}
int ObLogPlan::store_index_column_ids(ObSqlSchemaGuard& schema_guard, ObLogTableScan& scan, const int64_t index_id)
{
int ret = OB_SUCCESS;
ObString index_name;
const ObTableSchema* index_schema = NULL;
if (OB_FAIL(schema_guard.get_table_schema(index_id, index_schema))) {
ret = OB_SCHEMA_ERROR;
LOG_WARN("set index name error", K(ret), K(index_id), K(index_schema));
} else {
if (index_schema->is_materialized_view()) {
index_name = index_schema->get_table_name_str();
} else {
if (OB_FAIL(index_schema->get_index_name(index_name))) {
LOG_WARN("fail to get index name", K(index_name), K(ret));
}
}
}
if (OB_SUCC(ret)) {
scan.set_index_name(index_name);
for (ObTableSchema::const_column_iterator iter = index_schema->column_begin();
OB_SUCC(ret) && iter != index_schema->column_end();
++iter) {
if (OB_ISNULL(iter)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("iter is null", K(ret), K(iter));
} else {
const ObColumnSchemaV2* column_schema = *iter;
if (OB_ISNULL(column_schema)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("column_schema is null", K(ret));
} else if (OB_FAIL(scan.add_idx_column_id(column_schema->get_column_id()))) {
LOG_WARN("Fail to add column id to scan", K(ret));
} else {
} // do nothing
}
}
}
return ret;
}
int ObLogPlan::allocate_join_path(JoinPath* join_path, ObLogicalOperator*& out_join_path_op)
{
int ret = OB_SUCCESS;
ObJoinOrder* join_order = NULL;
if (OB_ISNULL(join_path) || OB_ISNULL(join_order = join_path->parent_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(join_path), K(join_order));
} else {
Path* left_path = const_cast<Path*>(join_path->left_path_);
Path* right_path = const_cast<Path*>(join_path->right_path_);
ObLogicalOperator* left_child = NULL;
ObLogicalOperator* right_child = NULL;
ObLogJoin* join_op = NULL;
if (OB_ISNULL(left_path) || OB_ISNULL(right_path)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(left_path), K(right_path));
} else if (OB_FAIL(create_plan_tree_from_path(left_path, left_child)) ||
OB_FAIL(create_plan_tree_from_path(right_path, right_child))) {
LOG_WARN("failed to create plan tree from path", K(ret));
} else if (OB_ISNULL(left_child) || OB_ISNULL(right_child)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get expected null", K(left_child), K(right_child), K(ret));
} else if (join_path->left_need_sort_ &&
OB_FAIL(allocate_sort_as_top(left_child, join_path->left_expected_ordering_))) {
LOG_WARN("failed to allocate sort operator", K(ret));
} else if (join_path->need_mat_ && (join_path->join_type_ != CONNECT_BY_JOIN) &&
OB_FAIL(allocate_material_as_top(right_child))) {
LOG_WARN("failed to allocate material operator", K(ret));
} else if (join_path->right_need_sort_ &&
OB_FAIL(allocate_sort_as_top(right_child, join_path->right_expected_ordering_))) {
LOG_WARN("failed to allocate sort operator", K(ret));
} else if (OB_ISNULL(join_op = static_cast<ObLogJoin*>(get_log_op_factory().allocate(*this, LOG_JOIN)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("failed to allocate join_op operator", K(ret));
} else if (OB_ISNULL(join_op)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(join_op));
} else {
/*
* Prefix sort check for outer merge join may have problems
* for example, select * from t1 left join t2 on t1.a = t2.a where t2.a is null
* in this case sort for t2 will use prefix sort since t2.a is null in our condition, but it is wrong
* we should maintain this info when generating merge join
*/
if ((join_path->join_type_ == LEFT_OUTER_JOIN || join_path->join_type_ == FULL_OUTER_JOIN) &&
log_op_def::LOG_SORT == right_child->get_type()) {
static_cast<ObLogSort*>(right_child)->set_prefix_pos(0);
}
if ((join_path->join_type_ == RIGHT_OUTER_JOIN || join_path->join_type_ == FULL_OUTER_JOIN) &&
log_op_def::LOG_SORT == left_child->get_type()) {
static_cast<ObLogSort*>(left_child)->set_prefix_pos(0);
}
if (right_path->is_inner_path() &&
(LEFT_SEMI_JOIN == join_path->join_type_ || LEFT_ANTI_JOIN == join_path->join_type_)) {
bool re_est = false;
if (OB_FAIL(right_child->re_est_cost(join_op, 1, re_est))) {
LOG_WARN("failed to re est cost", K(ret));
}
}
join_op->set_left_child(left_child);
join_op->set_right_child(right_child);
join_op->set_join_type(join_path->join_type_);
join_op->set_join_algo(join_path->join_algo_);
join_op->set_anti_or_semi_sel(join_order->get_anti_or_semi_match_sel());
if (OB_FAIL(ret)) {
// do nothing
} else if (OB_FAIL(join_op->set_nl_params(right_path->nl_params_))) {
LOG_WARN("set_nl_params fails", K(ret));
} else if (OB_FAIL(join_op->set_join_conditions(join_path->equal_join_condition_))) {
LOG_WARN("append error in allocate_join_path", K(ret));
} else if (IS_OUTER_OR_CONNECT_BY_JOIN(join_path->join_type_)) {
if (OB_FAIL(extract_level_pseudo_as_param(join_path->other_join_condition_, join_op->get_exec_params()))) {
LOG_WARN("Failed to extract level pseudo as param", K(ret));
} else if (OB_FAIL(append(join_op->get_join_filters(), join_path->other_join_condition_))) {
LOG_WARN("failed to allocate filter", K(ret));
} else if (OB_FAIL(append(join_op->get_filter_exprs(), join_path->filter_))) {
LOG_WARN("failed to allocate filter", K(ret));
} else {
LOG_TRACE("connect by join exec params",
K(join_op->get_exec_params()),
K(join_path->other_join_condition_),
K(ret));
}
} else if (OB_FAIL(append(join_op->get_join_filters(), join_path->other_join_condition_))) {
LOG_WARN("failed to allocate filter", K(ret));
} else { /* do nothing */
}
if (OB_SUCC(ret) && MERGE_JOIN == join_path->join_algo_) {
if (OB_FAIL(join_op->set_left_expected_ordering(join_path->left_expected_ordering_))) {
LOG_WARN("failed to set left_path expected ordering", K(ret));
} else if (OB_FAIL(join_op->set_right_expected_ordering(join_path->right_expected_ordering_))) {
LOG_WARN("failed to set right expected ordering", K(ret));
} else if (OB_FAIL(join_op->set_merge_directions(join_path->merge_directions_))) {
LOG_WARN("failed to set merge directions", K(ret));
}
}
if (OB_SUCC(ret) && CONNECT_BY_JOIN == join_path->join_type_) {
ObJoinOrder* left_jo = NULL;
ObJoinOrder* right_jo = NULL;
ObSEArray<ObRawExpr*, 8> column_exprs;
if (OB_ISNULL(join_path->left_path_) || OB_ISNULL(join_path->right_path_) ||
OB_ISNULL(left_jo = join_path->left_path_->parent_) ||
OB_ISNULL(right_jo = join_path->right_path_->parent_) || OB_ISNULL(stmt_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected NULL", K(ret));
} else if (OB_FAIL(stmt_->get_column_exprs(left_jo->get_table_id(), column_exprs))) {
LOG_WARN("failed to get left table columns", K(ret));
} else if (OB_FAIL(stmt_->get_column_exprs(right_jo->get_table_id(), column_exprs))) {
LOG_WARN("failed to get right table columns", K(ret));
} else if (OB_FAIL(join_op->set_connect_by_extra_exprs(column_exprs))) {
LOG_WARN("failed to set connect by extra exprs", K(ret));
} else if (OB_FAIL(join_op->set_right_expected_ordering(join_path->right_expected_ordering_))) {
LOG_WARN("failed to set right expected ordering", K(ret));
}
LOG_TRACE("set connect by right expected ordering", K(join_path->right_expected_ordering_));
}
if (OB_SUCC(ret)) {
if (OB_FAIL(add_connect_by_prior_exprs(*join_op))) {
LOG_WARN("fail to add connect_by prior_exprs", K(ret));
}
}
// compute property for join
// (equal sets, unique sets, est_sel_info, cost, card, width)
if (OB_SUCC(ret)) {
if (OB_FAIL(join_op->compute_property(join_path))) {
LOG_WARN("failed to compute property for join op", K(ret));
} else {
out_join_path_op = join_op;
}
}
}
}
return ret;
}
int ObLogPlan::add_connect_by_prior_exprs(ObLogJoin& log_join)
{
int ret = OB_SUCCESS;
ObSelectStmt* select_stmt = NULL;
if (CONNECT_BY_JOIN == log_join.get_join_type()) {
if (OB_ISNULL(get_stmt()) || OB_UNLIKELY(false == get_stmt()->is_select_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid stmt", KPC(get_stmt()), K(ret));
} else {
select_stmt = static_cast<ObSelectStmt*>(get_stmt());
if (select_stmt->is_hierarchical_query()) {
if (OB_FAIL(log_join.set_connect_by_prior_exprs(select_stmt->get_connect_by_prior_exprs()))) {
LOG_WARN("fail to set connect by priro expr", K(ret));
}
}
LOG_TRACE("cby connect by prior", K(select_stmt->get_connect_by_prior_exprs()), K(select_stmt));
}
}
return ret;
}
int ObLogPlan::allocate_subquery_path(SubQueryPath* subpath, ObLogicalOperator*& out_subquery_path_op)
{
int ret = OB_SUCCESS;
ObLogicalOperator* root = NULL;
ObLogSubPlanScan* subplan_scan = NULL;
if (OB_ISNULL(subpath) || OB_ISNULL(root = subpath->root_) || OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(subpath), K(root), K(get_stmt()), K(ret));
} else if (OB_ISNULL(subplan_scan =
static_cast<ObLogSubPlanScan*>(get_log_op_factory().allocate(*this, LOG_SUBPLAN_SCAN)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("failed to allocate subquery operator", K(ret));
} else {
root->mark_is_plan_root();
subplan_scan->set_subquery_id(subpath->subquery_id_);
subplan_scan->set_child(ObLogicalOperator::first_child, root);
// set subquery name
const TableItem* table_item = get_stmt()->get_table_item_by_id(subplan_scan->get_subquery_id());
if (OB_ISNULL(table_item)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("get unexpected null", K(ret));
} else {
subplan_scan->get_subquery_name().assign_ptr(table_item->table_name_.ptr(), table_item->table_name_.length());
if (OB_FAIL(append(subplan_scan->get_filter_exprs(), subpath->filter_))) {
LOG_WARN("failed to append filters", K(ret));
} else if (OB_FAIL(append(subplan_scan->get_pushdown_filter_exprs(), subpath->pushdown_filters_))) {
LOG_WARN("failed to append pushdown filters", K(ret));
} else if (OB_FAIL(subplan_scan->compute_property(subpath))) {
LOG_WARN("failed to compute property", K(ret));
} else {
out_subquery_path_op = subplan_scan;
}
}
}
return ret;
}
int ObLogPlan::allocate_material_as_top(ObLogicalOperator*& old_top)
{
int ret = OB_SUCCESS;
ObLogMaterial* material_op = NULL;
if (OB_ISNULL(old_top)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(old_top));
} else if (OB_ISNULL(material_op = static_cast<ObLogMaterial*>(get_log_op_factory().allocate(*this, LOG_MATERIAL)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("failed to allocate material operator", K(ret));
} else {
material_op->set_child(ObLogicalOperator::first_child, old_top);
if (OB_FAIL(material_op->compute_property())) {
LOG_WARN("failed to compute property", K(ret));
} else {
old_top = material_op;
}
}
return ret;
}
int ObLogPlan::create_plan_tree_from_path(Path* path, ObLogicalOperator*& out_plan_tree)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(path) || OB_ISNULL(path->parent_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(path));
} else if (NULL != path->log_op_) {
out_plan_tree = path->log_op_;
} else {
ObLogicalOperator* op = NULL;
if (ACCESS == path->path_type_) {
AccessPath* access_path = static_cast<AccessPath*>(path);
if (access_path->is_function_table_path()) {
if (OB_FAIL(allocate_function_table_path(access_path, op))) {
LOG_WARN("failed to allocate function table path", K(ret));
}
} else if (access_path->is_temp_table_path()) {
if (OB_FAIL(allocate_temp_table_path(access_path, op))) {
LOG_WARN("failed to allocate access path", K(ret));
} else { /* Do nothing */
}
} else if (OB_FAIL(allocate_access_path(access_path, op))) {
LOG_WARN("failed to allocate access path", K(ret));
} else { /* Do nothing */
}
} else if (JOIN == path->path_type_) {
JoinPath* join_path = static_cast<JoinPath*>(path);
if (OB_FAIL(allocate_join_path(join_path, op))) {
LOG_WARN("failed to allocate join path", K(ret));
} else { /* Do nothing */
}
} else if (SUBQUERY == path->path_type_) {
SubQueryPath* join_path = static_cast<SubQueryPath*>(path);
if (OB_FAIL(allocate_subquery_path(join_path, op))) {
LOG_WARN("failed to allocate subquery path", K(ret));
} else { /* Do nothing */
}
} else if (FAKE_CTE_TABLE_ACCESS == path->path_type_) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("there is no access belong to FAKE_CTE_TABLE_ACCESS");
} else { /* Do nothing */
}
if (OB_SUCC(ret)) {
path->log_op_ = op;
out_plan_tree = op;
}
}
return ret;
}
int ObLogPlan::extract_onetime_subquery_exprs(ObRawExpr* expr, ObIArray<ObRawExpr*>& onetime_subquery_exprs)
{
int ret = OB_SUCCESS;
ObArray<ObRawExpr*> params;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null expr", K(ret));
} else if (!expr->has_flag(CNT_EXEC_PARAM)) {
// do nothing
} else if (OB_FAIL(ObOptimizerUtil::extract_params(expr, params))) {
LOG_WARN("failed to extract_params", K(ret));
}
for (int64_t j = 0; OB_SUCC(ret) && j < params.count(); ++j) {
ObRawExpr* param = params.at(j);
ObRawExpr* onetime_expr = NULL;
if (OB_ISNULL(param) || !param->has_flag(IS_PARAM)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect param expr", K(param), K(ret));
} else if (OB_ISNULL(onetime_expr = ObOptimizerUtil::find_exec_param(
onetime_exprs_, static_cast<ObConstRawExpr*>(param)->get_value().get_unknown()))) {
} else if (!onetime_expr->has_flag(CNT_SUB_QUERY)) {
// do nothing
} else if (OB_FAIL(onetime_subquery_exprs.push_back(onetime_expr))) {
LOG_WARN("failed to push back onetime expr", K(ret));
}
}
return ret;
}
int ObLogPlan::candi_init()
{
int ret = OB_SUCCESS;
if (OB_ISNULL(join_order_) || OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), K(join_order_), K(get_stmt()));
} else {
int64_t total_usage = allocator_.total();
LOG_TRACE("memory usage after generating join order", K(total_usage));
ObLogicalOperator* root = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < join_order_->get_interesting_paths().count(); i++) {
if (OB_ISNULL(join_order_->get_interesting_paths().at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("join_order_->get_join_orders().at(i) is null", K(ret), K(i));
} else if (OB_FAIL(create_plan_tree_from_path(join_order_->get_interesting_paths().at(i), root))) {
LOG_WARN("failed to create a path", K(ret));
} else if (OB_ISNULL(root)) {
ret = OB_SQL_OPT_GEN_PLAN_FALIED;
LOG_WARN("root is null", K(ret), K(root));
} else if (OB_FAIL(append(root->get_filter_exprs(), get_random_exprs()))) {
LOG_WARN("failed to append random exprs to filter", K(ret));
} else if (OB_FAIL(append(root->get_filter_exprs(), get_user_var_filters()))) {
LOG_WARN("failed to append user var to filter", K(ret));
} else if (OB_FAIL(append_array_no_dup(root->get_startup_exprs(), get_startup_filters()))) {
LOG_WARN("failed to append startup filters", K(ret));
} else {
CandidatePlan cp;
cp.plan_tree_ = root;
if (OB_FAIL(candidates_.candidate_plans_.push_back(cp))) {
LOG_WARN("push back error", K(ret));
} else {
// update the 'uninteresting' plan cost
if (1 == candidates_.candidate_plans_.count() || cp.plan_tree_->get_cost() < candidates_.plain_plan_.first) {
if (OB_ISNULL(cp.plan_tree_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("cp.plan_tree_ is null", K(ret));
} else {
// the cost of the candidate plan should be noted in the root operator
candidates_.plain_plan_.first = cp.plan_tree_->get_cost();
// position in the candidate plan list
candidates_.plain_plan_.second = candidates_.candidate_plans_.count() - 1;
}
} else { /* Do nothing */
}
LOG_TRACE("add a candidate plan",
"count",
candidates_.candidate_plans_.count(),
K(candidates_.plain_plan_.first),
K(candidates_.plain_plan_.second));
int64_t plan_usage = allocator_.total() - total_usage;
total_usage = allocator_.total();
LOG_TRACE("memory usage after generate a candidate", K(total_usage), K(plan_usage));
total_usage = allocator_.total();
}
}
} // for join orders end
}
return ret;
}
int ObLogPlan::get_order_by_exprs(
ObLogicalOperator& root, ObIArray<ObRawExpr*>& order_by_exprs, ObIArray<ObOrderDirection>* directions)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), K(get_stmt()));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < get_stmt()->get_order_item_size(); i++) {
const OrderItem& order_item = get_stmt()->get_order_item(i);
bool is_const = false;
bool has_null_reject = false;
if (OB_ISNULL(order_item.expr_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::is_const_expr(order_item.expr_, root.get_output_const_exprs(), is_const))) {
LOG_WARN("check is const expr failed", K(ret));
} else if (is_const || (order_item.expr_->has_flag(CNT_COLUMN) && !order_item.expr_->has_flag(CNT_SUB_QUERY) &&
!order_item.expr_->get_expr_levels().has_member(get_stmt()->get_current_level()))) {
} else if (OB_FAIL(order_by_exprs.push_back(order_item.expr_))) {
LOG_WARN("failed to add order by expr", K(ret));
} else if (NULL != directions) {
if (OB_FAIL(ObTransformUtils::has_null_reject_condition(
get_stmt()->get_condition_exprs(), order_item.expr_, has_null_reject))) {
LOG_WARN("failed to check null rejection", K(ret));
} else if (!has_null_reject) {
ret = directions->push_back(order_item.order_type_);
} else if (is_ascending_direction(order_item.order_type_)) {
ret = directions->push_back(default_asc_direction());
} else {
ret = directions->push_back(default_desc_direction());
}
}
}
}
return ret;
}
int ObLogPlan::make_order_items(
const common::ObIArray<ObRawExpr*>& exprs, const ObIArray<ObOrderDirection>* dirs, ObIArray<OrderItem>& items)
{
int ret = OB_SUCCESS;
if (NULL == dirs) {
if (OB_FAIL(make_order_items(exprs, items))) {
LOG_WARN("Failed to make order items", K(ret));
}
} else {
if (OB_FAIL(make_order_items(exprs, *dirs, items))) {
LOG_WARN("Failed to make order items", K(ret));
}
}
return ret;
}
int ObLogPlan::make_order_items(const common::ObIArray<ObRawExpr*>& exprs, common::ObIArray<OrderItem>& items)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), K(get_stmt()));
} else {
ObOrderDirection direction = default_asc_direction();
if (get_stmt()->get_order_item_size() > 0) {
direction = get_stmt()->get_order_item(0).order_type_;
} else { /* Do nothing */
}
int64_t N = exprs.count();
for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
OrderItem key;
key.expr_ = exprs.at(i);
key.order_type_ = direction;
ret = items.push_back(key);
}
}
return ret;
}
int ObLogPlan::make_order_items(
const ObIArray<ObRawExpr*>& exprs, const ObIArray<ObOrderDirection>& dirs, ObIArray<OrderItem>& items)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(exprs.count() != dirs.count())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("expr and dir count not match", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < exprs.count(); ++i) {
OrderItem key;
if (OB_ISNULL(exprs.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(exprs.at(i)));
} else if (exprs.at(i)->has_const_or_const_expr_flag()) {
// do nothing
} else {
key.expr_ = exprs.at(i);
key.order_type_ = dirs.at(i);
if (OB_FAIL(items.push_back(key))) {
LOG_WARN("Failed to push array", K(ret));
}
}
}
}
return ret;
}
int ObLogPlan::candi_allocate_sequence()
{
int ret = OB_SUCCESS;
double min_cost = 0.0;
int64_t min_idx = OB_INVALID_INDEX;
for (int64_t idx = 0; OB_SUCC(ret) && idx < candidates_.candidate_plans_.count(); ++idx) {
CandidatePlan& plain_plan = candidates_.candidate_plans_.at(idx);
if (OB_FAIL(allocate_sequence_as_top(plain_plan.plan_tree_))) {
LOG_WARN("fail alloc candi sequence op", K(idx), K(ret));
} else if (OB_ISNULL(plain_plan.plan_tree_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("null plan tree", K(ret));
} else if (plain_plan.plan_tree_->get_cost() < min_cost || OB_INVALID_INDEX == min_idx) {
min_cost = plain_plan.plan_tree_->get_cost();
min_idx = idx;
} else { /*do nothing*/
}
}
if (OB_SUCC(ret)) {
if (OB_UNLIKELY(OB_INVALID_INDEX == min_idx)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Min idx is invalid", K(ret), K(min_idx));
} else {
candidates_.plain_plan_.first = min_cost;
candidates_.plain_plan_.second = min_idx;
}
}
return ret;
}
/*
* for sequence, old_top may be null
* |ID|OPERATOR |NAME|EST. ROWS|COST|
* -------------------------------------
* |0 |INSERT | |0 |1 |
* |1 | EXPRESSION | |1 |1 |
* |2 | SEQUENCE | |1 |1 |
*/
int ObLogPlan::allocate_sequence_as_top(ObLogicalOperator*& old_top)
{
int ret = OB_SUCCESS;
ObLogSequence* sequence = NULL;
if (OB_ISNULL(get_stmt())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Get unexpected null", K(ret), K(old_top), K(get_stmt()));
} else if (OB_ISNULL(sequence = static_cast<ObLogSequence*>(get_log_op_factory().allocate(*this, LOG_SEQUENCE)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("failed to allocate sequence operator", K(ret));
} else if (OB_FAIL(append_array_no_dup(sequence->get_sequence_ids(), get_stmt()->get_nextval_sequence_ids()))) {
LOG_WARN("failed to append array no dup", K(ret));
} else {
if (NULL != old_top) {
sequence->set_child(ObLogicalOperator::first_child, old_top);
}
if (OB_FAIL(sequence->compute_property())) {
LOG_WARN("failed to compute property", K(ret));
} else {
old_top = sequence;
}
}
return ret;
}
int ObLogPlan::candi_allocate_order_by(ObIArray<OrderItem>& order_items)
{
int ret = OB_SUCCESS;
ObSEArray<ObRawExpr*, 4> order_by_exprs;
ObSEArray<ObOrderDirection, 4> directions;
ObSEArray<ObRawExpr*, 4> candi_subquery_exprs;
ObSEArray<OrderItem, 4> candi_order_items;
ObLogicalOperator* best_plan = NULL;
if (OB_ISNULL(get_stmt())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret));
} else if (OB_FAIL(get_stmt()->get_order_exprs(candi_subquery_exprs))) {
LOG_WARN("failed to get exprs", K(ret));
} else if (OB_FAIL(candi_allocate_subplan_filter_for_exprs(candi_subquery_exprs))) {
LOG_WARN("failed to allocate subplan filter for exprs", K(ret));
} else if (OB_FAIL(get_current_best_plan(best_plan))) {
LOG_WARN("failed to get best plan", K(ret));
} else if (OB_ISNULL(best_plan)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(get_order_by_exprs(*best_plan, order_by_exprs, &directions))) {
LOG_WARN("failed to get order by columns", K(ret));
} else if (order_by_exprs.empty()) {
/*do nothing*/
} else if (OB_FAIL(make_order_items(order_by_exprs, directions, candi_order_items))) {
LOG_WARN("Failed to make order items", K(ret));
} else if (OB_FAIL(best_plan->simplify_ordered_exprs(candi_order_items, order_items))) {
LOG_WARN("failed to simplify ordered exprs", K(ret));
} else if (order_items.empty()) {
/*do nothing*/
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < candidates_.candidate_plans_.count(); i++) {
bool need_sort = false;
CandidatePlan& plain_plan = candidates_.candidate_plans_.at(i);
if (OB_ISNULL(plain_plan.plan_tree_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(plain_plan.plan_tree_->check_need_sort_above_node(order_items, need_sort))) {
LOG_WARN("failed to check plan need sort for order by", K(ret));
} else if (!need_sort) {
LOG_TRACE("no need to allocate sort for order-by", K(need_sort));
} else if (OB_FAIL(allocate_sort_as_top(plain_plan.plan_tree_, order_items))) {
LOG_WARN("failed to allocate sort as top", K(ret));
} else {
LOG_TRACE("succeed to allocate sort for order-by", K(need_sort));
}
}
// keep minimal cost plan or interesting plan
if (OB_SUCC(ret)) {
ObSEArray<CandidatePlan, 4> all_plans;
int64_t check_scope = OrderingCheckScope::CHECK_SET;
if (OB_FAIL(all_plans.assign(candidates_.candidate_plans_))) {
LOG_WARN("failed to assign plan", K(ret));
} else if (OB_FAIL(update_plans_interesting_order_info(all_plans, check_scope))) {
LOG_WARN("failed to update plans interesting order info", K(ret));
} else if (OB_FAIL(prune_and_keep_best_plans(all_plans))) {
LOG_WARN("failed to prune and keep best plans", K(ret));
} else { /*do nothing*/
}
}
}
return ret;
}
int ObLogPlan::candi_allocate_subplan_filter_for_exprs(ObIArray<ObRawExpr*>& exprs)
{
int ret = OB_SUCCESS;
ObSEArray<ObRawExpr*, 4> subquery_exprs;
ObSEArray<ObRawExpr*, 4> nested_subquery_exprs;
ObSEArray<ObQueryRefRawExpr*, 4> subqueries;
if (OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::get_subquery_exprs(exprs, subquery_exprs))) {
LOG_WARN("failed to get subquery exprs", K(ret));
} else if (subquery_exprs.empty()) {
/*do nothing*/
} else if (OB_FAIL(ObTransformUtils::extract_query_ref_expr(subquery_exprs, subqueries))) {
LOG_WARN("failed to get extract query ref expr", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::extract_target_level_query_ref_expr(
subquery_exprs, get_stmt()->get_current_level(), subqueries, nested_subquery_exprs))) {
LOG_WARN("failed to extract target level query ref expr", K(ret));
} else if (!nested_subquery_exprs.empty() && OB_FAIL(candi_allocate_subplan_filter(nested_subquery_exprs, false))) {
LOG_WARN("failed to allocate subplan filter for order by exprs", K(ret));
} else if (OB_FAIL(candi_allocate_subplan_filter(subquery_exprs, false))) {
LOG_WARN("failed to allocate subplan filter for order by exprs", K(ret));
} else { /*do nothing*/
}
return ret;
}
int ObLogPlan::allocate_sort_as_top(
ObLogicalOperator*& top, const ObIArray<ObRawExpr*>& order_by_exprs, const ObIArray<ObOrderDirection>* directions)
{
int ret = OB_SUCCESS;
ObSEArray<OrderItem, 4> order_items;
if (OB_ISNULL(top)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(top), K(ret));
} else if (OB_FAIL(make_order_items(order_by_exprs, directions, order_items))) {
LOG_WARN("failed to make order items", K(ret));
} else if (OB_FAIL(allocate_sort_as_top(top, order_items))) {
LOG_WARN("failed to allocate sort as top", K(ret));
} else { /*do nothing*/
}
return ret;
}
int ObLogPlan::allocate_group_by_as_top(ObLogicalOperator*& top, const AggregateAlgo algo,
const ObIArray<ObRawExpr*>& group_by_exprs, const ObIArray<ObRawExpr*>& rollup_exprs,
const ObIArray<ObAggFunRawExpr*>& agg_items, const ObIArray<ObRawExpr*>& having_exprs,
const ObIArray<OrderItem>& expected_ordering, const bool from_pivot /* = false*/)
{
int ret = OB_SUCCESS;
ObLogicalOperator* group_by_op = NULL;
if (OB_ISNULL(top)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(top));
} else if (OB_ISNULL(group_by_op = get_log_op_factory().allocate(*this, LOG_GROUP_BY))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("failed to allocate group by operator", K(ret));
} else {
ObLogGroupBy* group_by = static_cast<ObLogGroupBy*>(group_by_op);
group_by->set_child(ObLogicalOperator::first_child, top);
group_by->set_algo_type(algo);
group_by->set_from_pivot(from_pivot);
if (OB_FAIL(group_by->set_group_by_exprs(group_by_exprs))) {
LOG_WARN("failed to set group by columns", K(ret));
} else if (OB_FAIL(group_by->set_rollup_exprs(rollup_exprs))) {
LOG_WARN("failed to set rollup columns", K(ret));
} else if (OB_FAIL(group_by->set_aggr_exprs(agg_items))) {
LOG_WARN("failed to set aggregation exprs", K(ret));
} else if (OB_FAIL(group_by->set_expected_ordering(expected_ordering))) {
LOG_WARN("failed to set expected ordering", K(ret));
} else if (OB_FAIL(group_by->get_filter_exprs().assign(having_exprs))) {
LOG_WARN("failed to assign exprs", K(ret));
} else if (OB_FAIL(group_by->compute_property())) {
LOG_WARN("failed to compute property", K(ret));
} else {
top = group_by;
}
}
return ret;
}
int ObLogPlan::allocate_sort_as_top(ObLogicalOperator*& top, const ObIArray<OrderItem>& sort_keys)
{
int ret = OB_SUCCESS;
ObLogSort* sort = NULL;
if (OB_ISNULL(top)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(top), K(ret));
} else if (OB_ISNULL(sort = static_cast<ObLogSort*>(get_log_op_factory().allocate(*this, LOG_SORT)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("failed to allocate sort for order by", K(ret));
} else {
sort->set_child(ObLogicalOperator::first_child, top);
if (OB_FAIL(sort->set_sort_keys(sort_keys))) {
LOG_WARN("failed to set sort keys", K(ret));
} else if (OB_FAIL(sort->check_prefix_sort())) {
LOG_WARN("failed to check prefix sort", K(ret));
} else { /*do nothing*/
}
}
// set plan root, for allocate exchange and adjust sort
if (OB_SUCC(ret) && top->is_plan_root()) {
top->set_is_plan_root(false);
sort->mark_is_plan_root();
set_plan_root(sort);
}
// compute property
if (OB_SUCC(ret)) {
if (OB_FAIL(sort->compute_property())) {
LOG_WARN("failed to compute property", K(ret));
} else {
top = sort;
}
}
return ret;
}
/*
* Limit clause will trigger a cost re-estimation phase based on a uniform distribution assumption.
* instead of choosing minimal-cost plans, we prefer more reliable plans.
*/
int ObLogPlan::candi_allocate_limit(ObIArray<OrderItem>& order_items)
{
int ret = OB_SUCCESS;
ObDMLStmt* stmt = NULL;
bool has_union_child = false;
if (OB_ISNULL(stmt = get_stmt())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("get unexpected null", K(get_stmt()), K(ret));
} else if (stmt->is_set_stmt()) {
has_union_child = static_cast<ObSelectStmt*>(stmt)->get_set_op() == ObSelectStmt::UNION;
} else { /*do nothing*/
}
if (OB_SUCC(ret)) {
if (OB_FAIL(candi_allocate_limit(stmt->get_limit_expr(),
stmt->get_offset_expr(),
stmt->get_limit_percent_expr(),
order_items,
has_union_child,
stmt->is_calc_found_rows(),
stmt->has_top_limit(),
stmt->is_fetch_with_ties()))) {
LOG_WARN("failed to allocate limit operator", K(ret));
} else { /*do nothing*/
}
}
return ret;
}
int ObLogPlan::candi_allocate_limit(ObRawExpr* limit_expr, ObRawExpr* offset_expr, ObRawExpr* percent_expr,
ObIArray<OrderItem>& expect_ordering, const bool has_union_child, const bool is_calc_found_rows,
const bool is_top_limit, const bool is_fetch_with_ties)
{
int ret = OB_SUCCESS;
CandidatePlan temp_plan;
ObSEArray<CandidatePlan, 8> non_reliable_plans;
ObSEArray<CandidatePlan, 8> reliable_plans;
// aggregate the number of parent for each operator
for (int64_t i = 0; OB_SUCC(ret) && i < candidates_.candidate_plans_.count(); ++i) {
ObLogicalOperator* root = candidates_.candidate_plans_.at(i).plan_tree_;
if (OB_ISNULL(root)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(root->aggregate_number_of_parent())) {
LOG_WARN("failed to aggregate number of parent", K(ret));
} else { /*do nothing*/
}
}
for (int64_t idx = 0; OB_SUCC(ret) && idx < candidates_.candidate_plans_.count(); ++idx) {
bool need_copy_tree = false;
bool need_alloc_limit = false;
bool is_reliable = false;
CandidatePlan& plain_plan = candidates_.candidate_plans_.at(idx);
if (OB_ISNULL(plain_plan.plan_tree_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(plain_plan.plan_tree_->need_copy_plan_tree(need_copy_tree))) {
LOG_WARN("failed to check whether need copy plan tree", K(ret));
} else if (!need_copy_tree) {
temp_plan.plan_tree_ = plain_plan.plan_tree_;
} else if (OB_FAIL(plan_tree_copy(plain_plan.plan_tree_, temp_plan.plan_tree_))) {
LOG_WARN("failed to do plan tree copy", K(ret));
} else { /*do nothing*/
}
if (OB_FAIL(ret)) {
/*do nothing*/
} else if (OB_ISNULL(temp_plan.plan_tree_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(if_plan_need_limit(temp_plan.plan_tree_,
limit_expr,
offset_expr,
percent_expr,
is_fetch_with_ties,
need_alloc_limit))) {
LOG_WARN("Failed to check limit needed", K(ret));
} else if (need_alloc_limit && OB_FAIL(allocate_limit_as_top(temp_plan.plan_tree_,
limit_expr,
offset_expr,
percent_expr,
expect_ordering,
has_union_child,
is_calc_found_rows,
is_top_limit,
is_fetch_with_ties))) {
LOG_WARN("failed to allocate limit", K(ret));
} else if (OB_ISNULL(temp_plan.plan_tree_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(is_plan_reliable(temp_plan.plan_tree_, is_reliable))) {
LOG_WARN("failed to check plan is reliable", K(ret));
} else if (is_reliable) {
ret = reliable_plans.push_back(temp_plan);
} else {
ret = non_reliable_plans.push_back(temp_plan);
}
}
if (OB_SUCC(ret)) {
int64_t check_scope = OrderingCheckScope::NOT_CHECK;
if (!reliable_plans.empty()) {
if (OB_FAIL(update_plans_interesting_order_info(reliable_plans, check_scope))) {
LOG_WARN("failed to update plans interesting order info", K(ret));
} else if (OB_FAIL(prune_and_keep_best_plans(reliable_plans))) {
LOG_WARN("failed to prune and keep best plans", K(ret));
} else {
LOG_TRACE("Limit-k clause choose a more reliable plan");
}
} else {
if (OB_FAIL(update_plans_interesting_order_info(non_reliable_plans, check_scope))) {
LOG_WARN("failed to update plans interesting order info", K(ret));
} else if (OB_FAIL(prune_and_keep_best_plans(non_reliable_plans))) {
LOG_WARN("failed to prune and keep best plans", K(ret));
} else {
LOG_TRACE("Limit-k clause does not choose a more reliable plan");
}
}
}
// reset number of parent for each operator
for (int64_t i = 0; OB_SUCC(ret) && i < candidates_.candidate_plans_.count(); ++i) {
ObLogicalOperator* root = candidates_.candidate_plans_.at(i).plan_tree_;
if (OB_ISNULL(root)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(root->reset_number_of_parent())) {
LOG_WARN("failed to reset number of parent", K(ret));
} else { /*do nothing*/
}
}
return ret;
}
/*
* A plan is reliable if it does not make any uniform assumption during the cost re-estimation phase.
* In other words, it should satisfy the following two requirements:
* 1 no operator in the plan has more than 1 children
* 2 all operators in the plan belong to the set {LOG_LIMIT, LOG_COUNT, LOG_TABLE_LOOKUP,
* LOG_SUBPLAN_SCAN, LOG_TABLE_SCAN, LOG_UNPIVOT},
* and does not have any filters.
*/
int ObLogPlan::is_plan_reliable(const ObLogicalOperator* root, bool& is_reliable)
{
int ret = OB_SUCCESS;
is_reliable = false;
if (OB_ISNULL(root)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret));
} else if (log_op_def::LOG_TABLE_SCAN == root->get_type()) {
const ObCostTableScanInfo* cost_info = static_cast<const ObLogTableScan*>(root)->get_est_cost_info();
if (OB_ISNULL(cost_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("cost info is null", K(ret));
} else {
is_reliable = cost_info->table_filters_.empty() && cost_info->postfix_filters_.empty();
}
} else if (log_op_def::LOG_SORT == root->get_type()) {
if (fabs(root->get_op_cost()) < OB_DOUBLE_EPSINON) {
// this sort operator is allocated to adjust sort, can ignore
is_reliable = true;
} else {
is_reliable = false;
}
} else if (root->get_filter_exprs().count() == 0 &&
(log_op_def::LOG_LIMIT == root->get_type() || log_op_def::LOG_COUNT == root->get_type() ||
log_op_def::LOG_TABLE_LOOKUP == root->get_type() || log_op_def::LOG_SUBPLAN_SCAN == root->get_type() ||
log_op_def::LOG_UNPIVOT == root->get_type())) {
is_reliable = true;
} else {
is_reliable = false;
}
if (OB_SUCC(ret) && is_reliable) {
bool is_child_reliable = false;
if (root->get_num_of_child() > 1) {
is_reliable = false;
} else if (root->get_num_of_child() == 0) {
is_reliable = true;
} else if (OB_ISNULL(root->get_child(0))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(is_plan_reliable(root->get_child(0), is_child_reliable))) {
LOG_WARN("failed to check plan is reliable", K(ret));
} else {
is_reliable &= is_child_reliable;
}
}
if (OB_SUCC(ret)) {
LOG_TRACE("succeed to check plan is reliable", K(is_reliable), K(root));
}
return ret;
}
int ObLogPlan::candi_allocate_select_into()
{
int ret = OB_SUCCESS;
ObSEArray<CandidatePlan, 1> select_into_plans;
ObIArray<CandidatePlan>& candidates = candidates_.candidate_plans_;
int64_t best_plan_id = candidates_.plain_plan_.second;
if (OB_UNLIKELY(best_plan_id < 0 || best_plan_id >= candidates.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected array pos", K(best_plan_id), K(candidates.count()), K(ret));
} else {
CandidatePlan candidate_plan = candidates.at(best_plan_id);
if (OB_ISNULL(candidate_plan.plan_tree_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(allocate_selectinto_as_top(candidate_plan.plan_tree_))) {
LOG_WARN("failed to allocate selectinto as top", K(ret));
} else if (OB_FAIL(select_into_plans.push_back(candidate_plan))) {
LOG_WARN("failed to push back candidate plan", K(ret));
} else if (OB_FAIL(prune_and_keep_best_plans(select_into_plans))) {
LOG_WARN("failed to prune and keep best plans", K(ret));
} else { /*do nothing*/
}
}
return ret;
}
int ObLogPlan::allocate_selectinto_as_top(ObLogicalOperator*& old_top)
{
int ret = OB_SUCCESS;
ObLogSelectInto* select_into = NULL;
ObSelectStmt* stmt = static_cast<ObSelectStmt*>(get_stmt());
if (OB_ISNULL(old_top) || OB_ISNULL(get_stmt())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Get unexpected null", K(ret), K(old_top), K(get_stmt()));
} else if (OB_ISNULL(
select_into = static_cast<ObLogSelectInto*>(get_log_op_factory().allocate(*this, LOG_SELECT_INTO)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("allocate memory for ObLogSelectInto failed", K(ret));
} else {
ObSelectIntoItem* into_item = stmt->get_select_into();
bool need_expected_ordering = stmt->has_order_by() && !stmt->has_limit();
if (OB_ISNULL(into_item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("into item is null", K(ret));
} else {
select_into->set_into_type(into_item->into_type_);
select_into->set_outfile_name(into_item->outfile_name_);
select_into->set_filed_str(into_item->filed_str_);
select_into->set_line_str(into_item->line_str_);
select_into->set_user_vars(into_item->user_vars_);
select_into->set_is_optional(into_item->is_optional_);
select_into->set_closed_cht(into_item->closed_cht_);
select_into->set_child(ObLogicalOperator::first_child, old_top);
old_top = select_into;
// compute equal set
if (OB_SUCC(ret)) {
if (need_expected_ordering && OB_FAIL(select_into->set_expected_ordering(stmt->get_order_items()))) {
LOG_WARN("failed to set expected ordering", K(ret));
} else if (OB_FAIL(select_into->compute_property())) {
LOG_WARN("failed to compute equal set", K(ret));
} else { /*do nothing*/
}
}
}
}
return ret;
}
int ObLogPlan::if_plan_need_limit(ObLogicalOperator* top, ObRawExpr* limit_expr, ObRawExpr* offset_expr,
ObRawExpr* percent_expr, bool is_fetch_with_ties, bool& need_alloc_limit)
{
int ret = OB_SUCCESS;
need_alloc_limit = true;
if (OB_ISNULL(top) || OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(top), K(get_stmt()), K(ret));
} else if (log_op_def::instance_of_log_table_scan(top->get_type())) {
ObLogTableScan* table_scan = static_cast<ObLogTableScan*>(top);
if (!is_virtual_table(table_scan->get_ref_table_id()) && !get_stmt()->is_calc_found_rows() &&
(table_scan->get_phy_location_type() == OB_TBL_LOCATION_LOCAL ||
table_scan->get_phy_location_type() == OB_TBL_LOCATION_REMOTE) &&
OB_USE_LATE_MATERIALIZATION != get_stmt()->get_stmt_hint().use_late_mat_ && !table_scan->is_sample_scan() &&
NULL == table_scan->get_limit_expr() && NULL == percent_expr && !is_fetch_with_ties && limit_expr != NULL) {
// Push down limit onto TableScan
// 1. TODO: limit and offset on TableScan for virtual table are not handled yet.
// 2. For cases with distributed sharding_info_, the limit pushing down will be done later
// when allocating the EXCHANGE
// 3. Only do on SELECT log plan, since we can't get sharding_info_ for table_scan now
// and we need to use sharding_info_ on SELECT log plan.
// Reminder: location type is distributed if use intra parallel
table_scan->set_limit_offset(limit_expr, offset_expr);
need_alloc_limit = false;
// Adjust card for table scan
if (OB_FAIL(table_scan->set_limit_size())) {
LOG_WARN("Setting limit size for table scan fails", K(ret));
}
}
} else { /*do nothing*/
}
return ret;
}
int ObLogPlan::allocate_limit_as_top(ObLogicalOperator*& old_top, ObRawExpr* limit_expr, ObRawExpr* offset_expr,
ObRawExpr* percent_expr, ObIArray<OrderItem>& expect_ordering, const bool has_union_child,
const bool is_calc_found_rows, const bool is_top_limit, const bool is_fetch_with_ties)
{
int ret = OB_SUCCESS;
ObLogLimit* limit = NULL;
if (OB_ISNULL(old_top) || OB_ISNULL(get_stmt())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("get unexpected null", K(old_top), K(get_stmt()), K(ret));
} else if (OB_ISNULL(limit = static_cast<ObLogLimit*>(get_log_op_factory().allocate(*this, LOG_LIMIT)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("failed to allocate memory for limit op", K(ret));
} else {
limit->set_limit_count(limit_expr);
limit->set_limit_offset(offset_expr);
limit->set_limit_percent(percent_expr);
limit->set_child(ObLogicalOperator::first_child, old_top);
limit->set_has_union_child(has_union_child);
limit->set_calc_found_rows(is_calc_found_rows);
limit->set_top_limit(is_top_limit);
limit->set_fetch_with_ties(is_fetch_with_ties);
if (OB_FAIL(limit->set_expected_ordering(expect_ordering))) {
LOG_WARN("failed to set expected ordering", K(ret));
} else if (OB_FAIL(limit->compute_property())) {
LOG_WARN("failed to compute property", K(ret));
} else {
old_top = limit;
}
}
return ret;
}
int ObLogPlan::plan_tree_traverse(const TraverseOp& operation, void* ctx)
{
int ret = OB_SUCCESS;
int64_t parallel = get_optimizer_context().get_parallel();
if (OB_ISNULL(get_plan_root()) || OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), K(get_stmt()), K(get_plan_root()));
} else {
NumberingCtx numbering_ctx; // operator numbering context
NumberingExchangeCtx numbering_exchange_ctx; // operator numbering context
ObArenaAllocator allocator(CURRENT_CONTEXT.get_malloc_allocator());
allocator.set_label("PlanTreeTraver");
ObAllocExprContext alloc_expr_ctx(allocator); // expr allocation context
AllocExchContext alloc_exch_ctx(parallel); // exchange allocation context
AdjustSortContext adjust_sort_ctx; // exchange allocation context
uint64_t hash_seed = 0; // seed for plan signature
ObBitSet<256> output_deps; // output expr dependencies
AllocGIContext gi_ctx(parallel);
ObPxPipeBlockingCtx pipe_block_ctx(get_allocator());
ObLocationConstraintContext location_constraints;
AllocMDContext md_ctx;
GenLinkStmtContext link_ctx;
// set up context
switch (operation) {
case PX_PIPE_BLOCKING: {
ctx = &pipe_block_ctx;
if (OB_FAIL(get_plan_root()->init_all_traverse_ctx(pipe_block_ctx))) {
LOG_WARN("init traverse ctx failed", K(ret));
}
break;
}
case ALLOC_GI: {
ctx = &gi_ctx;
bool is_valid = true;
if (get_stmt()->is_insert_stmt() && !static_cast<ObInsertStmt*>(get_stmt())->value_from_select()) {
gi_ctx.is_valid_for_gi_ = false;
} else if (OB_FAIL(get_plan_root()->should_allocate_gi_for_dml(is_valid))) {
LOG_WARN("failed to check should allocate gi for dml", K(ret));
} else {
gi_ctx.is_valid_for_gi_ = get_stmt()->is_dml_write_stmt() && is_valid;
}
break;
}
case ALLOC_MONITORING_DUMP: {
ctx = &md_ctx;
break;
}
case ALLOC_EXCH: {
ctx = &alloc_exch_ctx;
break;
}
case ADJUST_SORT_OPERATOR: {
ctx = &adjust_sort_ctx;
break;
}
case PROJECT_PRUNING: {
ctx = &output_deps;
break;
}
case ALLOC_EXPR: {
if (OB_FAIL(alloc_expr_ctx.not_produced_exprs_.init())) {
LOG_WARN("fail to init not_produced_exprs", K(ret));
} else if (OB_FAIL(alloc_expr_ctx.set_group_replaced_exprs(group_replaced_exprs_))) {
LOG_WARN("failed to set_group_replaced_exprs", K(ret));
} else {
ctx = &alloc_expr_ctx;
}
break;
}
case OPERATOR_NUMBERING: {
ctx = &numbering_ctx;
break;
}
case EXCHANGE_NUMBERING: {
ctx = &numbering_exchange_ctx;
break;
}
case GEN_SIGNATURE: {
ctx = &hash_seed;
break;
}
case GEN_LOCATION_CONSTRAINT: {
ctx = &location_constraints;
break;
}
case PX_ESTIMATE_SIZE:
break;
case GEN_LINK_STMT: {
ctx = &link_ctx;
break;
}
case EXPLAIN_COLLECT_WIDTH:
case EXPLAIN_WRITE_BUFFER:
case EXPLAIN_WRITE_BUFFER_OUTPUT:
case EXPLAIN_WRITE_BUFFER_OUTLINE:
case EXPLAIN_INDEX_SELECTION_INFO:
default:
break;
}
if (OB_SUCC(ret)) {
if (((PX_ESTIMATE_SIZE == operation) || (PX_PIPE_BLOCKING == operation) || (PX_RESCAN == operation)) &&
(is_local_or_remote_plan())) {
/*do nothing*/
} else if (ALLOC_GI == operation && is_local_or_remote_plan() &&
!(gi_ctx.is_valid_for_gi_ && get_optimizer_context().enable_batch_rpc())) {
/*do nothing*/
} else if (OB_FAIL(get_plan_root()->do_plan_tree_traverse(operation, ctx))) {
LOG_WARN("failed to apply operation to operator", K(operation), K(ret));
} else {
// remember signature in plan
if (GEN_SIGNATURE == operation) {
if (OB_ISNULL(ctx)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("ctx is null", K(ret), K(ctx));
} else {
hash_value_ = *static_cast<uint64_t*>(ctx);
LOG_TRACE("succ to generate plan hash value", "hash_value", hash_value_);
}
} else if (ALLOC_EXCH == operation) {
set_phy_plan_type(alloc_exch_ctx);
if (!alloc_exch_ctx.exchange_allocated_) {
set_require_local_execution(true);
}
if (OB_FAIL(set_group_replaced_exprs(alloc_exch_ctx.group_push_down_replaced_exprs_))) {
LOG_WARN("failed to set_group_replaced_exprs", K(ret));
}
} else if (GEN_LOCATION_CONSTRAINT == operation) {
ObSqlCtx* sql_ctx = NULL;
if (OB_ISNULL(optimizer_context_.get_exec_ctx()) ||
OB_ISNULL(sql_ctx = optimizer_context_.get_exec_ctx()->get_sql_ctx())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(optimizer_context_.get_exec_ctx()), K(sql_ctx));
} else if (OB_FAIL(remove_duplicate_constraint(location_constraints, *sql_ctx))) {
LOG_WARN("fail to remove duplicate constraint", K(ret));
} else if (OB_FAIL(calc_and_set_exec_pwj_map(location_constraints))) {
LOG_WARN("failed to calc and set exec pwj map", K(ret));
}
} else if (ADJUST_SORT_OPERATOR == operation) {
if (0 != adjust_sort_ctx.exchange_cnt_) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid traverse for adjust sort", K(ret), K(adjust_sort_ctx.exchange_cnt_));
}
} else if (ALLOC_EXPR == operation) {
if (OB_FAIL(set_all_exprs(alloc_expr_ctx))) {
LOG_WARN("fail to set all exprs", K(ret));
}
} else if (OPERATOR_NUMBERING == operation) {
NumberingCtx* num_ctx = static_cast<NumberingCtx*>(ctx);
max_op_id_ = num_ctx->op_id_;
LOG_TRACE("trace max operator id", K(max_op_id_), K(this));
} else { /* Do nothing */
}
LOG_TRACE("succ to apply operaion to operator", K(operation), K(ret));
}
}
}
return ret;
}
int ObLogPlan::change_id_hint_to_idx()
{
int ret = OB_SUCCESS;
ObDMLStmt* dml_stmt = get_stmt();
if (OB_ISNULL(dml_stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("dml stmt is null", K(ret));
} else {
ObStmtHint& stmt_hint = dml_stmt->get_stmt_hint();
if (OB_FAIL(dml_stmt->convert_table_ids_to_bitset(stmt_hint.use_merge_ids_, stmt_hint.use_merge_idxs_))) {
LOG_WARN("failed to convert table ids to bitset for use merge ids", K(ret));
} else if (OB_FAIL(
dml_stmt->convert_table_ids_to_bitset(stmt_hint.no_use_merge_ids_, stmt_hint.no_use_merge_idxs_))) {
LOG_WARN("failed to convert table ids to bitset for no use merge ids", K(ret));
} else if (OB_FAIL(dml_stmt->convert_table_ids_to_bitset(stmt_hint.use_nl_ids_, stmt_hint.use_nl_idxs_))) {
LOG_WARN("failed to convert table ids to bitset for use nl ids", K(ret));
} else if (OB_FAIL(dml_stmt->convert_table_ids_to_bitset(stmt_hint.no_use_nl_ids_, stmt_hint.no_use_nl_idxs_))) {
LOG_WARN("failed to convert table ids to bitset for no use nl ids", K(ret));
} else if (OB_FAIL(dml_stmt->convert_table_ids_to_bitset(stmt_hint.use_bnl_ids_, stmt_hint.use_bnl_idxs_))) {
LOG_WARN("failed to convert table ids to bitset for use bnl ids", K(ret));
} else if (OB_FAIL(dml_stmt->convert_table_ids_to_bitset(stmt_hint.no_use_bnl_ids_, stmt_hint.no_use_bnl_idxs_))) {
LOG_WARN("failed to convert table ids to bitset for no use bnl ids", K(ret));
} else if (OB_FAIL(dml_stmt->convert_table_ids_to_bitset(stmt_hint.use_hash_ids_, stmt_hint.use_hash_idxs_))) {
LOG_WARN("failed to convert table ids to bitset for use hash ids", K(ret));
} else if (OB_FAIL(
dml_stmt->convert_table_ids_to_bitset(stmt_hint.no_use_hash_ids_, stmt_hint.no_use_hash_idxs_))) {
LOG_WARN("failed to convert table ids to bitset for use hash ids", K(ret));
} else if (OB_FAIL(dml_stmt->convert_table_ids_to_bitset(
stmt_hint.use_nl_materialization_ids_, stmt_hint.use_nl_materialization_idxs_))) {
LOG_WARN("failed to convert table ids to bitset for use hash ids", K(ret));
} else if (OB_FAIL(dml_stmt->convert_table_ids_to_bitset(
stmt_hint.no_use_nl_materialization_ids_, stmt_hint.no_use_nl_materialization_idxs_))) {
LOG_WARN("failed to convert table ids to bitset for use hash ids", K(ret));
} else if (OB_FAIL(
dml_stmt->convert_table_ids_to_bitset(stmt_hint.pq_distributes_, stmt_hint.pq_distributes_idxs_))) {
LOG_WARN("failed to convert table ids to bitset for use hash ids", K(ret));
} else if (OB_FAIL(dml_stmt->convert_table_ids_to_bitset(stmt_hint.pq_maps_, stmt_hint.pq_map_idxs_))) {
LOG_WARN("failed to convert table ids to bitset for use hash ids", K(ret));
} else if (OB_FAIL(dml_stmt->convert_table_ids_to_bitset(
stmt_hint.px_join_filter_ids_, stmt_hint.px_join_filter_idxs_))) {
LOG_WARN("failed to convert table ids to bitset for use hash ids", K(ret));
} else if (OB_FAIL(dml_stmt->convert_table_ids_to_bitset(
stmt_hint.no_px_join_filter_ids_, stmt_hint.no_px_join_filter_idxs_))) {
LOG_WARN("failed to convert table ids to bitset for use hash ids", K(ret));
} else {
}
}
return ret;
}
int ObLogPlan::generate_plan_tree()
{
int ret = OB_SUCCESS;
if (OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), K(get_stmt()));
} else {
// 1.1 generate access paths
/* random exprs should be split from condition exprs to avoid being pushed down
* random exprs will be added back in function candi_init*/
if (OB_FAIL(ObTransformUtils::right_join_to_left(get_stmt()))) {
LOG_WARN("failed to change right join to left", K(ret));
} else if (OB_FAIL(change_id_hint_to_idx())) {
LOG_WARN("failed to change id hint to idx", K(ret));
} else if (OB_FAIL(generate_join_orders())) {
LOG_WARN("failed to generate the access path for the single-table query", K(ret), K(get_stmt()->get_sql_stmt()));
} else if (OB_FAIL(candi_init())) {
LOG_WARN("failed to initialized the plan candidates from the join order", K(ret));
} else {
LOG_TRACE("plan candidates is initialized from the join order",
"# of candidates",
candidates_.candidate_plans_.count());
}
}
return ret;
}
void ObLogPlan::set_phy_plan_type(AllocExchContext& ctx)
{
AllocExchContext::DistrStat status = ctx.get_plan_type();
if (AllocExchContext::UNINITIALIZED == status || AllocExchContext::LOCAL == status) {
phy_plan_type_ = OB_PHY_PLAN_LOCAL;
} else if (AllocExchContext::REMOTE == status) {
phy_plan_type_ = OB_PHY_PLAN_REMOTE;
} else {
phy_plan_type_ = OB_PHY_PLAN_DISTRIBUTED;
}
}
int ObLogPlan::check_join_legal(const ObRelIds& left_set, const ObRelIds& right_set, ConflictDetector* detector,
bool delay_cross_product, bool& legal)
{
int ret = OB_SUCCESS;
ObRelIds ids;
legal = true;
if (OB_ISNULL(detector)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null detector", K(ret));
} else if (INNER_JOIN == detector->join_info_.join_type_) {
if (OB_FAIL(ids.add_members(left_set))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(ids.add_members(right_set))) {
LOG_WARN("failed to add members", K(ret));
} else if (!detector->join_info_.table_set_.is_subset(ids)) {
legal = false;
}
} else {
if (detector->L_TES_.is_subset(left_set) && detector->R_TES_.is_subset(right_set)) {
// do nothing
} else if (!detector->is_commutative_) {
legal = false;
} else if (detector->R_TES_.is_subset(left_set) && detector->L_TES_.is_subset(right_set)) {
// do nothing
} else {
legal = false;
}
if (legal && !detector->is_commutative_) {
if (left_set.overlap(detector->R_DS_) || right_set.overlap(detector->L_DS_)) {
legal = false;
}
}
}
if (OB_FAIL(ret) || !legal) {
// do nothing
} else if (detector->is_degenerate_pred_) {
// check T(left(o)) n S1 != empty ^ T(right(o)) n S2 != empty
if (detector->L_DS_.overlap(left_set) && detector->R_DS_.overlap(right_set)) {
// do nothing
} else if (!detector->is_commutative_) {
legal = false;
} else if (detector->R_DS_.overlap(left_set) && detector->L_DS_.overlap(right_set)) {
// do nothing
} else {
legal = false;
}
}
if (OB_FAIL(ret) || !legal) {
// do nothing
} else if (OB_FAIL(ids.add_members(left_set))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(ids.add_members(right_set))) {
LOG_WARN("failed to add members", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && legal && i < detector->CR_.count(); ++i) {
const ObRelIds& T1 = detector->CR_.at(i).first;
const ObRelIds& T2 = detector->CR_.at(i).second;
if (T1.overlap(ids) && !T2.is_subset(ids)) {
legal = false;
}
}
if (OB_SUCC(ret) && legal) {
for (int64_t i = 0; OB_SUCC(ret) && legal && i < detector->cross_product_rule_.count(); ++i) {
const ObRelIds& T1 = detector->cross_product_rule_.at(i).first;
const ObRelIds& T2 = detector->cross_product_rule_.at(i).second;
if (T1.overlap(left_set) && !T2.is_subset(left_set)) {
legal = false;
} else if (T1.overlap(right_set) && !T2.is_subset(right_set)) {
legal = false;
}
}
}
if (OB_SUCC(ret) && delay_cross_product && legal) {
for (int64_t i = 0; OB_SUCC(ret) && legal && i < detector->delay_cross_product_rule_.count(); ++i) {
const ObRelIds& T1 = detector->delay_cross_product_rule_.at(i).first;
const ObRelIds& T2 = detector->delay_cross_product_rule_.at(i).second;
if (T1.overlap(left_set) && !T2.is_subset(left_set)) {
legal = false;
} else if (T1.overlap(right_set) && !T2.is_subset(right_set)) {
legal = false;
}
}
}
}
return ret;
}
int ObLogPlan::check_join_hint(
const ObRelIds& left_set, const ObRelIds& right_set, bool& match_hint, bool& is_legal, bool& is_strict_order)
{
int ret = OB_SUCCESS;
if (!left_set.overlap(leading_tables_) && !right_set.overlap(leading_tables_)) {
match_hint = false;
is_legal = true;
is_strict_order = true;
} else if (left_set.is_subset(leading_tables_) && right_set.is_subset(leading_tables_)) {
bool found = false;
for (int64_t i = 0; !found && i < leading_infos_.count(); ++i) {
const LeadingInfo& info = leading_infos_.at(i);
if (left_set.equal(info.left_table_set_) && right_set.equal(info.right_table_set_)) {
is_strict_order = true;
found = true;
} else if (right_set.equal(info.left_table_set_) && left_set.equal(info.right_table_set_)) {
is_strict_order = false;
found = true;
}
}
if (!found) {
is_legal = false;
} else {
match_hint = true;
is_legal = true;
}
} else if (leading_tables_.is_subset(left_set)) {
match_hint = true;
is_legal = true;
is_strict_order = true;
} else {
is_legal = false;
}
return ret;
}
int ObLogPlan::extract_onetime_exprs(
ObRawExpr* expr, ObIArray<std::pair<int64_t, ObRawExpr*>>& onetime_exprs, ObBitSet<>& idxs)
{
int ret = OB_SUCCESS;
bool is_onetime_expr = false;
bool is_stack_overflow = false;
if (OB_ISNULL(expr) || OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Get unexpected null", K(ret), KP(expr), KP(get_stmt()));
} else if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
LOG_WARN("check stack overflow failed", K(ret));
} else if (is_stack_overflow) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("too deep recursive", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::check_is_onetime_expr(get_onetime_exprs(), expr, get_stmt(), is_onetime_expr))) {
LOG_WARN("failed to check subquery is onetime expr", K(ret));
} else if (is_onetime_expr) {
if (OB_FAIL(extract_subquery_ids(expr, idxs))) {
LOG_WARN("fail to extract param from raw expr", K(ret));
} else {
int64_t param_num = ObOptimizerUtil::find_exec_param(get_onetime_exprs(), expr);
if (param_num >= 0) {
ObRawExpr* param_expr = ObOptimizerUtil::find_param_expr(get_stmt()->get_exec_param_ref_exprs(), param_num);
if (NULL != param_expr) {
if (OB_FAIL(onetime_exprs.push_back(std::pair<int64_t, ObRawExpr*>(param_num, expr)))) {
LOG_WARN("push back onetime_exprs error", K(ret));
} else { /*do nothing*/
}
} else { /* do nothing */
}
} else {
ObRawExpr* temp_expr = expr;
std::pair<int64_t, ObRawExpr*> init_expr;
if (OB_FAIL(ObRawExprUtils::create_exec_param_expr(
get_stmt(), optimizer_context_.get_expr_factory(), temp_expr, NULL, init_expr))) {
LOG_WARN("create param for stmt error in extract_params_for_nl", K(ret));
} else if (OB_FAIL(onetime_exprs.push_back(init_expr))) {
LOG_WARN("push back error", K(ret));
} else { /*do nothing*/
}
}
}
} else {
int64_t count = expr->get_param_count();
for (int64_t i = 0; OB_SUCC(ret) && i < count; ++i) {
if (OB_FAIL(SMART_CALL(extract_onetime_exprs(expr->get_param_expr(i), onetime_exprs, idxs)))) {
LOG_WARN("fail to extract param from raw expr", K(ret), K(expr->get_param_expr(i)));
} else { /* Do nothing */
}
}
}
return ret;
}
int ObLogPlan::extract_subquery_ids(ObRawExpr* expr, ObBitSet<>& idxs)
{
int ret = OB_SUCCESS;
bool is_stack_overflow = false;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
} else if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
LOG_WARN("check stack overflow failed", K(ret));
} else if (is_stack_overflow) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("too deep recursive", K(ret));
} else {
ObRawExpr::ExprClass expr_class = expr->get_expr_class();
switch (expr_class) {
case ObRawExpr::EXPR_CONST: {
break;
}
case ObRawExpr::EXPR_QUERY_REF: {
if (OB_FAIL(idxs.add_member(static_cast<ObQueryRefRawExpr*>(expr)->get_ref_id()))) {
LOG_WARN("add_member fails", K(ret));
} else { /* Do nothing */
}
break;
}
case ObRawExpr::EXPR_SET_OP:
case ObRawExpr::EXPR_COLUMN_REF: {
break;
}
case ObRawExpr::EXPR_CASE_OPERATOR: // fallthrough
case ObRawExpr::EXPR_AGGR: // fallthrough
case ObRawExpr::EXPR_SYS_FUNC: // fallthrough
case ObRawExpr::EXPR_UDF:
case ObRawExpr::EXPR_OPERATOR: {
int64_t count = expr->get_param_count();
for (int64_t i = 0; OB_SUCC(ret) && i < count; ++i) {
if (OB_ISNULL(expr->get_param_expr(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expr->get_param_expr(i) is null", K(ret), K(i));
} else if (!expr->get_param_expr(i)->has_flag(CNT_SUB_QUERY)) {
} else if (OB_FAIL(SMART_CALL(extract_subquery_ids(expr->get_param_expr(i), idxs)))) {
LOG_WARN("fail to extract subquery ids from raw expr", K(ret));
} else { /* Do nothing */
}
}
break;
}
case ObRawExpr::EXPR_INVALID_CLASS:
default:
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid expr class", K(expr_class), K(ret));
// should not reach here
break;
} // switch case end
}
return ret;
}
int ObLogPlan::print_outline(planText& plan, bool is_hints) const
{
int ret = OB_SUCCESS;
char* buf = plan.buf;
int64_t& buf_len = plan.buf_len;
int64_t& pos = plan.pos;
bool is_oneline = plan.is_oneline_;
OutlineType outline_type = plan.outline_type_;
const ObQueryCtx* query_ctx = NULL;
if (OB_ISNULL(stmt_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("stmt_ is NULL", K(ret));
} else if (OB_ISNULL(query_ctx = stmt_->get_query_ctx())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("query_ctx is NULL", K(ret));
} else if (!is_oneline && OB_FAIL(BUF_PRINTF(" "))) {
} else if (!is_hints && OB_FAIL(BUF_PRINTF("/*+"))) { /* Do nothing */
} else if (OUTLINE_DATA == outline_type && !is_oneline && OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */
} else if (OUTLINE_DATA == outline_type &&
OB_FAIL(BUF_PRINTF(ObStmtHint::get_outline_indent(is_oneline)))) { /* Do nothing */
} else if (OUTLINE_DATA == outline_type && OB_FAIL(BUF_PRINTF("BEGIN_OUTLINE_DATA"))) { /* Do nothing */
} else if (OB_FAIL(const_cast<ObLogPlan*>(this)->plan_tree_traverse(EXPLAIN_WRITE_BUFFER_OUTLINE, &plan))) {
LOG_WARN("failed to print output exprs", K(ret));
} else if (OB_FAIL(stmt_->get_stmt_hint().print_global_hint_for_outline(plan, stmt_))) {
LOG_WARN("fail to print global hint for outline", K(ret));
} else if (OB_FAIL(query_ctx->print_qb_name_hint(plan))) {
LOG_WARN("fail to print qb_name", K(ret));
} else if (OUTLINE_DATA == outline_type && !is_oneline && OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */
} else if (OUTLINE_DATA == outline_type &&
OB_FAIL(BUF_PRINTF(ObStmtHint::get_outline_indent(is_oneline)))) { /* Do nothing */
} else if (OUTLINE_DATA == outline_type && OB_FAIL(BUF_PRINTF("END_OUTLINE_DATA"))) { /* Do nothing */
} else if (!is_oneline && OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */
} else if (!is_oneline && OB_FAIL(BUF_PRINTF(" "))) {
} else if (!is_hints && OB_FAIL(BUF_PRINTF("*/"))) { /* Do nothing */
}
return ret;
}
int ObLogPlan::print_outline_oneline(char* buf, int64_t buf_len, int64_t& pos) const
{
int ret = OB_SUCCESS;
planText plan(buf, buf_len, EXPLAIN_OUTLINE);
plan.is_oneline_ = true;
plan.outline_type_ = OUTLINE_DATA;
if (OB_FAIL(print_outline(plan))) {
LOG_WARN("fail to print outline", K(ret), "buf", ObString(static_cast<int32_t>(plan.pos), buf));
} else {
pos = plan.pos;
}
return ret;
}
double ObLogPlan::get_expr_selectivity(const ObRawExpr* expr, bool& found)
{
double sel = 1.0;
found = false;
if (OB_ISNULL(expr)) {
} else {
for (int64_t i = 0; !found && i < predicate_selectivities_.count(); ++i) {
if (expr == predicate_selectivities_.at(i).expr_) {
found = true;
sel = predicate_selectivities_.at(i).sel_;
}
}
}
return sel;
}
int ObLogPlan::store_param_expr_selectivity(ObRawExpr* src_expr, ObRawExpr* param_expr, ObEstSelInfo& sel_info)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(src_expr) || OB_ISNULL(param_expr)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Invalid argument", K(ret), K(src_expr), K(param_expr));
} else {
bool found_sel = false;
double sel = get_expr_selectivity(src_expr, found_sel);
if (!found_sel) {
LOG_TRACE("Not found param expr selectivity");
if (OB_FAIL(ObOptEstSel::clause_selectivity(sel_info, src_expr, sel, &get_predicate_selectivities()))) {
LOG_WARN("Failed to calc selectivity", K(ret));
}
}
if (OB_SUCC(ret)) {
int tmp_ret = OB_SUCCESS;
if (OB_UNLIKELY(OB_SUCCESS != (tmp_ret = add_var_to_array_no_dup(
get_predicate_selectivities(), ObExprSelPair(param_expr, sel))))) {
LOG_WARN("failed to add selectivity to plan", K(tmp_ret), K(param_expr), K(sel));
}
}
}
return ret;
}
int ObLogPlan::candi_allocate_subplan_filter_for_where()
{
int ret = OB_SUCCESS;
ObSEArray<ObRawExpr*, 4> pushdown_subquery;
ObSEArray<ObRawExpr*, 4> none_pushdown_subquery;
for (int64_t i = 0; i < subquery_filters_.count(); ++i) {
ObRawExpr* expr = subquery_filters_.at(i);
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null expr", K(ret));
} else if (expr->has_flag(CNT_SUB_QUERY)) {
ret = none_pushdown_subquery.push_back(expr);
} else if (OB_FAIL(extract_onetime_subquery_exprs(expr, pushdown_subquery))) {
LOG_WARN("failed to extract onetime subquery exprs", K(ret));
}
}
if (OB_FAIL(ret)) {
/*do nothing*/
} else if (OB_FAIL(candi_allocate_subplan_filter(pushdown_subquery, false))) {
LOG_WARN("failed to allocate subplan filter", K(ret));
} else if (OB_FAIL(candi_allocate_subplan_filter(none_pushdown_subquery, true))) {
LOG_WARN("failed to allocate subplan filter", K(ret));
} else { /*do nothing*/
}
return ret;
}
int ObLogPlan::candi_allocate_subplan_filter(ObIArray<ObRawExpr*>& subquery_exprs, const bool is_filter)
{
int ret = OB_SUCCESS;
if (OB_FAIL(candi_allocate_subplan_filter(subquery_exprs, is_filter, candidates_))) {
LOG_WARN("failed to allocate subplan filter as top", K(ret));
} else { /*do nothing*/
}
return ret;
}
int ObLogPlan::candi_allocate_subplan_filter(
ObIArray<ObRawExpr*>& subquery_exprs, const bool is_filter, All_Candidate_Plans& all_plans)
{
int ret = OB_SUCCESS;
ObBitSet<> initplan_idxs;
ObBitSet<> onetime_idxs;
ObSEArray<ObLogicalOperator*, 4> subquery_ops;
ObSEArray<std::pair<int64_t, ObRawExpr*>, 4> params;
ObSEArray<std::pair<int64_t, ObRawExpr*>, 4> onetime_exprs;
ObLogicalOperator* best_plan = NULL;
if (OB_FAIL(all_plans.get_best_plan(best_plan))) {
LOG_WARN("failed to get best plan", K(ret));
} else if (OB_ISNULL(best_plan)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpectd null", K(ret));
} else if (OB_FAIL(generate_subplan_filter_info(
subquery_exprs, best_plan, subquery_ops, params, onetime_exprs, initplan_idxs, onetime_idxs))) {
LOG_WARN("failed to generated subplan filter info", K(ret));
} else if (subquery_ops.empty() && !is_filter) {
/*do nothing*/
} else if (is_filter && !onetime_exprs.empty() &&
OB_FAIL(find_and_replace_onetime_expr_with_param(onetime_exprs, subquery_exprs))) {
LOG_WARN("failed to find and replace onetime expr with param", K(ret));
} else if (subquery_ops.empty()) {
if (OB_FAIL(candi_allocate_filter(subquery_exprs))) {
LOG_WARN("failed to allocate filter as top", K(ret));
} else { /*do nothing*/
}
} else {
double min_cost = 0.0;
int64_t min_idx = OB_INVALID_INDEX;
ObIArray<ObRawExpr*>* filters = NULL;
if (is_filter) {
filters = &subquery_exprs;
}
for (int64_t i = 0; OB_SUCC(ret) && i < all_plans.candidate_plans_.count(); ++i) {
CandidatePlan& plain_plan = all_plans.candidate_plans_.at(i);
if (OB_FAIL(allocate_subplan_filter_as_top(
plain_plan.plan_tree_, subquery_ops, params, onetime_exprs, initplan_idxs, onetime_idxs, filters))) {
LOG_WARN("failed to allocate filter", K(ret));
} else if (OB_ISNULL(plain_plan.plan_tree_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Plan_tree_ is NULL", K(ret));
} else if (plain_plan.plan_tree_->get_cost() < min_cost || OB_INVALID_INDEX == min_idx) {
min_cost = plain_plan.plan_tree_->get_cost();
min_idx = i;
} else { /*do nothing*/
}
}
if (OB_SUCC(ret)) {
if (OB_UNLIKELY(OB_INVALID_INDEX == min_idx)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected index", K(ret), K(min_idx));
} else {
all_plans.plain_plan_.second = min_idx;
all_plans.plain_plan_.first = min_cost;
}
}
}
if (OB_SUCC(ret) && !onetime_exprs.empty()) {
if (OB_FAIL(add_onetime_exprs(onetime_exprs))) {
LOG_WARN("failed to add onetime exprs", K(ret));
} else if (OB_FAIL(adjust_stmt_onetime_exprs(onetime_exprs))) {
LOG_WARN("failed to adjust stme onetime exprs", K(ret));
} else { /*do nothing*/
}
}
return ret;
}
int ObLogPlan::generate_subplan_filter_info(const ObIArray<ObRawExpr*>& subquery_exprs, ObLogicalOperator* top_node,
ObIArray<ObLogicalOperator*>& subquery_ops, ObIArray<std::pair<int64_t, ObRawExpr*>>& params,
ObIArray<std::pair<int64_t, ObRawExpr*>>& onetime_exprs, ObBitSet<>& initplan_idxs, ObBitSet<>& onetime_idxs)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(top_node)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else {
ObSEArray<SubPlanInfo*, 4> subplan_infos;
ObSEArray<SubPlanInfo*, 4> temp_subplan_infos;
ObBitSet<> temp_onetime_idxs;
ObSEArray<std::pair<int64_t, ObRawExpr*>, 4> temp_onetime_exprs;
for (int64_t i = 0; OB_SUCC(ret) && i < subquery_exprs.count(); i++) {
ObRawExpr* temp_expr = NULL;
temp_subplan_infos.reuse();
if (OB_ISNULL(temp_expr = subquery_exprs.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(generate_subplan(temp_expr))) {
LOG_WARN("failed to generate subplan", K(ret));
} else if (OB_FAIL(get_subplan_info(temp_expr, temp_subplan_infos))) {
LOG_WARN("failed to generate subplan info", K(ret));
} else {
for (int64_t j = 0; OB_SUCC(ret) && j < temp_subplan_infos.count(); j++) {
bool need_alloc = false;
if (OB_FAIL(need_alloc_child_for_subplan_filter(top_node, temp_subplan_infos.at(j)->subplan_, need_alloc))) {
LOG_WARN(
"failed to check whether need alloc subplan filter", K(need_alloc), K(top_node->get_type()), K(ret));
} else if (need_alloc && OB_FAIL(add_var_to_array_no_dup(subplan_infos, temp_subplan_infos.at(j)))) {
LOG_WARN("failed to push back subplan infos", K(ret));
} else { /*do nothing*/
}
}
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < subplan_infos.count(); i++) {
ObQueryRefRawExpr* ref_subquery_expr = NULL;
if (OB_ISNULL(subplan_infos.at(i)) || OB_ISNULL(subplan_infos.at(i)->subplan_) ||
OB_ISNULL(subplan_infos.at(i)->subplan_->get_plan_root()) || OB_ISNULL(subplan_infos.at(i)->init_expr_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(subquery_ops.push_back(subplan_infos.at(i)->subplan_->get_plan_root()))) {
LOG_WARN("failed to push back child ops", K(ret));
} else if (OB_FAIL(append(params, subplan_infos.at(i)->sp_params_))) {
LOG_WARN("failed to append params", K(ret));
} else if (subplan_infos.at(i)->init_plan_ && OB_FAIL(initplan_idxs.add_member(i + 1))) {
LOG_WARN("failed to add init plan idxs", K(ret));
} else {
ref_subquery_expr = static_cast<ObQueryRefRawExpr*>(subplan_infos.at(i)->init_expr_);
ref_subquery_expr->set_ref_id(i + 1);
ref_subquery_expr->set_ref_operator(subplan_infos.at(i)->subplan_->get_plan_root());
}
}
if (OB_SUCC(ret) && !subquery_ops.empty()) {
for (int64_t i = 0; OB_SUCC(ret) && i < subquery_exprs.count(); i++) {
temp_onetime_exprs.reuse();
temp_onetime_idxs.reuse();
if (OB_ISNULL(subquery_exprs.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(extract_onetime_exprs(subquery_exprs.at(i), temp_onetime_exprs, temp_onetime_idxs))) {
LOG_WARN("failed to extract onetime exprs", K(ret));
} else if (OB_FAIL(append(onetime_exprs, temp_onetime_exprs))) {
LOG_WARN("failed to append onetime exprs", K(ret));
} else if (OB_FAIL(onetime_idxs.add_members(temp_onetime_idxs))) {
LOG_WARN("failed to add member", K(ret));
} else {
LOG_TRACE("succeed to get onetime exprs", K(*subquery_exprs.at(i)), K(temp_onetime_idxs));
}
}
}
if (OB_SUCC(ret)) {
initplan_idxs.del_members(onetime_idxs);
}
}
return ret;
}
int ObLogPlan::candi_allocate_filter(const ObIArray<ObRawExpr*>& filter_exprs)
{
int ret = OB_SUCCESS;
double sel = 1.0;
ObLogicalOperator* best_plan = NULL;
if (OB_FAIL(get_current_best_plan(best_plan))) {
LOG_WARN("failed to get best plan", K(ret));
} else if (OB_ISNULL(best_plan)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(ObOptEstSel::calculate_selectivity(
*best_plan->get_est_sel_info(), filter_exprs, sel, &get_predicate_selectivities()))) {
LOG_WARN("failed to calc selectivity", K(ret));
} else {
/*update the number of rows for the top_node*/
for (int64_t i = 0; OB_SUCC(ret) && i < candidates_.candidate_plans_.count(); i++) {
ObLogicalOperator* top = candidates_.candidate_plans_.at(i).plan_tree_;
if (OB_ISNULL(top)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(append(top->get_filter_exprs(), filter_exprs))) {
LOG_WARN("failed to append exprs", K(ret));
} else {
top->set_card(top->get_card() * sel);
}
}
}
return ret;
}
int ObLogPlan::find_and_replace_onetime_expr_with_param(
const ObIArray<std::pair<int64_t, ObRawExpr*>>& onetime_exprs, ObIArray<ObRawExpr*>& ori_exprs)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < ori_exprs.count(); i++) {
if (OB_FAIL(find_and_replace_onetime_expr_with_param(onetime_exprs, ori_exprs.at(i)))) {
LOG_WARN("failed to find and replace onetime expr with param", K(ret));
} else { /*do nothing*/
}
}
return ret;
}
int ObLogPlan::find_and_replace_onetime_expr_with_param(
const ObIArray<std::pair<int64_t, ObRawExpr*>>& onetime_exprs, ObRawExpr*& ori_expr)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(ori_expr) || OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ori_expr), K(get_stmt()), K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < onetime_exprs.count(); ++i) {
int64_t param_idx = onetime_exprs.at(i).first;
const ObRawExpr* onetime_expr = onetime_exprs.at(i).second;
ObRawExpr** addr_matched_expr = NULL;
if (ObOptimizerUtil::is_sub_expr(onetime_expr, ori_expr, addr_matched_expr)) {
ObRawExpr* exec_param_expr =
ObOptimizerUtil::find_param_expr(get_stmt()->get_exec_param_ref_exprs(), param_idx);
if (OB_ISNULL(exec_param_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else {
*addr_matched_expr = exec_param_expr;
}
} else { /* Do nothing */
}
}
}
return ret;
}
int ObLogPlan::allocate_subplan_filter_as_top(ObLogicalOperator*& top, const ObIArray<ObLogicalOperator*>& subquery_ops,
const ObIArray<std::pair<int64_t, ObRawExpr*>>& params,
const ObIArray<std::pair<int64_t, ObRawExpr*>>& onetime_exprs, const ObBitSet<>& initplan_idxs,
const ObBitSet<>& onetime_idxs, const ObIArray<ObRawExpr*>* filters)
{
int ret = OB_SUCCESS;
ObLogSubPlanFilter* spf_node = NULL;
if (OB_ISNULL(top)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(top), K(ret));
} else if (OB_ISNULL(spf_node = static_cast<ObLogSubPlanFilter*>(
get_log_op_factory().allocate(*this, LOG_SUBPLAN_FILTER)))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(spf_node), K(ret));
} else if (OB_FAIL(spf_node->add_child(top))) {
LOG_WARN("failed to add child", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < subquery_ops.count(); i++) {
if (OB_FAIL(spf_node->add_child(subquery_ops.at(i)))) {
LOG_WARN("failed to add children", K(ret));
} else { /*do nothing*/
}
}
if (OB_SUCC(ret)) {
if (NULL != filters && OB_FAIL(append(spf_node->get_filter_exprs(), *filters))) {
LOG_WARN("failed to append filter exprs", K(ret));
} else if (OB_FAIL(spf_node->add_exec_params(params))) {
LOG_WARN("failed to add exec params", K(ret));
} else if (OB_FAIL(spf_node->add_onetime_exprs(onetime_exprs))) {
LOG_WARN("failed to add onetime exprs", K(ret));
} else if (OB_FAIL(spf_node->add_initplan_idxs(initplan_idxs))) {
LOG_WARN("failed to add init plan idxs", K(ret));
} else if (OB_FAIL(spf_node->add_onetime_idxs(onetime_idxs))) {
LOG_WARN("failed to add onetime idxs", K(ret));
} else if (OB_FAIL(spf_node->compute_property())) {
LOG_WARN("failed to compute property", K(ret));
} else {
top = spf_node;
}
}
}
return ret;
}
int ObLogPlan::allocate_subplan_filter_as_top(
ObIArray<ObRawExpr*>& subquery_exprs, const bool is_filter, ObLogicalOperator*& top_node)
{
int ret = OB_SUCCESS;
All_Candidate_Plans all_plans;
if (OB_ISNULL(top_node)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(all_plans.candidate_plans_.push_back(CandidatePlan(top_node)))) {
LOG_WARN("failed to push back plans", K(ret));
} else {
all_plans.plain_plan_ = std::pair<double, int64_t>(top_node->get_cost(), 0);
if (OB_FAIL(candi_allocate_subplan_filter(subquery_exprs, is_filter, all_plans))) {
LOG_WARN("failed to allocate subplan filter", K(ret));
} else if (OB_UNLIKELY(1 != all_plans.candidate_plans_.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected arry count", K(ret));
} else {
top_node = all_plans.candidate_plans_.at(0).plan_tree_;
LOG_TRACE("succeed to allocate subplan filter as top", K(subquery_exprs), K(top_node->get_type()));
}
}
return ret;
}
int ObLogPlan::adjust_stmt_onetime_exprs(ObIArray<std::pair<int64_t, ObRawExpr*>>& onetime_exprs)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(get_stmt()), K(ret));
} else {
ObSEArray<ObRawExpr*, 8> old_exprs;
ObSEArray<ObRawExpr*, 8> new_exprs;
for (int64_t i = 0; OB_SUCC(ret) && i < onetime_exprs.count(); i++) {
ObRawExpr* temp_expr = NULL;
if (OB_ISNULL(onetime_exprs.at(i).second)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(old_exprs.push_back(onetime_exprs.at(i).second))) {
LOG_WARN("failed to push back old exprs", K(ret));
} else if (OB_ISNULL(temp_expr = ObOptimizerUtil::find_param_expr(
get_stmt()->get_exec_param_ref_exprs(), onetime_exprs.at(i).first))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(new_exprs.push_back(temp_expr))) {
LOG_WARN("get unexpected null", K(ret));
} else { /*do nothing*/
}
}
if (OB_SUCC(ret) && !new_exprs.empty()) {
if (OB_FAIL(get_stmt()->replace_inner_stmt_expr(old_exprs, new_exprs))) {
LOG_WARN("failed to replace inner stmt expr", K(ret));
} else { /*do nothing*/
}
}
}
return ret;
}
int ObLogPlan::remove_null_direction_for_order_item(
common::ObIArray<OrderItem>& order_items, common::ObIArray<ObOrderDirection>& directions)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(get_stmt())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid null stmt", K(ret));
} else {
const ObIArray<ObRawExpr*>& conditions = get_stmt()->get_condition_exprs();
int64_t N = order_items.count();
bool has_null_reject = false;
for (int64_t i = 0; OB_SUCC(ret) && i < N; i++) {
OrderItem& order_item = order_items.at(i);
if (OB_ISNULL(order_item.expr_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid null expr", K(ret), K(order_item.expr_));
} else if (OB_FAIL(ObTransformUtils::has_null_reject_condition(conditions, order_item.expr_, has_null_reject))) {
LOG_WARN("failed to check null rejection", K(ret));
} else if (has_null_reject) {
if (is_ascending_direction(order_item.order_type_)) {
order_item.order_type_ = default_asc_direction();
directions.at(i) = order_item.order_type_;
} else {
order_item.order_type_ = default_desc_direction();
directions.at(i) = order_item.order_type_;
}
}
}
}
return ret;
}
int ObLogPlan::need_alloc_child_for_subplan_filter(ObLogicalOperator* root, ObLogPlan* sub_plan, bool& need)
{
int ret = OB_SUCCESS;
need = true;
if (OB_ISNULL(root)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("root is null", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && need && i < root->get_num_of_child(); ++i) {
if (log_op_def::LOG_SUBPLAN_FILTER == root->get_type() && i > 0) {
if (OB_ISNULL(root->get_child(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("root->get_child(i) is null", K(ret), K(i));
} else if (root->get_child(i)->get_plan() == sub_plan) {
need = false;
} else { /* Do nothing */
}
} else { /* Do nothing */
}
}
for (int64_t i = 0; OB_SUCC(ret) && need && i < root->get_num_of_child(); ++i) {
if (OB_FAIL(need_alloc_child_for_subplan_filter(root->get_child(i), sub_plan, need))) {
LOG_WARN("need_alloc_subfilter fails", K(ret), K(need));
} else { /* Do nothing */
}
}
}
return ret;
}
int ObLogPlan::allocate_subplan_filter_as_below(common::ObIArray<ObRawExpr*>& exprs, ObLogicalOperator* top_node)
{
int ret = OB_SUCCESS;
ObLogicalOperator* first_child = NULL;
ObSEArray<ObRawExpr*, 4> subquery_exprs;
if (OB_ISNULL(top_node) || OB_ISNULL(first_child = top_node->get_child(ObLogicalOperator::first_child))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(top_node), K(first_child));
} else if (OB_FAIL(ObOptimizerUtil::get_subquery_exprs(exprs, subquery_exprs))) {
LOG_WARN("failed to get subquery exprs", K(ret));
} else if (subquery_exprs.empty()) {
/*do nothing*/
} else if (OB_FAIL(allocate_subplan_filter_as_top(subquery_exprs, false, first_child))) {
LOG_WARN("failed to allocate subplan filter", K(ret));
} else if (OB_ISNULL(first_child)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(first_child), K(ret));
} else {
top_node->set_child(0, first_child);
}
return ret;
}
int ObLogPlan::candi_allocate_count()
{
int ret = OB_SUCCESS;
ObRawExpr* limit_expr = NULL;
ObSEArray<ObRawExpr*, 4> filter_exprs;
ObSEArray<ObRawExpr*, 4> start_exprs;
ObSEArray<ObRawExpr*, 4> subquery_exprs;
if (OB_FAIL(ObOptimizerUtil::get_subquery_exprs(get_rownum_exprs(), subquery_exprs))) {
LOG_WARN("failed to get subquery exprs", K(ret));
} else if (!subquery_exprs.empty() && OB_FAIL(candi_allocate_subplan_filter(subquery_exprs, false))) {
LOG_WARN("failed to allocate subplan filter", K(ret));
} else if (OB_FAIL(classify_rownum_exprs(get_rownum_exprs(), filter_exprs, start_exprs, limit_expr))) {
LOG_WARN("failed to classify rownum exprs", K(ret));
} else {
double min_cost = 0.0;
int64_t min_idx = OB_INVALID_INDEX;
for (int64_t i = 0; OB_SUCC(ret) && i < candidates_.candidate_plans_.count(); ++i) {
CandidatePlan& plain_plan = candidates_.candidate_plans_.at(i);
if (OB_FAIL(allocate_count_as_top(plain_plan.plan_tree_, filter_exprs, start_exprs, limit_expr))) {
LOG_WARN("failed to allocate count operator", K(ret));
} else if (OB_ISNULL(plain_plan.plan_tree_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("null plan tree", K(ret));
} else if (plain_plan.plan_tree_->get_cost() < min_cost || OB_INVALID_INDEX == min_idx) {
min_cost = plain_plan.plan_tree_->get_cost();
min_idx = i;
} else { /*do nothing*/
}
}
if (OB_SUCC(ret)) {
if (OB_UNLIKELY(OB_INVALID_INDEX == min_idx)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Min idx is invalid", K(ret), K(min_idx));
} else {
candidates_.plain_plan_.second = min_idx;
candidates_.plain_plan_.first = min_cost;
}
}
}
return ret;
}
int ObLogPlan::allocate_count_as_top(ObLogicalOperator*& old_top, const common::ObIArray<ObRawExpr*>& filter_exprs,
const common::ObIArray<ObRawExpr*>& start_exprs, ObRawExpr* limit_expr)
{
int ret = OB_SUCCESS;
ObLogCount* count = NULL;
if (OB_ISNULL(old_top) || OB_ISNULL(get_stmt())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Unexpected null stmt", K(ret), K(old_top), K(get_stmt()));
} else if (OB_ISNULL(count = static_cast<ObLogCount*>(get_log_op_factory().allocate(*this, LOG_COUNT)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("Allocate memory for ObLogCount Failed", K(ret));
} else if (OB_FAIL(append(count->get_filter_exprs(), filter_exprs))) {
LOG_WARN("failed to append filter exprs", K(ret));
} else if (OB_FAIL(append(count->get_startup_exprs(), start_exprs))) {
LOG_WARN("failed to append start up exprs", K(ret));
} else {
count->set_rownum_limit_expr(limit_expr);
count->set_child(ObLogicalOperator::first_child, old_top);
// set cost and card
if (OB_FAIL(count->set_limit_size())) {
LOG_WARN("set limit size error", K(ret));
} else if (OB_FAIL(count->compute_property())) {
LOG_WARN("failed to compute property");
} else {
old_top = count;
}
}
return ret;
}
int ObLogPlan::classify_rownum_exprs(const ObIArray<ObRawExpr*>& rownum_exprs, ObIArray<ObRawExpr*>& filter_exprs,
ObIArray<ObRawExpr*>& start_exprs, ObRawExpr*& limit_expr)
{
int ret = OB_SUCCESS;
ObItemType limit_rownum_type = T_INVALID;
limit_expr = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < rownum_exprs.count(); i++) {
ObRawExpr *rownum_expr = rownum_exprs.at(i);
ObRawExpr *dummy = NULL;
ObRawExpr *const_expr = NULL;
ObItemType expr_type = T_INVALID;
bool dummy_flag = false;
if (OB_FAIL(ObOptimizerUtil::get_rownum_filter_info(
rownum_expr, expr_type, dummy, const_expr, dummy_flag))) {
LOG_WARN("failed to check is rownum expr used as filter", K(ret));
} else if (OB_FAIL(
classify_rownum_expr(expr_type, rownum_expr, const_expr, filter_exprs, start_exprs, limit_expr))) {
LOG_WARN("failed to classify rownum expr", K(ret));
} else if (const_expr == limit_expr) {
limit_rownum_type = expr_type;
}
}
if (OB_SUCC(ret) && OB_NOT_NULL(limit_expr)) {
ObRawExpr* limit_int_expr = NULL;
if (OB_FAIL(ObOptimizerUtil::convert_rownum_filter_as_limit(get_optimizer_context().get_expr_factory(),
get_optimizer_context().get_session_info(),
limit_rownum_type,
limit_expr,
limit_int_expr))) {
LOG_WARN("failed to transform rownum filter as limit", K(ret));
} else {
limit_expr = limit_int_expr;
}
}
if (OB_SUCC(ret)) {
LOG_TRACE("succeed to classify rownum exprs", K(filter_exprs.count()), K(start_exprs.count()), K(limit_expr));
}
return ret;
}
int ObLogPlan::classify_rownum_expr(const ObItemType expr_type, ObRawExpr* rownum_expr, ObRawExpr* left_const_expr,
common::ObIArray<ObRawExpr*>& filter_exprs, common::ObIArray<ObRawExpr*>& start_exprs, ObRawExpr*& limit_expr)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(rownum_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("null expr", K(rownum_expr), K(ret));
} else if ((expr_type == T_OP_LE || expr_type == T_OP_LT) && NULL == limit_expr && NULL != left_const_expr) {
limit_expr = left_const_expr;
} else if (expr_type == T_OP_GE || expr_type == T_OP_GT) {
if (OB_FAIL(start_exprs.push_back(rownum_expr))) {
LOG_WARN("failed to push back rownum expr", K(ret));
} else { /*do nothing*/
}
} else {
if (OB_FAIL(filter_exprs.push_back(rownum_expr))) {
LOG_WARN("failed to push back rownum expr", K(ret));
} else { /*do nothing*/
}
}
return ret;
}
int ObLogPlan::get_base_table_ids(ObIArray<uint64_t>& dependency_tables) const
{
int ret = OB_SUCCESS;
const ObDMLStmt* stmt = NULL;
const ObQueryCtx* query_ctx = NULL;
if (OB_ISNULL(stmt = get_stmt()) || OB_ISNULL(query_ctx = stmt->get_query_ctx())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("stmt is invalid", K(stmt), K(query_ctx));
}
ARRAY_FOREACH(query_ctx->table_partition_infos_, i)
{
const ObTablePartitionInfo* tbl_info = query_ctx->table_partition_infos_.at(i);
if (OB_ISNULL(tbl_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("tbl_info is null");
} else if (OB_FAIL(dependency_tables.push_back(tbl_info->get_ref_table_id()))) {
LOG_WARN("store dependency table failed", K(ret));
}
}
return ret;
}
int ObLogPlan::remove_duplicate_constraint(ObLocationConstraintContext& location_constraint, ObSqlCtx& sql_ctx) const
{
int ret = OB_SUCCESS;
if (OB_FAIL(remove_duplicate_base_table_constraint(location_constraint))) {
LOG_WARN("failed to remove duplicate base table constraint", K(ret));
} else if (OB_FAIL(remove_duplicate_pwj_constraint(location_constraint.strict_constraints_))) {
LOG_WARN("failed to remove duplicate strict pwj constraint", K(ret));
} else if (OB_FAIL(remove_duplicate_pwj_constraint(location_constraint.non_strict_constraints_))) {
LOG_WARN("failed to remove duplicate strict pwj constraint", K(ret));
} else if (OB_FAIL(sort_pwj_constraint(location_constraint))) {
LOG_WARN("failed to sort pwj constraint", K(ret));
} else if (OB_FAIL(sql_ctx.set_location_constraints(location_constraint, get_allocator()))) {
LOG_WARN("failed to set location constraints", K(ret));
} else {
LOG_TRACE("duplicated constraints removed", K(location_constraint));
}
return ret;
}
int ObLogPlan::remove_duplicate_base_table_constraint(ObLocationConstraintContext& location_constraint) const
{
int ret = OB_SUCCESS;
ObLocationConstraint& base_constraints = location_constraint.base_table_constraints_;
ObLocationConstraint unique_constraint;
for (int64_t i = 0; OB_SUCC(ret) && i < base_constraints.count(); ++i) {
bool find = false;
int64_t j = 0;
for (/* do nothing */; !find && j < unique_constraint.count(); ++j) {
if (base_constraints.at(i) == unique_constraint.at(j)) {
find = true;
}
}
if (find) {
--j;
if (OB_FAIL(replace_pwj_constraints(location_constraint.strict_constraints_, i, j))) {
LOG_WARN("failed to replace pwj constraints", K(ret));
} else if (OB_FAIL(replace_pwj_constraints(location_constraint.non_strict_constraints_, i, j))) {
LOG_WARN("failed to replace pwj constraints", K(ret));
}
} else if (OB_FAIL(unique_constraint.push_back(base_constraints.at(i)))) {
LOG_WARN("failed to push back location constraint", K(ret));
// do nothing
}
}
if (OB_SUCC(ret) && unique_constraint.count() != base_constraints.count()) {
if (OB_FAIL(base_constraints.assign(unique_constraint))) {
LOG_WARN("failed to assign base constraints", K(ret));
}
LOG_TRACE("inner duplicates removed", K(location_constraint));
}
return ret;
}
int ObLogPlan::replace_pwj_constraints(
ObIArray<ObPwjConstraint*>& constraints, const int64_t from, const int64_t to) const
{
int ret = OB_SUCCESS;
ObPwjConstraint* cur_cons = NULL;
ObSEArray<ObPwjConstraint*, 4> new_constraints;
for (int64_t i = 0; OB_SUCC(ret) && i < constraints.count(); ++i) {
if (OB_ISNULL(cur_cons = constraints.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
}
for (int64_t j = 0; OB_SUCC(ret) && j < cur_cons->count(); ++j) {
if (from == cur_cons->at(j)) {
if (OB_FAIL(cur_cons->remove(j))) {
LOG_WARN("failed to remove item", K(ret));
} else if (OB_FAIL(add_var_to_array_no_dup(*cur_cons, to))) {
LOG_WARN("failed to add var to array no dup");
}
}
}
if (OB_SUCC(ret)) {
if (cur_cons->count() > 1 && OB_FAIL(new_constraints.push_back(cur_cons))) {
LOG_WARN("failed to push back pwj constraint", K(ret));
}
}
}
if (OB_SUCC(ret) && new_constraints.count() < constraints.count()) {
if (OB_FAIL(constraints.assign(new_constraints))) {
LOG_WARN("failed to assign new constraints", K(ret));
}
}
return ret;
}
int ObLogPlan::remove_duplicate_pwj_constraint(ObIArray<ObPwjConstraint*>& pwj_constraints) const
{
int ret = OB_SUCCESS;
ObPwjConstraint *l_cons = NULL, *r_cons = NULL;
ObBitSet<> removed_idx;
ObLocationConstraintContext::InclusionType inclusion_result = ObLocationConstraintContext::NotSubset;
for (int64_t i = 0; OB_SUCC(ret) && i < pwj_constraints.count(); ++i) {
if (OB_ISNULL(l_cons = pwj_constraints.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(i));
} else if (l_cons->count() < 2) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected constraint const", K(ret), K(*l_cons));
} else if (removed_idx.has_member(i)) {
// do nothing
} else {
for (int64_t j = i + 1; OB_SUCC(ret) && j < pwj_constraints.count(); ++j) {
if (OB_ISNULL(r_cons = pwj_constraints.at(j))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(j));
} else if (OB_FAIL(ObLocationConstraintContext::calc_constraints_inclusion(l_cons, r_cons, inclusion_result))) {
LOG_WARN("failed to calculate inclusion relation between constraints", K(ret), K(*l_cons), K(*r_cons));
} else if (ObLocationConstraintContext::LeftIsSuperior == inclusion_result) {
// Left containts all the elements of the right, remove j
if (OB_FAIL(removed_idx.add_member(j))) {
LOG_WARN("failed to add member", K(ret), K(j));
}
} else if (ObLocationConstraintContext::RightIsSuperior == inclusion_result) {
// Right containts all the elements of the left, remove i
if (OB_FAIL(removed_idx.add_member(i))) {
LOG_WARN("failed to add member", K(ret), K(i));
}
}
}
}
}
// get unique pwj constraints
if (OB_SUCC(ret) && !removed_idx.is_empty()) {
ObSEArray<ObPwjConstraint*, 8> tmp_constraints;
if (OB_FAIL(tmp_constraints.assign(pwj_constraints))) {
LOG_WARN("failed to assign strict constraints", K(ret));
} else {
pwj_constraints.reuse();
for (int64_t i = 0; OB_SUCC(ret) && i < tmp_constraints.count(); ++i) {
if (!removed_idx.has_member(i) && OB_FAIL(pwj_constraints.push_back(tmp_constraints.at(i)))) {
LOG_WARN("failed to push back pwj constraint", K(ret));
}
}
}
}
return ret;
}
int ObLogPlan::set_all_exprs(const ObAllocExprContext& ctx)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < ctx.expr_producers_.count(); i++) {
const ObRawExpr* expr = ctx.expr_producers_.at(i).expr_;
OZ(all_exprs_.append(const_cast<ObRawExpr*>(expr)));
}
for (int64_t i = 0; OB_SUCC(ret) && i < ctx.group_replaced_exprs_.count(); i++) {
ObRawExpr* expr = ctx.group_replaced_exprs_.at(i).first;
OZ(all_exprs_.append(expr));
expr = ctx.group_replaced_exprs_.at(i).second;
OZ(all_exprs_.append(expr));
}
OZ(all_exprs_.append(ctx.not_produced_exprs_.get_expr_array()));
return ret;
}
int ObLogPlan::sort_pwj_constraint(ObLocationConstraintContext& location_constraint) const
{
int ret = OB_SUCCESS;
ObIArray<ObPwjConstraint*>& strict_pwj_cons = location_constraint.strict_constraints_;
ObIArray<ObPwjConstraint*>& non_strict_pwj_cons = location_constraint.non_strict_constraints_;
ObPwjConstraint* cur_cons = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < strict_pwj_cons.count(); ++i) {
if (OB_ISNULL(cur_cons = strict_pwj_cons.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(i));
} else {
std::sort(&cur_cons->at(0), &cur_cons->at(0) + cur_cons->count());
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < non_strict_pwj_cons.count(); ++i) {
if (OB_ISNULL(cur_cons = non_strict_pwj_cons.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(i));
} else {
std::sort(&cur_cons->at(0), &cur_cons->at(0) + cur_cons->count());
}
}
return ret;
}
/*
*
* Select 1 from t2 connect by level < t2.c1;
* We generate a ? expresstion from this level pseudo expr.
* Why ?
* The level pseudo expr result is generate by connect by join,
* and 'level < t2.c1' is a other join condition.
* When we generate code for this expression, we will find all input
* from children' output. We can find 't2.c1', but we can't find 'level'.
* This level pseudo is output of this connect by join.
* So finally, we use ? expr to solve this problem.
* Just generate this ? expr here, but remember not to replace.
* If replace level pesudo expr to ? expr, say 'level < 5' -> '? < 5',
* our optimizer will push this exprs down to the lowest level child.
* Do replace at code generate.
*
*/
int ObLogPlan::extract_level_pseudo_as_param(
const ObIArray<ObRawExpr*>& join_condition, ObIArray<std::pair<int64_t, ObRawExpr*>>& exec_param)
{
int ret = OB_SUCCESS;
ObDMLStmt* stmt = nullptr;
ObSEArray<ObRawExpr*, 16> level_exprs;
ObSQLSessionInfo* session_info = nullptr;
for (int64_t i = 0; i < join_condition.count() && OB_SUCC(ret); ++i) {
ObRawExpr* qual = join_condition.at(i);
if (OB_ISNULL(stmt = get_stmt()) || OB_ISNULL((get_optimizer_context()).get_session_info())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Null poiner passed in", K(stmt), K(ret));
} else if (OB_FAIL(find_connect_by_level(qual, level_exprs))) {
LOG_WARN("Failed to find level pseudo", K(ret));
} else if (level_exprs.empty()) {
// do nothing
} else {
ObOptimizerContext& opt_ctx = get_optimizer_context();
session_info = const_cast<ObSQLSessionInfo*>(opt_ctx.get_session_info());
std::pair<int64_t, ObRawExpr*> param_expr;
ObRawExpr* expr_element = level_exprs.at(0);
if (OB_FAIL(ObRawExprUtils::create_exec_param_expr(
stmt, opt_ctx.get_expr_factory(), expr_element, session_info, param_expr))) {
LOG_WARN("Create param for stmt error in extract_params_for_stmt", K(ret));
} else if (FALSE_IT(param_expr.second = expr_element)) {
} else if (OB_FAIL(exec_param.push_back(param_expr))) {
LOG_WARN("Failed to push back param expr", K(ret));
} else {
LOG_TRACE("Get a level pseudo as param", K(param_expr.first), K(*param_expr.second), K(*expr_element));
break;
}
}
}
return ret;
}
int ObLogPlan::find_connect_by_level(ObRawExpr* qual, ObIArray<ObRawExpr*>& level_exprs)
{
int ret = OB_SUCCESS;
ObRawConnectByLevelVisitor visitor;
if (OB_FAIL(visitor.check_connectby_filter(qual, level_exprs))) {
LOG_WARN("Failed to check connectby filter", K(ret));
} else {
LOG_TRACE("Find level pseudo", K(level_exprs), K(ret));
}
return ret;
}
int ObLogPlan::update_plans_interesting_order_info(ObIArray<CandidatePlan>& candidate_plans, const int64_t check_scope)
{
int ret = OB_SUCCESS;
int64_t match_info = OrderingFlag::NOT_MATCH;
if (check_scope == OrderingCheckScope::NOT_CHECK) {
// do nothing
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < candidate_plans.count(); i++) {
CandidatePlan& candidate_plan = candidate_plans.at(i);
if (OB_ISNULL(candidate_plan.plan_tree_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::compute_stmt_interesting_order(candidate_plan.plan_tree_->get_op_ordering(),
get_stmt(),
get_is_subplan_scan(),
get_equal_sets(),
get_const_exprs(),
check_scope,
match_info))) {
LOG_WARN("failed to update ordering match info", K(ret));
} else {
candidate_plan.plan_tree_->set_interesting_order_info(match_info);
}
}
}
return ret;
}
int ObLogPlan::prune_and_keep_best_plans(ObIArray<CandidatePlan>& candidate_plans)
{
int ret = OB_SUCCESS;
candidates_.candidate_plans_.reset();
double min_cost = 0.0;
int64_t min_idx = OB_INVALID_INDEX;
for (int64_t i = 0; OB_SUCC(ret) && i < candidate_plans.count(); i++) {
CandidatePlan& candidate_plan = candidate_plans.at(i);
if (OB_FAIL(add_candidate_plan(candidates_.candidate_plans_, candidate_plan))) {
LOG_WARN("failed to add candidate plan", K(ret));
} else { /*do nothing*/
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < candidates_.candidate_plans_.count(); i++) {
CandidatePlan& candidate_plan = candidates_.candidate_plans_.at(i);
if (min_idx == OB_INVALID_INDEX || candidate_plan.plan_tree_->get_cost() < min_cost) {
min_idx = i;
min_cost = candidate_plan.plan_tree_->get_cost();
} else { /*do nothing */
}
}
if (OB_SUCC(ret)) {
if (OB_UNLIKELY(min_idx == OB_INVALID_INDEX)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Min idx is invalid", K(ret), K(min_idx));
} else {
candidates_.plain_plan_.second = min_idx;
candidates_.plain_plan_.first = min_cost;
candidates_.first_new_op_ = NULL;
}
}
return ret;
}
int ObLogPlan::add_candidate_plan(ObIArray<CandidatePlan>& current_plans, const CandidatePlan& new_plan)
{
int ret = OB_SUCCESS;
bool should_add = true;
PlanRelationship plan_rel = UNCOMPARABLE;
for (int64_t i = current_plans.count() - 1; OB_SUCC(ret) && should_add && i >= 0; --i) {
if (OB_FAIL(compute_plan_relationship(current_plans.at(i), new_plan, plan_rel))) {
LOG_WARN("failed to compute plan relationship", K(current_plans.at(i)), K(new_plan), K(ret));
} else if (LEFT_DOMINATED == plan_rel || EQUAL == plan_rel) {
should_add = false;
} else if (RIGHT_DOMINATED == plan_rel) {
if (OB_FAIL(current_plans.remove(i))) {
LOG_WARN("failed to remove dominated plans", K(i), K(ret));
} else { /* do nothing*/
}
} else { /* do nothing */
}
}
if (OB_SUCC(ret)) {
if (should_add) {
if (OB_FAIL(current_plans.push_back(new_plan))) {
LOG_WARN("failed to add plan", K(ret));
} else { /*do nothing*/
}
} else { /*do nothing*/
}
}
return ret;
}
int ObLogPlan::compute_plan_relationship(
const CandidatePlan& first_plan, const CandidatePlan& second_plan, PlanRelationship& plan_rel)
{
int ret = OB_SUCCESS;
plan_rel = UNCOMPARABLE;
const ObDMLStmt* stmt = get_stmt();
if (OB_ISNULL(stmt) || OB_ISNULL(first_plan.plan_tree_) || OB_ISNULL(second_plan.plan_tree_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(stmt), K(first_plan.plan_tree_), K(second_plan.plan_tree_), K(ret));
} else {
int64_t left_dominated_count = 0;
int64_t right_dominated_count = 0;
int64_t uncompareable_count = 0;
// compare cost
if (fabs(first_plan.plan_tree_->get_cost() - second_plan.plan_tree_->get_cost()) < OB_DOUBLE_EPSINON) {
// do nothing
} else if (first_plan.plan_tree_->get_cost() < second_plan.plan_tree_->get_cost()) {
left_dominated_count++;
} else {
right_dominated_count++;
}
// compare interesting
bool left_prefix = false;
bool right_prefix = false;
const EqualSets& equal_sets = first_plan.plan_tree_->get_ordering_output_equal_sets();
bool first_has_interesting_order = first_plan.plan_tree_->has_any_interesting_order_info_flag();
bool second_has_interesting_order = second_plan.plan_tree_->has_any_interesting_order_info_flag();
if (!first_has_interesting_order && !second_has_interesting_order) {
// do nothing
} else if (first_has_interesting_order && !second_has_interesting_order) {
left_dominated_count++;
} else if (!first_has_interesting_order && second_has_interesting_order) {
right_dominated_count++;
} else {
if (OB_FAIL(ObOptimizerUtil::is_prefix_ordering(first_plan.plan_tree_->get_op_ordering(),
second_plan.plan_tree_->get_op_ordering(),
equal_sets,
get_const_exprs(),
left_prefix))) {
LOG_WARN("failed to compute prefix ordering relationship",
K(ret),
K(first_plan.plan_tree_->get_op_ordering()),
K(second_plan.plan_tree_->get_op_ordering()));
} else if (OB_FAIL(ObOptimizerUtil::is_prefix_ordering(second_plan.plan_tree_->get_op_ordering(),
first_plan.plan_tree_->get_op_ordering(),
equal_sets,
get_const_exprs(),
right_prefix))) {
LOG_WARN("failed to compute prefix ordering relationship",
K(ret),
K(first_plan.plan_tree_->get_op_ordering()),
K(second_plan.plan_tree_->get_op_ordering()));
} else if (left_prefix && right_prefix) {
// do nothing
} else if (left_prefix) {
right_dominated_count++;
} else if (right_prefix) {
left_dominated_count++;
} else {
uncompareable_count++;
}
}
bool is_first_pipeline = false;
bool is_second_pipeline = false;
// compare pipeline operator
if (OB_SUCC(ret) && stmt->has_limit()) {
if (OB_FAIL(is_pipeline_operator(first_plan, is_first_pipeline))) {
LOG_WARN("failed to examine pipeline operator", K(first_plan), K(ret));
} else if (OB_FAIL(is_pipeline_operator(second_plan, is_second_pipeline))) {
LOG_WARN("failed to examine pipeline operator", K(second_plan), K(ret));
} else if (is_first_pipeline == is_second_pipeline) {
// do nothing
} else if (is_first_pipeline && !is_second_pipeline) {
left_dominated_count++;
} else {
right_dominated_count++;
}
}
// compute final result
if (OB_SUCC(ret)) {
ObLogicalOperator* first = first_plan.plan_tree_;
ObLogicalOperator* second = second_plan.plan_tree_;
if (left_dominated_count > 0 && right_dominated_count == 0 && uncompareable_count == 0) {
plan_rel = LEFT_DOMINATED;
LOG_TRACE("first dominated second",
K(first->get_cost()),
K(first->get_op_ordering()),
K(is_first_pipeline),
K(second->get_cost()),
K(second->get_op_ordering()),
K(is_second_pipeline));
} else if (right_dominated_count > 0 && left_dominated_count == 0 && uncompareable_count == 0) {
plan_rel = RIGHT_DOMINATED;
LOG_TRACE("second dominated first",
K(second->get_cost()),
K(second->get_op_ordering()),
K(is_second_pipeline),
K(first->get_cost()),
K(first->get_op_ordering()),
K(is_first_pipeline));
} else if (left_dominated_count == 0 && right_dominated_count == 0 && uncompareable_count == 0) {
plan_rel = EQUAL;
} else {
plan_rel = UNCOMPARABLE;
}
}
}
return ret;
}
int ObLogPlan::is_pipeline_operator(const CandidatePlan& first_plan, bool& is_pipeline)
{
int ret = OB_SUCCESS;
is_pipeline = false;
// todo set op ?
if (OB_ISNULL(first_plan.plan_tree_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("null operator", K(ret));
} else if (first_plan.plan_tree_->get_type() == LOG_GROUP_BY) {
ObLogGroupBy* group_by = static_cast<ObLogGroupBy*>(first_plan.plan_tree_);
ObLogicalOperator* child = group_by->get_child(0);
if (OB_ISNULL(child)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null child operator", K(ret));
} else if (MERGE_AGGREGATE == group_by->get_algo() && LOG_SORT != child->get_type()) {
is_pipeline = true;
} else {
is_pipeline = false;
}
} else if (first_plan.plan_tree_->get_type() == LOG_DISTINCT) {
ObLogDistinct* distinct = static_cast<ObLogDistinct*>(first_plan.plan_tree_);
ObLogicalOperator* child = distinct->get_child(0);
if (OB_ISNULL(child)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null child operator", K(ret));
} else if (MERGE_AGGREGATE == distinct->get_algo() && LOG_SORT == child->get_type()) {
is_pipeline = false;
} else {
is_pipeline = true;
}
} else if (first_plan.plan_tree_->get_type() == LOG_WINDOW_FUNCTION) {
ObLogicalOperator* child = first_plan.plan_tree_->get_child(0);
if (OB_ISNULL(child)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(child));
} else if (LOG_SORT == child->get_type()) {
is_pipeline = false;
} else {
is_pipeline = true;
}
} else if (first_plan.plan_tree_->get_type() == LOG_SORT || first_plan.plan_tree_->get_type() == LOG_MATERIAL) {
is_pipeline = false;
} else {
is_pipeline = true;
}
return ret;
}
int ObLogPlan::calc_plan_resource()
{
int ret = OB_SUCCESS;
const ObDMLStmt* stmt = nullptr;
ObLogicalOperator* plan_root = nullptr;
int64_t max_parallel_thread_group_count = 0;
if (OB_ISNULL(stmt = get_stmt()) || OB_ISNULL(plan_root = get_plan_root())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else {
ObPxResourceAnalyzer analyzer;
if (OB_FAIL(analyzer.analyze(*plan_root, max_parallel_thread_group_count))) {
LOG_WARN("fail analyze px stmt thread group reservation count", K(ret));
} else {
LOG_INFO("max parallel thread group count", K(max_parallel_thread_group_count));
set_expected_worker_count(max_parallel_thread_group_count);
}
}
return ret;
}
// calculate whether all partitions in same server
int ObLogPlan::is_partition_in_same_server(const ObIArray<const ObPhyTableLocationInfo*>& phy_location_infos,
bool& is_same, bool& multi_part_table, ObAddr& first_addr)
{
int ret = OB_SUCCESS;
int64_t phy_location_count = phy_location_infos.count();
if (phy_location_count > 0) {
bool is_first = true;
ObReplicaLocation replica_location;
for (int64_t i = 0; OB_SUCC(ret) && is_same && i < phy_location_count; ++i) {
int64_t partition_location_count = phy_location_infos.at(i)->get_partition_cnt();
if (partition_location_count >= 2 && !multi_part_table) {
multi_part_table = true;
}
if (partition_location_count > 0) {
for (int64_t j = 0; OB_SUCC(ret) && is_same && j < partition_location_count; ++j) {
replica_location.reset();
const ObPhyPartitionLocationInfo& phy_part_loc_info =
phy_location_infos.at(i)->get_phy_part_loc_info_list().at(j);
if (OB_FAIL(phy_part_loc_info.get_selected_replica(replica_location))) {
LOG_WARN("fail to get selected replica", K(ret), K(phy_part_loc_info));
} else if (!replica_location.is_valid()) {
LOG_WARN("replica_location is invalid", K(ret), K(replica_location));
} else {
if (is_first) {
// get first replica
first_addr = replica_location.server_;
is_same = true;
is_first = false;
LOG_TRACE("part_location first replica", K(ret), K(replica_location));
} else {
is_same = (replica_location.server_ == first_addr);
LOG_TRACE("part_location replica", K(ret), K(i), K(replica_location));
}
}
}
} else {
LOG_DEBUG("there is no partition_locattion in this phy_location", KP(phy_location_infos.at(i)));
}
}
} else {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("phy_locations is empty");
}
return ret;
}
int ObLogPlan::collect_partition_location_info(
ObLogicalOperator* root, ObIArray<const ObPhyTableLocationInfo*>& phy_tbl_loc_info_list)
{
int ret = OB_SUCCESS;
int64_t child_count = root->get_num_of_child();
if (child_count != 0) {
for (int64_t i = 0; i < child_count && OB_SUCC(ret); ++i) {
if (OB_FAIL(collect_partition_location_info(root->get_child(i), phy_tbl_loc_info_list))) {
LOG_WARN("fail to get use px", K(ret));
}
}
}
if (OB_SUCC(ret) && LOG_TABLE_SCAN == root->get_type()) {
ObLogTableScan* tsc = static_cast<ObLogTableScan*>(root);
const ObTablePartitionInfo* tbl_part_info = tsc->get_table_partition_info();
if (OB_FAIL(phy_tbl_loc_info_list.push_back(&tbl_part_info->get_phy_tbl_location_info()))) {
LOG_WARN("fail to push back phy tble loc info", K(ret), K(tbl_part_info->get_phy_tbl_location_info()));
}
}
if (OB_SUCC(ret) && root->is_dml_operator()) {
ObLogDelUpd* dml = static_cast<ObLogDelUpd*>(root);
const ObTablePartitionInfo* tbl_part_info = &dml->get_table_partition_info();
if (OB_FAIL(phy_tbl_loc_info_list.push_back(&tbl_part_info->get_phy_tbl_location_info()))) {
LOG_WARN("fail to push back phy tble loc info", K(ret), K(tbl_part_info->get_phy_tbl_location_info()));
}
}
return ret;
}
int ObLogPlan::get_max_table_dop_for_plan(ObLogicalOperator* root, bool& disable_table_dop, int64_t& max_table_dop)
{
int ret = OB_SUCCESS;
if (disable_table_dop) {
max_table_dop = 1;
} else if (OB_ISNULL(root)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("log op is null", K(ret));
} else {
log_op_def::ObLogOpType op_type = root->get_type();
if (op_type == log_op_def::LOG_TABLE_SCAN || op_type == log_op_def::LOG_MV_TABLE_SCAN ||
op_type == log_op_def::LOG_TABLE_LOOKUP || op_type == log_op_def::LOG_INSERT ||
op_type == log_op_def::LOG_MERGE) {
uint64_t index_id = OB_INVALID_ID;
if (op_type == log_op_def::LOG_TABLE_LOOKUP) {
// LOOK UP
ObLogTableLookup* look_up = static_cast<ObLogTableLookup*>(root);
index_id = look_up->get_index_id();
} else if (op_type == log_op_def::LOG_TABLE_SCAN || op_type == log_op_def::LOG_MV_TABLE_SCAN) {
// SCAN
ObLogTableScan* table_scan = static_cast<ObLogTableScan*>(root);
index_id = table_scan->get_index_table_id();
} else {
// INSERT, MERGE
ObLogDelUpd* dml = static_cast<ObLogDelUpd*>(root);
index_id = dml->get_index_tid();
}
ObSchemaGetterGuard* schema_guard = NULL;
const ObTableSchema* table_schema = NULL;
if (index_id == OB_INVALID_ID) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("the index id is invalid", K(ret));
} else if (OB_ISNULL(schema_guard = get_optimizer_context().get_schema_guard())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("schema guard is null", K(ret));
} else if (is_link_table_id(index_id)) {
max_table_dop = 1;
disable_table_dop = true;
LOG_TRACE("due to the existence of link table, table dop is disable", K(ret), K(root->get_op_id()));
} else if (is_cte_table(index_id)) {
max_table_dop = 1;
disable_table_dop = true;
LOG_TRACE("due to the existence of cte table, table dop is disable", K(ret), K(root->get_op_id()));
} else if (OB_FAIL(schema_guard->get_table_schema(index_id, table_schema))) {
LOG_WARN("failed get table schema", K(ret), K(index_id));
} else if (OB_ISNULL(table_schema)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("the table schema is null", K(ret), K(index_id));
} else if (table_schema->get_dop() > max_table_dop) {
max_table_dop = table_schema->get_dop();
}
}
for (int i = 0; i < root->get_num_of_child() && OB_SUCC(ret) && !disable_table_dop; i++) {
ObLogicalOperator* child = root->get_child(i);
if (OB_FAIL(get_max_table_dop_for_plan(child, disable_table_dop, max_table_dop))) {
LOG_WARN("failed to get max table dop", K(ret));
}
}
}
return ret;
}
int ObLogPlan::init_plan_info()
{
int ret = OB_SUCCESS;
if (OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(get_stmt()), K(ret));
} else if (OB_FAIL(get_stmt()->get_stmt_equal_sets(equal_sets_, allocator_, false, EQUAL_SET_SCOPE::SCOPE_WHERE))) {
LOG_WARN("failed to get stmt equal sets", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::compute_const_exprs(get_stmt()->get_condition_exprs(), get_const_exprs()))) {
LOG_WARN("failed to compute const equivalent exprs", K(ret));
} else { /*do nothing*/
}
return ret;
}
EqualSets* ObLogPlan::create_equal_sets()
{
EqualSets* esets = NULL;
void* ptr = NULL;
if (OB_LIKELY(NULL != (ptr = get_allocator().alloc(sizeof(EqualSets))))) {
esets = new (ptr) EqualSets();
}
return esets;
}
ObEstSelInfo* ObLogPlan::create_est_sel_info(ObLogicalOperator* op)
{
void* ptr = NULL;
ObEstSelInfo* est_sel_info = NULL;
if (OB_LIKELY(NULL != (ptr = get_allocator().alloc(sizeof(ObEstSelInfo))))) {
est_sel_info = new (ptr) ObEstSelInfo(get_optimizer_context(), get_stmt(), op);
}
return est_sel_info;
}
ObJoinOrder* ObLogPlan::create_join_order(PathType type)
{
void* ptr = NULL;
ObJoinOrder* join_order = NULL;
if (OB_LIKELY(NULL != (ptr = get_allocator().alloc(sizeof(ObJoinOrder))))) {
join_order = new (ptr) ObJoinOrder(&get_allocator(), this, type);
}
return join_order;
}
int ObLogPlan::check_enable_plan_expiration(bool& enable) const
{
int ret = OB_SUCCESS;
ObSQLSessionInfo* session = NULL;
bool use_acs = false;
bool use_spm = false;
enable = false;
if (OB_ISNULL(get_stmt()) || OB_ISNULL(session = optimizer_context_.get_session_info())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("stmt is null", K(ret));
} else if (!get_stmt()->is_select_stmt()) {
// do nothing
} else if (get_phy_plan_type() != OB_PHY_PLAN_LOCAL && get_phy_plan_type() != OB_PHY_PLAN_REMOTE) {
// do nothing
} else if (OB_FAIL(session->get_adaptive_cursor_sharing(use_acs))) {
LOG_WARN("failed to check is acs enabled", K(ret));
} else if (use_acs) {
// do nothing
} else if (OB_FAIL(session->get_use_plan_baseline(use_spm))) {
LOG_WARN("failed to check is spm enabled", K(ret));
} else if (use_spm) {
// do nothing
} else {
const ObLogicalOperator* node = root_;
while (OB_SUCC(ret)) {
if (OB_ISNULL(node)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("node is null", K(ret));
} else if (node->get_num_of_child() == 1) {
node = node->get_child(ObLogicalOperator::first_child);
} else {
break;
}
}
if (OB_SUCC(ret) && node->is_table_scan()) {
enable = (static_cast<const ObLogTableScan*>(node)->get_diverse_path_count() >= 2);
}
}
return ret;
}
bool ObLogPlan::need_consistent_read() const
{
bool bret = true;
if (OB_NOT_NULL(root_) && OB_NOT_NULL(get_stmt()) && OB_NOT_NULL(get_stmt()->get_query_ctx())) {
if (stmt::T_INSERT == get_stmt()->get_stmt_type()) {
const ObInsertStmt* insert_stmt = static_cast<const ObInsertStmt*>(get_stmt());
if (!insert_stmt->is_replace() && !insert_stmt->get_insert_up()) {
uint64_t insert_table_id = insert_stmt->get_insert_table_id();
const ObQueryCtx* query_ctx = get_stmt()->get_query_ctx();
bool found_other_table = false;
for (int64_t i = 0; !found_other_table && i < query_ctx->table_partition_infos_.count(); ++i) {
ObTablePartitionInfo* part_info = query_ctx->table_partition_infos_.at(i);
if (OB_NOT_NULL(part_info) && part_info->get_table_id() != insert_table_id) {
found_other_table = true;
}
}
bret = found_other_table;
}
}
}
return bret;
}
int ObLogPlan::check_fullfill_safe_update_mode(ObLogicalOperator* op)
{
int ret = OB_SUCCESS;
bool is_sql_safe_updates = false;
bool is_not_fullfill = false;
const ObSQLSessionInfo* session_info = NULL;
if (OB_ISNULL(session_info = get_optimizer_context().get_session_info())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(get_optimizer_context().get_session_info()));
} else if (OB_FAIL(session_info->get_sql_safe_updates(is_sql_safe_updates))) {
LOG_WARN("failed to get is safe update mode", K(ret));
} else if (!is_sql_safe_updates) {
/*do nothing*/
} else if (OB_FAIL(do_check_fullfill_safe_update_mode(op, is_not_fullfill))) {
LOG_WARN("failed to check fullfill safe update mode", K(ret));
} else if (is_not_fullfill) {
ret = OB_ERR_SAFE_UPDATE_MODE_NEED_WHERE_OR_LIMIT;
LOG_WARN("using safe update mode need WHERE or LIMIT", K(ret));
}
return ret;
}
int ObLogPlan::do_check_fullfill_safe_update_mode(ObLogicalOperator* op, bool& is_not_fullfill)
{
int ret = OB_SUCCESS;
bool is_stack_overflow = false;
if (OB_ISNULL(op)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(op), K(ret));
} else if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
LOG_WARN("check stack overflow failed", K(ret));
} else if (is_stack_overflow) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("too deep recursive", K(ret));
} else if (is_not_fullfill) {
/*do nothing*/
} else if (op->get_type() == log_op_def::LOG_TABLE_SCAN) {
ObLogTableScan* table_scan = static_cast<ObLogTableScan*>(op);
is_not_fullfill |= table_scan->is_whole_range_scan();
} else {
for (int64_t i = 0; OB_SUCC(ret) && !is_not_fullfill && i < op->get_num_of_child(); ++i) {
if (OB_FAIL(do_check_fullfill_safe_update_mode(op->get_child(i), is_not_fullfill))) {
LOG_WARN("failed to check fullfill safe update mode", K(ret));
}
}
}
return ret;
}
int ObLogPlan::calc_and_set_exec_pwj_map(ObLocationConstraintContext& location_constraint) const
{
int ret = OB_SUCCESS;
ObExecContext* exec_ctx = get_optimizer_context().get_exec_ctx();
if (OB_ISNULL(exec_ctx)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (location_constraint.strict_constraints_.count() > 0 ||
location_constraint.non_strict_constraints_.count() > 0) {
ObIArray<LocationConstraint>& base_location_cons = location_constraint.base_table_constraints_;
ObIArray<ObPwjConstraint*>& strict_cons = location_constraint.strict_constraints_;
ObIArray<ObPwjConstraint*>& non_strict_cons = location_constraint.non_strict_constraints_;
const int64_t tbl_count = location_constraint.base_table_constraints_.count();
ObSEArray<PwjTable, 8> pwj_tables;
ObPwjComparer strict_pwj_comparer(true);
ObPwjComparer non_strict_pwj_comparer(false);
PWJPartitionIdMap pwj_map;
if (OB_FAIL(pwj_tables.prepare_allocate(tbl_count))) {
LOG_WARN("failed to prepare allocate pwj tables", K(ret));
} else if (OB_FAIL(pwj_map.create(8, ObModIds::OB_PLAN_EXECUTE))) {
LOG_WARN("create pwj map failed", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < tbl_count; ++i) {
for (int64_t j = 0; OB_SUCC(ret) && j < strict_cons.count(); ++j) {
const ObPwjConstraint* pwj_cons = strict_cons.at(j);
if (OB_ISNULL(pwj_cons) || OB_UNLIKELY(pwj_cons->count() <= 1)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected pwj constraint", K(ret), K(pwj_cons));
} else if (pwj_cons->at(0) == i) {
if (OB_FAIL(check_pwj_cons(
*pwj_cons, location_constraint.base_table_constraints_, pwj_tables, strict_pwj_comparer, pwj_map))) {
LOG_WARN("failed to check pwj cons", K(ret));
}
}
}
for (int64_t j = 0; OB_SUCC(ret) && j < non_strict_cons.count(); ++j) {
const ObPwjConstraint* pwj_cons = non_strict_cons.at(j);
if (OB_ISNULL(pwj_cons) || OB_UNLIKELY(pwj_cons->count() <= 1)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected pwj constraint", K(ret), K(pwj_cons));
} else if (pwj_cons->at(0) == i) {
if (OB_FAIL(check_pwj_cons(*pwj_cons,
location_constraint.base_table_constraints_,
pwj_tables,
non_strict_pwj_comparer,
pwj_map))) {
LOG_WARN("failed to check pwj cons", K(ret));
}
}
}
}
if (OB_SUCC(ret)) {
PWJPartitionIdMap* exec_pwj_map = NULL;
if (OB_FAIL(exec_ctx->get_pwj_map(exec_pwj_map))) {
LOG_WARN("failed to get exec pwj map", K(ret));
} else if (OB_FAIL(exec_pwj_map->reuse())) {
LOG_WARN("failed to reuse pwj map", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < base_location_cons.count(); ++i) {
if (!base_location_cons.at(i).is_multi_part_insert()) {
PartitionIdArray partition_id_array;
if (OB_FAIL(pwj_map.get_refactored(i, partition_id_array))) {
if (OB_HASH_NOT_EXIST == ret) {
ret = OB_SUCCESS;
} else {
LOG_WARN("failed to get refactored", K(ret));
}
} else if (OB_FAIL(
exec_pwj_map->set_refactored(base_location_cons.at(i).key_.table_id_, partition_id_array))) {
LOG_WARN("failed to set refactored", K(ret));
}
}
}
}
if (pwj_map.created()) {
int tmp_ret = OB_SUCCESS;
if (OB_UNLIKELY(OB_SUCCESS != (tmp_ret = pwj_map.destroy()))) {
LOG_WARN("failed to destroy pwj map", K(tmp_ret));
}
}
}
return ret;
}
int64_t ObLogPlan::check_pwj_cons(const ObPwjConstraint& pwj_cons,
const ObIArray<LocationConstraint>& base_location_cons, ObIArray<PwjTable>& pwj_tables, ObPwjComparer& pwj_comparer,
PWJPartitionIdMap& pwj_map) const
{
int ret = OB_SUCCESS;
bool is_same = true;
ObShardingInfo* first_sharding = base_location_cons.at(pwj_cons.at(0)).sharding_info_;
if (OB_ISNULL(first_sharding)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(first_sharding));
} else {
if (first_sharding->is_local() || first_sharding->is_remote()) {
// all tables in pwj constraint are local or remote
// alreay checked, do nothing
} else {
// distribute partition wise join
LOG_DEBUG("check pwj constraint", K(pwj_cons), K(base_location_cons), K(pwj_tables));
pwj_comparer.reset();
for (int64_t i = 0; OB_SUCC(ret) && is_same && i < pwj_cons.count(); ++i) {
const int64_t table_idx = pwj_cons.at(i);
PwjTable& table = pwj_tables.at(table_idx);
bool need_set_refactored = false;
if (OB_INVALID_ID == table.ref_table_id_) {
// pwj table no init
need_set_refactored = true;
ObShardingInfo* cur_sharding = base_location_cons.at(table_idx).sharding_info_;
if (OB_ISNULL(cur_sharding)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(table.init(*cur_sharding))) {
LOG_WARN("failed to init owj table with sharding info", K(ret));
} else {
table.ref_table_id_ = base_location_cons.at(table_idx).key_.ref_table_id_;
}
} else {
// pwj table already init, should find partition id array in pwj map
PartitionIdArray partition_id_array;
if (OB_FAIL(pwj_map.get_refactored(table_idx, partition_id_array))) {
if (OB_HASH_NOT_EXIST == ret) {
LOG_WARN("get refactored not find partition id array", K(ret));
} else {
LOG_WARN("failed to get refactored", K(ret));
}
} else if (OB_FAIL(table.ordered_partition_ids_.assign(partition_id_array))) {
LOG_WARN("failed to assign partition id array", K(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(pwj_comparer.add_table(table, is_same))) {
LOG_WARN("failed to add table", K(ret));
} else if (!is_same) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get not same table", K(*first_sharding), K(table));
} else if (need_set_refactored &&
OB_FAIL(pwj_map.set_refactored(table_idx, pwj_comparer.get_partition_id_group().at(i)))) {
LOG_WARN("failed to set refactored", K(ret));
}
}
}
}
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink