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

init push

Browse Source
This commit is contained in:
oceanbase-admin
2021-05-31 22:56:52 +08:00
commit cea7de1475
7020 changed files with 5689869 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

429
src/sql/optimizer/ob_log_insert_all.cpp Normal file
View File

@ -0,0 +1,429 @@
/**
* 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_insert_stmt.h"
#include "ob_log_insert_all.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"
#include "sql/optimizer/ob_select_log_plan.h"
#include "sql/optimizer/ob_log_table_scan.h"
#include "sql/optimizer/ob_log_exchange.h"
#include "sql/engine/expr/ob_expr_column_conv.h"
using namespace oceanbase;
using namespace sql;
using namespace oceanbase::common;
using namespace share;
using namespace oceanbase::share::schema;
const char* ObLogInsertAll::get_name() const
{
const char* ret = "MULTI TABLE INSERT";
return ret;
}
int ObLogInsertAll::print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type)
{
int ret = OB_SUCCESS;
if (OB_FAIL(BUF_PRINTF(", "))) {
LOG_WARN("BUG_PRINTF fails", K(ret));
} else if (OB_FAIL(BUF_PRINTF("\n "))) {
LOG_WARN("BUG_PRINTF fails", K(ret));
} else { /* Do nothing */
}
const ObIArray<TableColumns>* columns = get_all_table_columns();
if (OB_SUCC(ret)) {
EXPLAIN_PRINT_COLUMNS(columns, type);
} else { /* Do nothing */
}
// print multi table info
if (OB_FAIL(ret)) {
} else if (is_multi_conditions_insert()) {
if (is_multi_insert_first() && OB_FAIL(BUF_PRINTF(", multi_table_first(%s),\n ", "true"))) {
LOG_WARN("BUG_PRINTF fails", K(ret));
} else if (!is_multi_insert_first() && OB_FAIL(BUF_PRINTF(",\n "))) {
LOG_WARN("BUG_PRINTF fails", K(ret));
} else if (get_multi_column_convert_exprs() != NULL && get_multi_insert_table_info() != NULL) {
if (OB_ISNULL(get_stmt()) ||
OB_UNLIKELY(get_multi_insert_table_info()->count() != get_multi_column_convert_exprs()->count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null",
K(get_multi_insert_table_info()->count()),
K(get_stmt()),
K(get_multi_column_convert_exprs()->count()),
K(ret));
} else {
int64_t pre_idx = -1;
for (int64_t i = 0; OB_SUCC(ret) && i < get_multi_insert_table_info()->count(); ++i) {
TableItem* table_item = get_stmt()->get_table_item_by_id(get_multi_insert_table_info()->at(i).table_id_);
if (OB_ISNULL(table_item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(table_item), K(ret));
} else if (get_multi_insert_table_info()->at(i).when_conds_idx_ == pre_idx) {
BUF_PRINTF(",\"%.*s\"", table_item->table_name_.length(), table_item->table_name_.ptr());
} else if (get_multi_insert_table_info()->at(i).when_conds_idx_ != -1) { // when
if (pre_idx != -1) {
BUF_PRINTF("}; ");
}
const ObIArray<ObRawExpr*>& when_exprs = get_multi_insert_table_info()->at(i).when_conds_expr_;
EXPLAIN_PRINT_EXPRS(when_exprs, type);
BUF_PRINTF(" then: table_list{");
BUF_PRINTF("\"%.*s\"", table_item->table_name_.length(), table_item->table_name_.ptr());
pre_idx = get_multi_insert_table_info()->at(i).when_conds_idx_;
} else { // else
BUF_PRINTF("}; ELSE: table_list{");
BUF_PRINTF("\"%.*s\"", table_item->table_name_.length(), table_item->table_name_.ptr());
pre_idx = get_multi_insert_table_info()->at(i).when_conds_idx_;
}
}
if (OB_SUCC(ret)) {
BUF_PRINTF("},\n ");
for (int64_t i = 0; OB_SUCC(ret) && i < get_multi_column_convert_exprs()->count(); ++i) {
const ObIArray<ObRawExpr*>& conv_exprs = get_multi_column_convert_exprs()->at(i);
EXPLAIN_PRINT_EXPRS(conv_exprs, type);
if (i < get_multi_column_convert_exprs()->count() - 1) {
BUF_PRINTF(",\n ");
}
}
}
}
}
} else if (OB_FAIL(BUF_PRINTF(",\n "))) {
LOG_WARN("BUG_PRINTF fails", K(ret));
} else if (get_multi_column_convert_exprs() != NULL) {
for (int64_t i = 0; OB_SUCC(ret) && i < get_multi_column_convert_exprs()->count(); ++i) {
const ObIArray<ObRawExpr*>& conv_exprs = get_multi_column_convert_exprs()->at(i);
EXPLAIN_PRINT_EXPRS(conv_exprs, type);
if (i < get_multi_column_convert_exprs()->count() - 1) {
BUF_PRINTF(",\n ");
}
}
}
return ret;
}
int ObLogInsertAll::check_output_dep_specific(ObRawExprCheckDep& checker)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(multi_value_columns_) || OB_ISNULL(multi_column_convert_exprs_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get null", K(multi_value_columns_), K(multi_column_convert_exprs_), K(ret));
} else if (OB_FAIL(ObLogInsert::check_output_dep_specific(checker))) {
LOG_WARN("ObLogDelUpd::check_output_dep_specific fails", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < multi_value_exprs_.count(); ++i) {
const ObIArray<ObRawExpr*>& value_exprs = multi_value_exprs_.at(i);
for (int64_t j = 0; OB_SUCC(ret) && j < value_exprs.count(); j++) {
if (OB_ISNULL(value_exprs.at(j))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(checker.check(*value_exprs.at(j)))) {
LOG_WARN("failed to check expr", K(j), K(ret));
} else { /*do nothing*/
}
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < multi_value_columns_->count(); ++i) {
const ObIArray<ObColumnRefRawExpr*>& value_columns = multi_value_columns_->at(i);
for (int64_t j = 0; OB_SUCC(ret) && j < value_columns.count(); j++) {
if (OB_ISNULL(value_columns.at(j))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(checker.check(*value_columns.at(j)))) {
LOG_WARN("failed to check expr", K(j), K(ret));
} else { /*do nothing*/
}
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < multi_column_convert_exprs_->count(); ++i) {
const ObIArray<ObRawExpr*>& convert_exprs = multi_column_convert_exprs_->at(i);
for (int64_t j = 0; OB_SUCC(ret) && j < convert_exprs.count(); j++) {
if (OB_ISNULL(convert_exprs.at(j))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(checker.check(*convert_exprs.at(j)))) {
LOG_WARN("failed to check expr", K(j), K(ret));
} else { /*do nothing*/
}
}
}
if (OB_SUCC(ret) && is_multi_conditions_insert_ && NULL != multi_insert_table_info_) {
int64_t pre_idx = -1;
for (int64_t i = 0; OB_SUCC(ret) && i < multi_insert_table_info_->count(); i++) {
if (multi_insert_table_info_->at(i).when_conds_idx_ != pre_idx &&
multi_insert_table_info_->at(i).when_conds_idx_ != -1) {
pre_idx = multi_insert_table_info_->at(i).when_conds_idx_;
for (int64_t j = 0; OB_SUCC(ret) && j < multi_insert_table_info_->at(i).when_conds_expr_.count(); j++) {
if (OB_ISNULL(multi_insert_table_info_->at(i).when_conds_expr_.at(j))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(checker.check(*multi_insert_table_info_->at(i).when_conds_expr_.at(j)))) {
LOG_WARN("failed to check expr", K(i), K(j), K(ret));
} else { /*do nothing*/
}
}
}
}
}
}
return ret;
}
int ObLogInsertAll::extract_value_exprs()
{
int ret = OB_SUCCESS;
ObOptimizerContext* opt_ctx = NULL;
if (OB_ISNULL(get_plan()) || OB_ISNULL(opt_ctx = &get_plan()->get_optimizer_context()) ||
OB_ISNULL(opt_ctx->get_session_info()) || OB_ISNULL(get_stmt()) || OB_UNLIKELY(!get_stmt()->is_insert_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else {
const ObInsertStmt* insert_stmt = static_cast<ObInsertStmt*>(get_stmt());
for (int64_t i = 0; OB_SUCC(ret) && i < insert_stmt->get_multi_insert_col_conv_funcs().count(); ++i) {
RawExprArray expr_without_col_conv;
RawExprArray column_conv_functions = insert_stmt->get_multi_insert_col_conv_funcs().at(i);
if (opt_ctx->get_session_info()->use_static_typing_engine()) {
if (OB_FAIL(multi_value_exprs_.push_back(column_conv_functions))) {
LOG_WARN("failed to push back column conv functions", K(ret));
} else { /*do nothing*/
}
} else if (OB_FAIL(multi_value_exprs_.push_back(column_conv_functions))) {
LOG_WARN("failed to push back column conv functions", K(ret));
} else { /*do nothing*/
}
}
}
return ret;
}
int ObLogInsertAll::allocate_expr_pre(ObAllocExprContext& ctx)
{
int ret = OB_SUCCESS;
ObSEArray<ObRawExpr*, 4> new_value_exprs;
ObSEArray<ObRawExpr*, 4> new_insert_cond_exprs;
// Since multi-table insertion may involve the constant value insertion of many tables, such as
// 500 tables, this time will cause the generation plan to be too slow,so unnecessary constant expr
// needs to be removed, Avoid too deep and time-consuming recursion.
for (int64_t i = 0; OB_SUCC(ret) && i < get_multi_value_exprs().count(); ++i) {
if (OB_FAIL(remove_const_expr(get_multi_value_exprs().at(i), new_value_exprs))) {
LOG_WARN("failed to remove const expr", K(ret));
} else if (OB_FAIL(add_exprs_to_ctx(ctx, new_value_exprs))) {
LOG_WARN("failed to add exprs to ctx", K(ret));
} else {
new_value_exprs.reset();
}
}
if (OB_SUCC(ret) && is_multi_conditions_insert_ && OB_NOT_NULL(multi_insert_table_info_)) {
int64_t pre_idx = -1;
for (int64_t i = 0; OB_SUCC(ret) && i < multi_insert_table_info_->count(); ++i) {
if (multi_insert_table_info_->at(i).when_conds_idx_ != pre_idx &&
multi_insert_table_info_->at(i).when_conds_idx_ != -1) {
if (OB_FAIL(remove_const_expr(multi_insert_table_info_->at(i).when_conds_expr_, new_insert_cond_exprs))) {
LOG_WARN("failed to remove const expr", K(ret));
} else if (OB_FAIL(add_exprs_to_ctx(ctx, new_insert_cond_exprs))) {
LOG_WARN("failed to add exprs to ctx", K(ret));
} else {
pre_idx = multi_insert_table_info_->at(i).when_conds_idx_;
new_insert_cond_exprs.reset();
}
}
}
}
return ret;
}
int ObLogInsertAll::allocate_expr_post(ObAllocExprContext& ctx)
{
int ret = OB_SUCCESS;
ObInsertStmt* stmt = static_cast<ObInsertStmt*>(get_stmt());
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(stmt), K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_column_size(); ++i) {
bool expr_is_required = false;
bool is_true = false;
const ColumnItem* col_item = stmt->get_column_item(i);
if (OB_ISNULL(col_item) || OB_ISNULL(col_item->expr_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table column is null", K(ret));
} else if (OB_FAIL(is_insert_table_id(col_item->table_id_, is_true))) {
LOG_WARN("failed to is insert table id", K(ret));
} else if (!is_true || !col_item->expr_->is_explicited_reference()) {
// do nothing
} else if (OB_FAIL(mark_expr_produced(col_item->expr_, branch_id_, id_, ctx, expr_is_required))) {
LOG_WARN("failed to mark expr produced", K(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(ObLogDelUpd::allocate_expr_post(ctx))) {
LOG_WARN("failed to allocate expr post", K(ret));
}
}
}
return ret;
}
int ObLogInsertAll::need_multi_table_dml(AllocExchContext& ctx, ObShardingInfo& sharding_info, bool& is_needed)
{
int ret = OB_SUCCESS;
const ObTableSchema* tbl_schema = NULL;
ObShardingInfo target_sharding_info;
ObSchemaGetterGuard* schema_guard = NULL;
ObInsertStmt* insert_stmt = static_cast<ObInsertStmt*>(get_stmt());
is_needed = false;
// When there is a row-before insert trigger, the original inserted data is allowed to be invalid
//(which does not correspond to any partition), so the trigger check operation is brought to the forefront.
if (OB_ISNULL(get_plan()) || OB_ISNULL(schema_guard = get_plan()->get_optimizer_context().get_schema_guard())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(get_plan()), K(schema_guard));
} else if (OB_FAIL(schema_guard->get_table_schema(get_index_tid(), tbl_schema))) {
LOG_WARN("get table schema from schema guard failed", K(ret));
} else if (OB_ISNULL(tbl_schema)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table schema is null", K(ret), K(insert_stmt));
} else if (OB_FAIL(generate_sharding_info(target_sharding_info))) {
LOG_WARN("failed to generate sharding info", K(ret));
}
if (OB_FAIL(ret)) {
} else if (target_sharding_info.is_distributed()) {
is_needed = true;
ctx.plan_type_ = AllocExchContext::DistrStat::DISTRIBUTED;
LOG_TRACE("set multi part insert plan to dist", K(ctx.plan_type_));
} else {
is_needed = true;
}
UNUSED(sharding_info);
return ret;
}
int ObLogInsertAll::allocate_exchange_post(AllocExchContext* ctx)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(ctx) || OB_ISNULL(get_plan()) || OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ctx), K(get_plan()), K(ret));
} else if (OB_FAIL(ObLogDelUpd::allocate_exchange_post(ctx))) {
LOG_WARN("failed to do allocate exchange post", K(ret));
} else if (ctx->exchange_allocated_ || ctx->plan_type_ == AllocExchContext::DistrStat::DISTRIBUTED) {
// The LOCAL type multi part insert plan does not add the table partition info corresponding to the insert table
if (OB_FAIL(get_plan()->add_global_table_partition_info(&table_partition_info_))) {
LOG_WARN("failed to add table partition info", K(ret));
} else { /*do nothing*/
}
}
if (OB_SUCC(ret)) {
ObInsertStmt* insert_stmt = static_cast<ObInsertStmt*>(get_stmt());
ObIArray<TableColumns>& table_columns = insert_stmt->get_all_table_columns();
for (int64_t i = 1; OB_SUCC(ret) && i < table_columns.count(); ++i) {
ObIArray<IndexDMLInfo>& index_infos = table_columns.at(i).index_dml_infos_;
for (int64_t j = 0; OB_SUCC(ret) && j < index_infos.count(); ++j) {
ObRawExpr* expr = NULL;
if (OB_FAIL(gen_calc_part_id_expr(index_infos.at(j).loc_table_id_, index_infos.at(j).index_tid_, expr))) {
LOG_WARN("fail to gen calc part id expr", K(ret));
} else if (index_infos.at(j).calc_part_id_exprs_.push_back(expr)) {
LOG_WARN("fail to push back calc part id expr", K(ret));
}
}
}
}
return ret;
}
int ObLogInsertAll::is_insert_table_id(uint64_t table_id, bool& is_true) const
{
is_true = false;
int ret = OB_SUCCESS;
const ObInsertStmt* stmt = static_cast<const ObInsertStmt*>(get_stmt());
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(stmt));
} else if (stmt->is_multi_insert_stmt()) {
// The last table of multi table insert stmt is subquery
for (int64_t i = 0; OB_SUCC(ret) && !is_true && i < stmt->get_table_items().count() - 1; ++i) {
TableItem* table_item = stmt->get_table_items().at(i);
if (OB_ISNULL(table_item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(table_item));
} else if (table_id == table_item->table_id_) {
is_true = true;
} else {
/*do nothing*/
}
}
} else {
is_true = (table_id == stmt->get_insert_table_id());
}
return ret;
}
int ObLogInsertAll::get_part_hint(const ObPartHint*& part_hint, const uint64_t table_id) const
{
int ret = OB_SUCCESS;
bool found = false;
part_hint = NULL;
for (int64_t i = 0; OB_SUCC(ret) && !found && i < part_hints_.count(); i++) {
if (OB_ISNULL(part_hints_.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(part_hints_.at(i)));
} else if (table_id == part_hints_.at(i)->table_id_) {
part_hint = part_hints_.at(i);
found = true;
}
}
return ret;
}
int ObLogInsertAll::inner_replace_generated_agg_expr(
const ObIArray<std::pair<ObRawExpr*, ObRawExpr*>>& to_replace_exprs)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(multi_column_convert_exprs_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < multi_column_convert_exprs_->count(); ++i) {
if (OB_FAIL(
replace_exprs_action(to_replace_exprs, const_cast<RawExprArray&>(multi_column_convert_exprs_->at(i))))) {
LOG_WARN("failed to replace_expr_action", K(ret));
} else { /*do nothing*/
}
}
}
return ret;
}
int ObLogInsertAll::remove_const_expr(const ObIArray<ObRawExpr*>& old_exprs, ObIArray<ObRawExpr*>& new_exprs) const
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < old_exprs.count(); ++i) {
if (OB_ISNULL(old_exprs.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null");
} else if (old_exprs.at(i)->has_const_or_const_expr_flag()) {
/*do nothing */
} else if (OB_FAIL(new_exprs.push_back(old_exprs.at(i)))) {
LOG_WARN("failed to push back old exprs", K(ret));
} else { /*do nothing*/
}
}
return ret;
}