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

Do not report ERROR when sample rate equals 100

Browse Source
This commit is contained in:
ZenoWang
2024-02-06 14:49:31 +00:00
committed by ob-robot
parent 1f1d5c08ae
commit c8ef409bf3
3710 changed files with 486984 additions and 3083329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

383
src/sql/resolver/dml/ob_insert_resolver.cpp
View File

@ -43,8 +43,7 @@ ObInsertResolver::ObInsertResolver(ObResolverParams &params)
: ObDelUpdResolver(params),
row_count_(0),
sub_select_resolver_(NULL),
autoinc_col_added_(false),
is_mock_(false)
autoinc_col_added_(false)
{
params.contain_dml_ = true;
}
@ -164,9 +163,7 @@ int ObInsertResolver::resolve_insert_clause(const ParseNode &node)
LOG_WARN("failed to resolve insert filed", K(ret));
} else if (OB_FAIL(get_label_se_columns(insert_stmt->get_insert_table_info(), label_se_columns))) {
LOG_WARN("failed to get label se columns", K(ret));
} else if (OB_FAIL(resolve_values(*values_node,
label_se_columns,
table_item, node.children_[DUPLICATE_NODE]))) {
} else if (OB_FAIL(resolve_values(*values_node, label_se_columns))) {
LOG_WARN("failed to resolve values", K(ret));
} else {
has_tg = insert_stmt->has_instead_of_trigger();
@ -279,10 +276,6 @@ int ObInsertResolver::process_values_function(ObRawExpr *&expr)
uint64_t column_id = b_expr->get_column_id();
ColumnItem *column_item = NULL;
if (OB_ISNULL(column_item = insert_stmt->get_column_item_by_id(table_id, column_id))) {
ret = OB_ERR_BAD_FIELD_ERROR;
ObString scope_name = ObString::make_string(get_scope_name(current_scope_));
LOG_USER_ERROR(OB_ERR_BAD_FIELD_ERROR, b_expr->get_column_name().length(), b_expr->get_column_name().ptr(),
scope_name.length(), scope_name.ptr());
LOG_WARN("fail to get column item", K(ret), K(table_id), K(column_id));
} else {
const int64_t N = insert_columns.count();
@ -309,19 +302,6 @@ int ObInsertResolver::process_values_function(ObRawExpr *&expr)
T_INSERT_SCOPE,
true))) {
LOG_WARN("fail to add additional function", K(ret));
} else if (value_expr->is_const_expr() &&
!ob_is_enum_or_set_type(value_expr->get_data_type())) {
ObRawExpr* remove_const_expr = NULL;
if (OB_FAIL(ObRawExprUtils::build_remove_const_expr(*params_.expr_factory_,
*params_.session_info_,
value_expr, remove_const_expr))) {
LOG_WARN("fail to build remove_const expr",K(ret), K(expr), K(remove_const_expr));
} else {
value_expr = remove_const_expr;
}
}
if (OB_FAIL(ret)) {
//do nothing
} else if (OB_FAIL(ObRawExprUtils::replace_ref_column(expr, b_expr, value_expr))) {
LOG_WARN("fail to replace ref column", K(ret), K(b_expr), K(value_expr));
} else {
@ -439,6 +419,9 @@ int ObInsertResolver::resolve_insert_field(const ParseNode &insert_into, TableIt
session_info_->set_table_name_hidden(old_flag);
}
OZ(column_namespace_checker_.add_reference_table(table_item));
if (OB_SUCC(ret) && OB_FAIL(resolve_foreign_key_constraint(table_item))) {
LOG_WARN("failed to resolve foreign key constraint", K(ret), K(table_item->ref_id_));
}
if (OB_SUCC(ret)) {
current_scope_ = T_INSERT_SCOPE;
const ObTableSchema *table_schema = NULL;
@ -446,7 +429,12 @@ int ObInsertResolver::resolve_insert_field(const ParseNode &insert_into, TableIt
? table_item->ref_query_->get_view_ref_id()
: table_item->get_base_table_item().ref_id_;
OZ(schema_checker_->get_table_schema(session_info_->get_effective_tenant_id(), ref_id, table_schema, table_item->is_link_table()));
OZ (check_need_fired_trigger(table_item));
if (OB_SUCC(ret) && table_item->is_view_table_ && is_oracle_mode()) {
bool has_tg = false;
OZ (has_need_fired_trigger_on_view(table_item, has_tg));
OX (insert_stmt->set_has_instead_of_trigger(has_tg));
}
if (OB_SUCC(ret)) {
if (table_schema->is_oracle_tmp_table()) {
@ -548,10 +536,7 @@ int ObInsertResolver::resolve_insert_assign(const ParseNode &assign_list)
return ret;
}
int ObInsertResolver::resolve_values(const ParseNode &value_node,
ObIArray<uint64_t>& label_se_columns,
TableItem* table_item,
const ParseNode *duplicate_node)
int ObInsertResolver::resolve_values(const ParseNode &value_node, ObIArray<uint64_t>& label_se_columns)
{
int ret = OB_SUCCESS;
ObInsertStmt *insert_stmt = get_insert_stmt();
@ -578,7 +563,6 @@ int ObInsertResolver::resolve_values(const ParseNode &value_node,
LOG_WARN("allocate select buffer failed", K(ret), "size", sizeof(ObSelectResolver));
} else {
// value from sub-query(insert into table select ..)
is_mock_ = lib::is_mysql_mode() && value_node.reserved_;
ObSelectStmt *select_stmt = NULL;
sub_select_resolver_ = new(select_buffer) ObSelectResolver(params_);
//insert clause and select clause in insert into select belong to the same namespace level
@ -592,24 +576,6 @@ int ObInsertResolver::resolve_values(const ParseNode &value_node,
TableItem *sub_select_table = NULL;
ObString view_name;
ObSEArray<ColumnItem, 4> column_items;
ParseNode *alias_node = NULL;
ParseNode *table_alias_node = NULL;
if (is_mock_ &&
value_node.children_[PARSE_SELECT_FROM] != NULL &&
value_node.children_[PARSE_SELECT_FROM]->num_child_ == 1 &&
value_node.children_[PARSE_SELECT_FROM]->children_[0]->type_ == T_ALIAS &&
value_node.children_[PARSE_SELECT_FROM]->children_[0]->num_child_ == 2) {
alias_node = value_node.children_[PARSE_SELECT_FROM]->children_[0]->children_[1];
if (T_LINK_NODE == alias_node->type_ && alias_node->num_child_ == 2) {
table_alias_node = alias_node->children_[0];
} else {
table_alias_node = alias_node;
}
if (NULL != table_alias_node) {
view_name.assign_ptr(const_cast<char*>(table_alias_node->str_value_),
static_cast<int32_t>(table_alias_node->str_len_));
}
}
if (OB_UNLIKELY(T_SELECT != value_node.type_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid value node", K(value_node.type_));
@ -618,8 +584,7 @@ int ObInsertResolver::resolve_values(const ParseNode &value_node,
} else if (OB_ISNULL(select_stmt = sub_select_resolver_->get_select_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid select stmt", K(select_stmt));
} else if (!session_info_->get_ddl_info().is_ddl() &&
OB_FAIL(check_insert_select_field(*insert_stmt, *select_stmt, is_mock_))) {
} else if (!session_info_->get_ddl_info().is_ddl() && OB_FAIL(check_insert_select_field(*insert_stmt, *select_stmt))) {
LOG_WARN("check insert select field failed", K(ret), KPC(insert_stmt), KPC(select_stmt));
} else if (!session_info_->get_ddl_info().is_ddl() && OB_FAIL(add_new_sel_item_for_oracle_temp_table(*select_stmt))) {
LOG_WARN("add session id value to select item failed", K(ret));
@ -627,39 +592,10 @@ int ObInsertResolver::resolve_values(const ParseNode &value_node,
label_se_columns,
*select_stmt))) {
LOG_WARN("add label security columns to select item failed", K(ret));
} else if (OB_FAIL(insert_stmt->generate_anonymous_view_name(*allocator_, view_name))) {
LOG_WARN("failed to generate view name", K(ret));
} else if (OB_FAIL(resolve_generate_table_item(select_stmt, view_name, sub_select_table))) {
LOG_WARN("failed to resolve generate table item", K(ret));
}
if (OB_SUCC(ret) && is_mock_) {
ObString ori_table_name = table_item->table_name_;
ObSEArray<ObString, 4> ori_column_names;
ObString row_alias_table_name = sub_select_table->get_table_name();
ObSEArray<ObString, 4> row_alias_column_names;
//1. check_table_and_column_name
if (OB_FAIL(check_table_and_column_name(insert_stmt->get_values_desc(),
select_stmt,
ori_table_name,
ori_column_names,
row_alias_table_name,
row_alias_column_names))) {
LOG_WARN("fail to get table and column name", K(ret));
}
//2.check_validity_of_duplicate_node
if (OB_FAIL(ret)) {
//do nothing
} else if (duplicate_node != NULL) {
if (OB_FAIL(check_validity_of_duplicate_node(duplicate_node,
ori_table_name,
ori_column_names,
row_alias_table_name,
row_alias_column_names))) {
LOG_WARN("fail to check validity of duplicate node", K(ret));
}
}
}
if (OB_FAIL(ret)) {
//do nothing
} else if (OB_FAIL(resolve_all_generated_table_columns(*sub_select_table,
column_items))) {
LOG_WARN("failed to resolve all generated table columns", K(ret));
@ -670,260 +606,12 @@ int ObInsertResolver::resolve_values(const ParseNode &value_node,
return ret;
}
int ObInsertResolver::check_table_and_column_name(const ObIArray<ObColumnRefRawExpr*> & value_desc,
ObSelectStmt *select_stmt,
ObString &ori_table_name,
ObIArray<ObString> &ori_column_names,
ObString &row_alias_table_name,
ObIArray<ObString> &row_alias_column_names)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(select_stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected error", K(ret));
}
//get original table name and column name,row alias table name and column name
for (int64_t i = 0; OB_SUCC(ret) && i < value_desc.count(); i++) {
//column name comparsion is case insensitive
const ObColumnRefRawExpr* column = value_desc.at(i);
if (OB_ISNULL(column)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("column is NULL", K(ret));
} else if (OB_FAIL(ori_column_names.push_back(column->get_column_name()))) {
LOG_WARN("fail to push column name");
} else if (OB_FAIL(row_alias_column_names.push_back(select_stmt->get_select_item(i).alias_name_))){
LOG_WARN("fail to push column name");
}
}
if (OB_SUCC(ret)) {
//check validity
ObNameCaseMode mode = OB_NAME_CASE_INVALID;
bool perserve_lettercase = true;
ObCollationType cs_type = CS_TYPE_INVALID;
if (OB_FAIL(session_info_->get_name_case_mode(mode))) {
LOG_WARN("fail to get name case mode", K(mode), K(ret));
} else if (OB_FAIL(session_info_->get_collation_connection(cs_type))) {
LOG_WARN("fail to get collation_connection", K(ret));
} else {
perserve_lettercase = lib::is_oracle_mode() ?
true : (mode != OB_LOWERCASE_AND_INSENSITIVE);
}
if (OB_FAIL(ret)) {
//do nothing
} else if (!perserve_lettercase) {
ObCharset::casedn(cs_type, ori_table_name);
ObCharset::casedn(cs_type, row_alias_table_name);
}
if (0 == ori_table_name.compare(row_alias_table_name)) {
//case: insert into t1(a,b) values (4,5) as t1(a,b) on duplicate key update a = t1.a;
ret = OB_ERR_NONUNIQ_TABLE;
LOG_USER_ERROR(OB_ERR_NONUNIQ_TABLE, row_alias_table_name.length(), row_alias_table_name.ptr());
} else if (row_alias_column_names.count() == 0 ||
ori_column_names.count() == 0) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected column column", K(ret));
} else if (row_alias_column_names.count() != ori_column_names.count()) {
//case: insert into t1(a,b) values (4,5) as new(a,b,c) on duplicate key update a = t1.a;
ret = OB_ERR_VIEW_WRONG_LIST;
LOG_WARN("unexpect different count between row_alias_column_names and ori_column_names", K(ret));
}
}
return ret;
}
int ObInsertResolver::check_validity_of_duplicate_node(const ParseNode* node,
ObString &ori_table_name,
ObIArray<ObString> &ori_column_names,
ObString &row_alias_table_name,
ObIArray<ObString> &row_alias_column_names)
{
int ret = OB_SUCCESS;
bool is_valid = true;
if (OB_ISNULL(node)) {
is_valid = false;
} else if (T_ASSIGN_ITEM == node->type_) {
ObString table_name;
ObString column_name;
ParseNode* table_name_node = NULL;
ParseNode* column_name_node = NULL;
ParseNode* col_ref_node = node->children_[0];
if (col_ref_node->num_child_ != 3) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected error", K(ret));
} else if (OB_ISNULL(table_name_node = col_ref_node->children_[1])) {
//do nothing
} else if (OB_ISNULL(column_name_node = col_ref_node->children_[2])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected error", K(ret));
} else {
table_name.assign_ptr(table_name_node->str_value_,
static_cast<int32_t>(table_name_node->str_len_));
if (0 == (row_alias_table_name.compare(ori_table_name)) ) {
column_name.assign_ptr(column_name_node->str_value_,
static_cast<int32_t>(column_name_node->str_len_));
/*
* INSERT INTO t1 VALUES (4,5,7) AS t1(m,n,p) ON DUPLICATE KEY UPDATE NEW.m = m+n+1;
* NEW.m is not allowed to set
*/
ret = OB_ERR_BAD_FIELD_ERROR;
ObString scope_name = ObString::make_string(get_scope_name(current_scope_));
LOG_USER_ERROR(OB_ERR_BAD_FIELD_ERROR, column_name.length(), column_name.ptr(),
scope_name.length(), scope_name.ptr());
} else if (OB_FAIL(check_ambiguous_column(column_name, ori_column_names, row_alias_column_names))) {
LOG_WARN("fail to check ambiguous columns", K(ret));
}
}
} else if (T_FUN_SYS == node->type_) {
if (node->num_child_ != 2) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected error", K(node->num_child_), K(ret));
} else {
ObString node_name;
ObString node_column_name;
node_name.assign_ptr(node->children_[0]->str_value_,
static_cast<int32_t>(node->children_[0]->str_len_));
if (0 == node_name.case_compare("values")) {
//do nothing, do not replace column under values expr
if (node->children_[1]->type_ == T_EXPR_LIST) {
ParseNode* expr_list_node = node->children_[1];
for (int64_t i = 0; OB_SUCC(ret) && i < expr_list_node->num_child_; ++i) {
ObString node_table_name;
if (OB_ISNULL(expr_list_node->children_[i])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected error", K(ret));
} else {
//case: insert into t1(a,b) values (4,5) as new(a,b) on duplicate key update a = value(new.a)+new.a;
//new.a under values is not allowed
ParseNode* col_ref_node = expr_list_node->children_[i];
if (col_ref_node->num_child_ != 3 || OB_ISNULL(col_ref_node->children_[2])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected error", K(col_ref_node->num_child_), K(col_ref_node->children_[2]), K(ret));
} else if (col_ref_node->children_[1] == NULL) {
//table node is null
//insert into t1(a,b) values (4,5) as new(a,b) on duplicate key update a = value(a)+a
//a in valus expr must be column of target table t1
node_column_name.assign_ptr(col_ref_node->children_[2]->str_value_,
static_cast<int32_t>(col_ref_node->children_[2]->str_len_));
if (!find_in_column(node_column_name, ori_column_names)) {
ret = OB_ERR_BAD_FIELD_ERROR;
ObString scope_name = ObString::make_string(get_scope_name(current_scope_));
LOG_USER_ERROR(OB_ERR_BAD_FIELD_ERROR, node_column_name.length(), node_column_name.ptr(),
scope_name.length(), scope_name.ptr());
}
} else {
//table node is not null
node_table_name.assign_ptr(col_ref_node->children_[1]->str_value_,
static_cast<int32_t>(col_ref_node->children_[1]->str_len_));
if (0 == (node_table_name.compare(row_alias_table_name))) {
node_column_name.assign_ptr(col_ref_node->children_[2]->str_value_,
static_cast<int32_t>(col_ref_node->children_[2]->str_len_));
ret = OB_ERR_BAD_FIELD_ERROR;
ObString scope_name = ObString::make_string(get_scope_name(current_scope_));
LOG_USER_ERROR(OB_ERR_BAD_FIELD_ERROR, node_column_name.length(), node_column_name.ptr(),
scope_name.length(), scope_name.ptr());
}
}
}
}
}
is_valid = false;
}
}
} else if (T_COLUMN_REF == node->type_) {
ObString table_name;
ObString column_name;
if (node->num_child_ != 3) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect column ref child node", K(node->num_child_), K(ret));
} else {
if ((node->children_[1]) != NULL) {
table_name.assign_ptr(node->children_[1]->str_value_,
static_cast<int32_t>(node->children_[1]->str_len_));
}
if ((node->children_[2]) != NULL) {
column_name.assign_ptr(node->children_[2]->str_value_,
static_cast<int32_t>(node->children_[2]->str_len_));
}
if (node->children_[1] == NULL ||
(0 == (table_name.compare(ori_table_name)) &&
0 == (table_name.compare(row_alias_table_name)))) {
//case: insert into t1(a,b) values (4,5) as new(a,b) on duplicate key update a = value(a)+a;
//update a[0] = value(a[1])+a[2], a[2] is ambiguous
if (OB_FAIL(check_ambiguous_column(column_name, ori_column_names, row_alias_column_names))) {
LOG_WARN("fail to check ambiguous columns", K(ret));
}
}
}
is_valid = false;
}
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < node->num_child_; i++) {
if (T_ASSIGN_ITEM == node->type_ && 0 == i) {
//ON DUPLICATE KEY UPDATE c = new.a+values(b), only deal with value list [new.a+values(b)]
} else if (OB_FAIL(SMART_CALL(check_validity_of_duplicate_node(node->children_[i],
ori_table_name,
ori_column_names,
row_alias_table_name,
row_alias_column_names)))) {
LOG_WARN("refine_insert_update_assignment fail", K(ret));
}
}
return ret;
}
int ObInsertResolver::check_ambiguous_column(ObString &column_name,
ObIArray<ObString> &ori_column_names,
ObIArray<ObString> &row_alias_column_names)
{
int ret = OB_SUCCESS;
bool find_in_ori = false;
bool find_in_row_alias = false;
if (row_alias_column_names.count() != ori_column_names.count()) {
ret = OB_ERR_VIEW_WRONG_LIST;
LOG_WARN("unexpect different count between row_alias_column_names and ori_column_names", K(ret));
}
for (int i = 0; OB_SUCC(ret) && (!find_in_row_alias || !find_in_ori)
&& i < row_alias_column_names.count(); i++) {
ObString row_alias_col_name = row_alias_column_names.at(i);
ObString ori_col_name = ori_column_names.at(i);
if (0 == (column_name.case_compare(row_alias_col_name))) {
find_in_row_alias = true;
}
if (0 == (column_name.case_compare(ori_col_name))) {
find_in_ori = true;
}
}
if (OB_FAIL(ret)) {
//do nothing
} else if (find_in_row_alias && find_in_ori) {
ret = OB_NON_UNIQ_ERROR;
ObString scope_name = ObString::make_string(get_scope_name(current_scope_));
LOG_USER_ERROR(OB_NON_UNIQ_ERROR, column_name.length(), column_name.ptr(),
scope_name.length(), scope_name.ptr());
}
return ret;
}
bool ObInsertResolver::find_in_column(ObString &column_name,
ObIArray<ObString> &column_names)
{
bool find_column = false;
for (int i = 0; !find_column && i < column_names.count(); i++) {
ObString tmp_col_name = column_names.at(i);
if (0 == (column_name.case_compare(tmp_col_name))) {
find_column = true;
}
}
return find_column;
}
int ObInsertResolver::check_insert_select_field(ObInsertStmt &insert_stmt,
ObSelectStmt &select_stmt,
bool is_mock)
ObSelectStmt &select_stmt)
{
int ret = OB_SUCCESS;
bool is_generated_column = false;
const ObIArray<ObColumnRefRawExpr*> &values_desc = insert_stmt.get_values_desc();
ObSelectStmt *ref_stmt = NULL;
if (OB_ISNULL(session_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid session_info_", K(ret));
@ -931,15 +619,6 @@ int ObInsertResolver::check_insert_select_field(ObInsertStmt &insert_stmt,
ret = OB_ERR_COULUMN_VALUE_NOT_MATCH;
LOG_WARN("column count mismatch", K(values_desc.count()), K(select_stmt.get_select_item_size()));
LOG_USER_ERROR(OB_ERR_COULUMN_VALUE_NOT_MATCH, 1l);
} else if (is_mock && select_stmt.is_single_table_stmt()) {
const TableItem *table_item = select_stmt.get_table_item(0);
if (table_item->is_generated_table()) {
ref_stmt = table_item->ref_query_;
if (ref_stmt->get_select_item_size() != select_stmt.get_select_item_size()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("item size is unexpected", K(ret), K(ref_stmt->get_select_item_size()), K(select_stmt.get_select_item_size()));
}
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < values_desc.count(); ++i) {
const ObColumnRefRawExpr *value_desc = values_desc.at(i);
@ -975,19 +654,6 @@ int ObInsertResolver::check_insert_select_field(ObInsertStmt &insert_stmt,
ret = OB_ERR_INSERT_INTO_GENERATED_ALWAYS_IDENTITY_COLUMN;
LOG_USER_ERROR(OB_ERR_INSERT_INTO_GENERATED_ALWAYS_IDENTITY_COLUMN);
}
if (OB_FAIL(ret)) {
//do nothing
} else if (is_mock &&
ref_stmt != NULL) {
if (!ref_stmt->get_select_item(i).is_real_alias_) {
ref_stmt->get_select_item(i).alias_name_ = value_desc->get_column_name();
ref_stmt->get_select_item(i).is_real_alias_ = true;
}
if (!select_stmt.get_select_item(i).is_real_alias_) {
select_stmt.get_select_item(i).alias_name_ = ref_stmt->get_select_item(i).alias_name_;
select_stmt.get_select_item(i).is_real_alias_ = true;
}
}
}
return ret;
}
@ -997,7 +663,6 @@ int ObInsertResolver::mock_values_column_ref(const ObColumnRefRawExpr *column_re
int ret = OB_SUCCESS;
ObInsertStmt *stmt = get_insert_stmt();
ObColumnRefRawExpr *value_desc = NULL;
ObColumnRefRawExpr *base_column_ref = const_cast<ObColumnRefRawExpr*>(column_ref);
if (OB_ISNULL(column_ref) || OB_ISNULL(stmt) || OB_ISNULL(params_.expr_factory_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(column_ref), K(stmt), KP_(params_.expr_factory));
@ -1020,23 +685,9 @@ int ObInsertResolver::mock_values_column_ref(const ObColumnRefRawExpr *column_re
ret = OB_ERR_UNEXPECTED;
LOG_WARN(("value desc is null"));
} else {
if (OB_FAIL(ObTransformUtils::get_base_column(stmt, base_column_ref))) {
// may be invalid updatable view, will be handled later.
ret = OB_SUCCESS;
base_column_ref = const_cast<ObColumnRefRawExpr*>(column_ref);
LOG_WARN("failed to get base column", K(ret));
}
value_desc->set_result_type(column_ref->get_result_type());
value_desc->set_result_flag(column_ref->get_result_flag());
value_desc->set_column_flags(column_ref->get_column_flags());
if (base_column_ref != column_ref) {
if (base_column_ref->is_table_part_key_column()) {
value_desc->set_table_part_key_column();
}
if (base_column_ref->is_table_part_key_org_column()) {
value_desc->set_table_part_key_org_column();
}
}
value_desc->set_dependant_expr(const_cast<ObRawExpr *>(column_ref->get_dependant_expr()));
value_desc->set_ref_id(stmt->get_insert_table_info().table_id_, column_ref->get_column_id());
value_desc->set_column_attr(ObString::make_string(OB_VALUES), column_ref->get_column_name());
@ -1194,8 +845,6 @@ int ObInsertResolver::resolve_insert_update_assignment(const ParseNode *node, Ob
ret = OB_NOT_SUPPORTED;
LOG_WARN("REPLACE statement does not support ON DUPLICATE KEY UPDATE clause");
LOG_USER_ERROR(OB_NOT_SUPPORTED, "REPLACE statement ON DUPLICATE KEY UPDATE clause");
} else if (FALSE_IT(is_resolve_insert_update_ = true)) {
//do nothing
} else if (OB_FAIL(ObDelUpdResolver::resolve_insert_update_assignment(node, table_info))) {
LOG_WARN("resolve assignment error", K(ret));
}