hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
03001c1fe35e7e840a29b21413c5e5acbfc44b93
oceanbase/src/sql/optimizer/ob_log_merge.cpp
oceanbase-admin cea7de1475 init push
2021-05-31 22:56:52 +08:00

370 lines
14 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 "sql/resolver/dml/ob_merge_stmt.h"
#include "sql/optimizer/ob_log_merge.h"
#include "lib/container/ob_se_array.h"
#include "lib/container/ob_se_array_iterator.h"
#include "share/partition_table/ob_partition_location_cache.h"
#include "sql/ob_phy_table_location.h"
#include "sql/code_generator/ob_expr_generator_impl.h"
#include "sql/ob_sql_utils.h"
#include "sql/optimizer/ob_log_plan.h"
using namespace oceanbase;
using namespace sql;
using namespace oceanbase::common;
using namespace share;
using namespace oceanbase::share::schema;
int ObLogMerge::print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type)
{
int ret = OB_SUCCESS;
if (OB_FAIL(ObLogInsert::print_my_plan_annotation(buf, buf_len, pos, type))) {
LOG_WARN("fail to print plan annotaqqtion", K(ret));
} else if (OB_FAIL(BUF_PRINTF(", "))) {
LOG_WARN("BUF_PRINTF fails", K(ret));
} else if (OB_FAIL(BUF_PRINTF("\n "))) {
LOG_WARN("BUF_PRINTF fails", K(ret));
} else if (OB_ISNULL(match_condition_exprs_) || OB_ISNULL(update_condition_exprs_) ||
OB_ISNULL(insert_condition_exprs_) || OB_ISNULL(delete_condition_exprs_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("some condition exprs is NULL",
KPC(match_condition_exprs_),
KPC(update_condition_exprs_),
KPC(insert_condition_exprs_),
KPC(delete_condition_exprs_),
K(ret));
} else {
const ObIArray<ObRawExpr*>& match_conds = *match_condition_exprs_;
const ObIArray<ObRawExpr*>& update_conds = *update_condition_exprs_;
const ObIArray<ObRawExpr*>& delete_conds = *delete_condition_exprs_;
const ObIArray<ObRawExpr*>& insert_conds = *insert_condition_exprs_;
EXPLAIN_PRINT_EXPRS(match_conds, type);
if (OB_SUCC(ret) && OB_FAIL(BUF_PRINTF(", "))) {
LOG_WARN("BUF_PRINTF fails", K(ret));
}
EXPLAIN_PRINT_EXPRS(insert_conds, type);
if (OB_FAIL(ret)) {
} else if (OB_FAIL(BUF_PRINTF(", "))) {
LOG_WARN("BUF_PRINTF fails", K(ret));
} else if (OB_FAIL(BUF_PRINTF("\n "))) {
LOG_WARN("BUF_PRINTF fails", K(ret));
}
EXPLAIN_PRINT_EXPRS(update_conds, type);
if (OB_SUCC(ret) && OB_FAIL(BUF_PRINTF(", "))) {
LOG_WARN("BUF_PRINTF fails", K(ret));
}
EXPLAIN_PRINT_EXPRS(delete_conds, type);
}
return ret;
}
int ObLogMerge::add_all_table_assignments_to_ctx(ObAllocExprContext& ctx)
{
int ret = OB_SUCCESS;
int64_t table_cnt = tables_assignments_->count();
if (table_cnt == 0) {
// do nothing
} else if (table_cnt == 1) {
ObSEArray<ObRawExpr*, 8> exprs;
const ObAssignments& assigns = tables_assignments_->at(0).assignments_;
for (int64_t i = 0; OB_SUCC(ret) && i < assigns.count(); i++) {
if (OB_ISNULL(assigns.at(i).expr_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(exprs.push_back(assigns.at(i).expr_))) {
LOG_WARN("failed to push back exprs", K(ret));
} else { /*do nothing*/
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(add_merge_exprs_to_ctx(ctx, exprs))) {
LOG_WARN("failed to add exprs to ctx", K(ret));
} else { /*do nothing*/
}
}
} else {
LOG_WARN("unexpected assignment table count", K(table_cnt));
}
return ret;
}
int ObLogMerge::allocate_expr_pre(ObAllocExprContext& ctx)
{
int ret = OB_SUCCESS;
if (OB_FAIL(add_all_table_assignments_to_ctx(ctx))) {
LOG_WARN("fail to add all table assignment", K(ret));
} else if (NULL != match_condition_exprs_ && OB_FAIL(add_merge_exprs_to_ctx(ctx, *match_condition_exprs_))) {
LOG_WARN("fail to add expr to ctx", K(ret));
} else if (NULL != insert_condition_exprs_ && OB_FAIL(add_merge_exprs_to_ctx(ctx, *insert_condition_exprs_))) {
LOG_WARN("fail to add expr to ctx", K(ret));
} else if (NULL != update_condition_exprs_ && OB_FAIL(add_merge_exprs_to_ctx(ctx, *update_condition_exprs_))) {
LOG_WARN("fail to add expr to ctx", K(ret));
} else if (OB_FAIL(add_delete_exprs_to_ctx(ctx))) {
LOG_WARN("fail to add expr to ctx", K(ret));
} else if (nullptr != value_vector_ && OB_FAIL(add_merge_exprs_to_ctx(ctx, *value_vector_))) {
LOG_WARN("fail to add expr to ctx", K(ret));
} else if (OB_FAIL(add_all_source_table_columns_to_ctx(ctx))) {
LOG_WARN("fail to add source table columns to ctx", K(ret));
} else if (OB_FAIL(ObLogicalOperator::allocate_expr_pre(ctx))) {
LOG_WARN("failed to add parent need expr", K(ret));
}
return ret;
}
int ObLogMerge::add_merge_exprs_to_ctx(ObAllocExprContext& ctx, const ObIArray<ObRawExpr*>& exprs)
{
int ret = OB_SUCCESS;
ObLogicalOperator* child = NULL;
uint64_t producer_id = OB_INVALID_ID;
ObSEArray<ObRawExpr*, 8> subquery_exprs;
ObSEArray<ObRawExpr*, 8> non_subquery_exprs;
if (OB_FAIL(classify_merge_subquery_expr(exprs, subquery_exprs, non_subquery_exprs))) {
LOG_WARN("failed to classify merge subquery exprs", K(ret));
} else if (!non_subquery_exprs.empty() && OB_FAIL(add_exprs_to_ctx(ctx, non_subquery_exprs))) {
LOG_WARN("failed to add exprs to ctx", K(ret));
} else if (subquery_exprs.empty()) {
/*do nothing*/
} else if (OB_ISNULL(child = get_child(ObLogicalOperator::first_child))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(get_next_producer_id(child, producer_id))) {
LOG_WARN("failed to get next producer id", K(ret));
} else if (OB_FAIL(add_exprs_to_ctx(ctx, subquery_exprs, producer_id))) {
LOG_WARN("failed to add exprs to ctx", K(ret));
} else { /*do nothing*/
}
return ret;
}
int ObLogMerge::classify_merge_subquery_expr(
const ObIArray<ObRawExpr*>& exprs, ObIArray<ObRawExpr*>& subquery_exprs, ObIArray<ObRawExpr*>& non_subquery_exprs)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(get_plan())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < exprs.count(); i++) {
bool has_subquery = false;
if (OB_ISNULL(exprs.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::check_expr_contain_subquery(
exprs.at(i), &get_plan()->get_onetime_exprs(), has_subquery))) {
LOG_WARN("failed to check whether contain subquery", K(ret));
} else if (has_subquery) {
ret = subquery_exprs.push_back(exprs.at(i));
} else {
ret = non_subquery_exprs.push_back(exprs.at(i));
}
}
}
return ret;
}
int ObLogMerge::add_delete_exprs_to_ctx(ObAllocExprContext& ctx)
{
int ret = OB_SUCCESS;
ObRawExpr* expr = NULL;
ObSEArray<ObRawExpr*, 8> subquery_exprs;
ObSEArray<ObRawExpr*, 8> non_subquery_exprs;
if (OB_ISNULL(delete_condition_exprs_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(classify_merge_subquery_expr(*delete_condition_exprs_, subquery_exprs, non_subquery_exprs))) {
LOG_WARN("failed to classify merge subquery exprs", K(ret));
} else {
if (!non_subquery_exprs.empty()) {
ObSEArray<ObRawExpr*, 8> delete_column_exprs;
if (OB_FAIL(ObRawExprUtils::extract_column_exprs(non_subquery_exprs, delete_column_exprs))) {
LOG_WARN("fail to extract column exprs", K(ret));
} else if (OB_FAIL(add_exprs_to_ctx(ctx, delete_column_exprs))) {
LOG_WARN("fail to add exprs to ctx", K(ret));
} else { /*do nothing*/
}
}
if (OB_SUCC(ret) && !subquery_exprs.empty()) {
ObLogicalOperator* child = NULL;
uint64_t producer_id = OB_INVALID_ID;
if (OB_ISNULL(child = get_child(ObLogicalOperator::first_child))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(get_next_producer_id(child, producer_id))) {
LOG_WARN("failed to get next producer id", K(ret));
} else if (OB_FAIL(add_exprs_to_ctx(ctx, subquery_exprs, producer_id))) {
LOG_WARN("failed to add exprs to ctx", K(ret));
} else { /*do nothing*/
}
}
}
return ret;
}
int ObLogMerge::check_output_dep_specific(ObRawExprCheckDep& checker)
{
int ret = OB_SUCCESS;
if (OB_FAIL(ObLogInsert::check_output_dep_specific(checker))) {
LOG_WARN("ObLogDelUpd::check_output_dep_specific fails", K(ret));
} else {
if (NULL != match_condition_exprs_) {
for (int64_t i = 0; OB_SUCC(ret) && i < match_condition_exprs_->count(); i++) {
if (OB_ISNULL(match_condition_exprs_->at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(checker.check(*match_condition_exprs_->at(i)))) {
LOG_WARN("failed to check expr", K(ret));
} else { /*do nothing*/
}
}
}
if (OB_SUCC(ret) && NULL != insert_condition_exprs_) {
for (int64_t i = 0; OB_SUCC(ret) && i < insert_condition_exprs_->count(); i++) {
if (OB_ISNULL(insert_condition_exprs_->at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(checker.check(*insert_condition_exprs_->at(i)))) {
LOG_WARN("failed to check expr", K(ret));
} else { /*do nothing*/
}
}
}
if (OB_SUCC(ret) && NULL != update_condition_exprs_) {
for (int64_t i = 0; OB_SUCC(ret) && i < update_condition_exprs_->count(); i++) {
if (OB_ISNULL(update_condition_exprs_->at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(checker.check(*update_condition_exprs_->at(i)))) {
LOG_WARN("failed to check expr", K(ret));
} else { /*do nothing*/
}
}
}
if (OB_SUCC(ret) && NULL != delete_condition_exprs_) {
for (int64_t i = 0; OB_SUCC(ret) && i < delete_condition_exprs_->count(); i++) {
if (OB_ISNULL(delete_condition_exprs_->at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(checker.check(*delete_condition_exprs_->at(i)))) {
LOG_WARN("failed to check expr", K(ret));
} else { /*do nothing*/
}
}
}
if (OB_SUCC(ret) && NULL != value_vector_) {
for (int64_t i = 0; OB_SUCC(ret) && i < value_vector_->count(); i++) {
if (OB_ISNULL(value_vector_->at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(checker.check(*value_vector_->at(i)))) {
LOG_WARN("failed to check expr", K(ret));
} else { /*do nothing*/
}
}
}
if (OB_SUCC(ret) && NULL != rowkey_exprs_) {
for (int64_t i = 0; OB_SUCC(ret) && i < rowkey_exprs_->count(); i++) {
if (OB_ISNULL(rowkey_exprs_->at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(checker.check(*rowkey_exprs_->at(i)))) {
LOG_WARN("failed to check expr", K(ret));
} else { /*do nothing*/
}
}
}
}
return ret;
}
uint64_t ObLogMerge::hash(uint64_t seed) const
{
if (NULL != match_condition_exprs_) {
HASH_PTR_ARRAY(*match_condition_exprs_, seed);
}
if (NULL != insert_condition_exprs_) {
HASH_PTR_ARRAY(*insert_condition_exprs_, seed);
}
if (NULL != update_condition_exprs_) {
HASH_PTR_ARRAY(*update_condition_exprs_, seed);
}
if (NULL != delete_condition_exprs_) {
HASH_PTR_ARRAY(*delete_condition_exprs_, seed);
}
if (NULL != value_vector_) {
HASH_PTR_ARRAY(*value_vector_, seed);
}
if (NULL != rowkey_exprs_) {
HASH_PTR_ARRAY(*rowkey_exprs_, seed);
}
seed = ObLogicalOperator::hash(seed);
return seed;
}
int ObLogMerge::add_all_source_table_columns_to_ctx(ObAllocExprContext& ctx)
{
int ret = OB_SUCCESS;
CK(OB_NOT_NULL(table_columns_), !table_columns_->empty());
OZ(add_exprs_to_ctx(ctx, *table_columns_));
return ret;
}
int ObLogMerge::inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const
{
int ret = OB_SUCCESS;
OZ(ObLogDelUpd::inner_append_not_produced_exprs(raw_exprs));
if (OB_SUCC(ret)) {
if (nullptr != match_condition_exprs_ && OB_FAIL(raw_exprs.append(*match_condition_exprs_))) {
LOG_WARN("append_array_no_dup failed", K(ret));
}
if (nullptr != insert_condition_exprs_ && OB_FAIL(raw_exprs.append(*insert_condition_exprs_))) {
LOG_WARN("append_array_no_dup failed", K(ret));
}
if (nullptr != update_condition_exprs_ && OB_FAIL(raw_exprs.append(*update_condition_exprs_))) {
LOG_WARN("append_array_no_dup failed", K(ret));
}
if (nullptr != delete_condition_exprs_ && OB_FAIL(raw_exprs.append(*delete_condition_exprs_))) {
LOG_WARN("append_array_no_dup failed", K(ret));
}
if (nullptr != rowkey_exprs_ && OB_FAIL(raw_exprs.append(*rowkey_exprs_))) {
LOG_WARN("append_array_no_dup failed", K(ret));
}
}
OZ(ObLogInsert::inner_append_not_produced_exprs(raw_exprs));
return ret;
}
const char* ObLogMerge::get_name() const
{
const char* ret = "NOT SET";
if (is_multi_part_dml()) {
ret = "MULTI PARTITION MERGE";
} else {
ret = "MERGE";
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink