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

patch 4.0

Browse Source
This commit is contained in:
wangzelin.wzl
2022-10-24 10:34:53 +08:00
parent 4ad6e00ec3
commit 93a1074b0c
10533 changed files with 2588271 additions and 2299373 deletions
Download Patch File Download Diff File Expand all files Collapse all files

454
src/sql/optimizer/ob_log_insert_all.cpp
View File

@ -11,11 +11,9 @@
*/
#define USING_LOG_PREFIX SQL_OPT
#include "sql/optimizer/ob_del_upd_log_plan.h"
#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"
@ -33,72 +31,78 @@ using namespace oceanbase::share::schema;
const char* ObLogInsertAll::get_name() const
{
const char* ret = "MULTI TABLE INSERT";
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 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(", "))) {
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 (OB_FAIL(print_table_infos(ObString::make_string("columns"),
buf, buf_len, pos, type))) {
LOG_WARN("failed to print table infos", K(ret));
} else if (is_multi_conditions_insert()) {
if (is_multi_insert_first() && OB_FAIL(BUF_PRINTF(", multi_table_first(%s),\n ", "true"))) {
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) {
} else if (get_insert_all_table_info() != NULL) {
if (OB_ISNULL(get_stmt()) ||
OB_UNLIKELY(get_multi_insert_table_info()->count() != get_multi_column_convert_exprs()->count())) {
OB_UNLIKELY(get_table_list().count() != get_insert_all_table_info()->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));
LOG_WARN("get unexpected null", K(get_insert_all_table_info()->count()), K(get_stmt()),
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)) {
for (int64_t i = 0; OB_SUCC(ret) && i < get_insert_all_table_info()->count(); ++i) {
ObInsertAllTableInfo* table_info = get_insert_all_table_info()->at(i);
const TableItem *table_item = nullptr;
if (OB_ISNULL(table_info) ||
OB_ISNULL(table_item = get_stmt()->get_table_item_by_id(table_info->table_id_))) {
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
LOG_WARN("get unexpected null", K(table_item), K(table_info), K(ret));
} else if (table_info->when_cond_idx_ == pre_idx) {
BUF_PRINTF(",\"%.*s\"", table_item->table_name_.length(),table_item->table_name_.ptr());
} else if (table_info->when_cond_idx_ != -1) {//when
if (pre_idx != -1) {
BUF_PRINTF("}; ");
}
const ObIArray<ObRawExpr*>& when_exprs = get_multi_insert_table_info()->at(i).when_conds_expr_;
const ObIArray<ObRawExpr *> &when_exprs = table_info->when_cond_exprs_;
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
pre_idx = table_info->when_cond_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_;
pre_idx = table_info->when_cond_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 ");
int64_t cnt = 0;
for (int64_t i = 0; OB_SUCC(ret) && i < get_index_dml_infos().count(); ++i) {
const IndexDMLInfo *dml_info = get_index_dml_infos().at(i);
if (OB_ISNULL(dml_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("dml info is null", K(ret), K(dml_info));
} else if (!dml_info->is_primary_index_) {
continue;
} else {
const ObIArray<ObRawExpr *> &conv_exprs = dml_info->column_convert_exprs_;
EXPLAIN_PRINT_EXPRS(conv_exprs, type);
if (cnt < get_table_list().count() - 1) {
BUF_PRINTF(",\n ");
}
++ cnt;
}
}
}
@ -106,324 +110,88 @@ int ObLogInsertAll::print_my_plan_annotation(char* buf, int64_t& buf_len, int64_
}
} 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_)) {
int64_t cnt = 0;
for (int64_t i = 0; OB_SUCC(ret) && i < get_index_dml_infos().count(); ++i) {
const IndexDMLInfo *dml_info = get_index_dml_infos().at(i);
if (OB_ISNULL(dml_info)) {
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;
LOG_WARN("dml info is null", K(ret), K(dml_info));
} else if (!dml_info->is_primary_index_) {
continue;
} else {
/*do nothing*/
const ObIArray<ObRawExpr *> &conv_exprs = dml_info->column_convert_exprs_;
EXPLAIN_PRINT_EXPRS(conv_exprs, type);
if (cnt < get_table_list().count() - 1) {
BUF_PRINTF(",\n ");
}
++ cnt;
}
}
} 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 ObLogInsertAll::get_op_exprs(ObIArray<ObRawExpr*> &all_exprs)
{
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_)) {
if (OB_ISNULL(insert_all_table_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
LOG_WARN("get unexpected null", K(insert_all_table_info_), K(ret));
} else if (OB_FAIL(ObLogInsert::get_op_exprs(all_exprs))) {
LOG_WARN("failed to allocate expr pre", 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*/
}
for (int64_t i = 0; OB_SUCC(ret) && i < insert_all_table_info_->count(); ++i) {
if (OB_ISNULL(insert_all_table_info_->at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get null table info", K(ret), K(i));
} else if (OB_FAIL(append(all_exprs, insert_all_table_info_->at(i)->when_cond_exprs_))) {
LOG_WARN("failed to append exprs", 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;
}
// int ObLogInsertAll::generate_rowid_expr_for_trigger()
// {
// int ret = OB_SUCCESS;
// // oracle mode does not have replace or insert on duplicate
// if (lib::is_oracle_mode() && !has_instead_of_trigger()) {
// for (int64_t i = 0; OB_SUCC(ret) && i < get_index_dml_infos().count(); ++i) {
// bool has_trg = false;
// IndexDMLInfo *dml_info = get_index_dml_infos().at(i);
// if (OB_ISNULL(dml_info)) {
// ret = OB_ERR_UNEXPECTED;
// LOG_WARN("dml info is null", K(ret), K(dml_info));
// } else if (!dml_info->is_primary_index_) {
// // do nothing
// } else if (OB_FAIL(check_has_trigger(dml_info->ref_table_id_, has_trg))) {
// LOG_WARN("failed to check has trigger", K(ret));
// } else if (!has_trg) {
// // do nothing
// } else if (OB_FAIL(generate_old_rowid_expr(*dml_info))) {
// LOG_WARN("failed to generate rowid expr", K(ret));
// } else if (OB_FAIL(generate_insert_new_rowid_expr(*dml_info))) {
// LOG_WARN("failed to generate new rowid expr", K(ret));
// } else { /*do nothing*/ }
// }
// }
// return ret;
// }
// int ObLogInsertAll::generate_multi_part_partition_id_expr()
// {
// int ret = OB_SUCCESS;
// for (int64_t i = 0; OB_SUCC(ret) && i < get_index_dml_infos().count(); ++i) {
// if (OB_ISNULL(get_index_dml_infos().at(i))) {
// ret = OB_ERR_UNEXPECTED;
// LOG_WARN("index dml info is null", K(ret));
// } else if (OB_FAIL(generate_old_calc_partid_expr(*get_index_dml_infos().at(i)))) {
// LOG_WARN("failed to generate calc partid expr", K(ret));
// } else if (OB_FAIL(generate_insert_new_calc_partid_expr(*get_index_dml_infos().at(i)))) {
// LOG_WARN("failed to generate new calc partid expr", K(ret));
// } else { /*do nothing*/ }
// }
// return ret;
// }