From ff8bbf3ebcedbbf7f62436970a7f97ee47eb0845 Mon Sep 17 00:00:00 2001 From: rq0 Date: Wed, 23 Mar 2022 22:07:54 +0800 Subject: [PATCH] fix padding bug with function-based index --- .../ob_inner_table_schema.25101_25150.cpp | 6 +- .../inner_table/ob_inner_table_schema_def.py | 15 ++-- src/share/ob_index_builder_util.cpp | 18 +++-- src/share/ob_index_builder_util.h | 9 ++- src/share/ob_rpc_struct.cpp | 9 ++- src/share/ob_rpc_struct.h | 19 ++++- src/share/schema/ob_schema_struct.h | 1 + src/sql/ob_sql_utils.cpp | 5 +- .../resolver/ddl/ob_alter_table_resolver.cpp | 3 + .../resolver/ddl/ob_create_index_resolver.cpp | 1 + .../resolver/ddl/ob_create_table_resolver.cpp | 7 +- src/sql/resolver/ddl/ob_ddl_resolver.cpp | 3 + src/sql/resolver/dml/ob_dml_resolver.cpp | 75 ++++++++++++++++++- src/sql/resolver/dml/ob_dml_resolver.h | 2 + src/sql/resolver/expr/ob_raw_expr_util.cpp | 44 ++++++++++- src/sql/resolver/expr/ob_raw_expr_util.h | 8 +- 16 files changed, 191 insertions(+), 34 deletions(-) diff --git a/src/share/inner_table/ob_inner_table_schema.25101_25150.cpp b/src/share/inner_table/ob_inner_table_schema.25101_25150.cpp index 2d6c4fa3db..56e4ba9c35 100644 --- a/src/share/inner_table/ob_inner_table_schema.25101_25150.cpp +++ b/src/share/inner_table/ob_inner_table_schema.25101_25150.cpp @@ -684,7 +684,7 @@ int ObInnerTableSchema::dba_ind_expressions_schema(ObTableSchema &table_schema) table_schema.set_create_mem_version(1); if (OB_SUCC(ret)) { - if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT CAST(INDEX_OWNER AS VARCHAR2(128)) AS INDEX_OWNER, CAST(INDEX_NAME AS VARCHAR2(128)) AS INDEX_NAME, CAST(TABLE_OWNER AS VARCHAR2(128)) AS TABLE_OWNER, CAST(H.TABLE_NAME AS VARCHAR2(128)) AS TABLE_NAME, CAST(COLUMN_EXPRESSION /* TODO: LONG */ AS VARCHAR2(1000)) AS COLUMN_EXPRESSION, COLUMN_POSITION FROM ( SELECT INDEX_OWNER, INDEX_NAME, TABLE_OWNER, F.CUR_DEFAULT_VALUE_V2 AS COLUMN_EXPRESSION, E.INDEX_POSITION AS COLUMN_POSITION, E.TABLE_ID AS TABLE_ID FROM (SELECT INDEX_OWNER, INDEX_NAME, TABLE_OWNER, C.TABLE_ID AS TABLE_ID, C.INDEX_ID AS INDEX_ID, D.COLUMN_ID AS COLUMN_ID, D.COLUMN_NAME AS COLUMN_NAME, D.INDEX_POSITION AS INDEX_POSITION FROM (SELECT DATABASE_NAME AS INDEX_OWNER, SUBSTR(TABLE_NAME, 7 + INSTR(SUBSTR(TABLE_NAME, 7), '_')) AS INDEX_NAME, DATABASE_NAME AS TABLE_OWNER, A.DATA_TABLE_ID AS TABLE_ID, A.TABLE_ID AS INDEX_ID FROM SYS.ALL_VIRTUAL_TABLE_REAL_AGENT A JOIN SYS.ALL_VIRTUAL_DATABASE_REAL_AGENT B ON A.DATABASE_ID = B.DATABASE_ID AND B.DATABASE_NAME != '__recyclebin' AND A.TENANT_ID = EFFECTIVE_TENANT_ID() AND B.TENANT_ID = EFFECTIVE_TENANT_ID() WHERE TABLE_TYPE=5 ) C JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT D ON C.INDEX_ID=D.TABLE_ID AND D.TENANT_ID = EFFECTIVE_TENANT_ID()) E JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT F ON F.TABLE_ID=E.TABLE_ID AND F.TENANT_ID = EFFECTIVE_TENANT_ID() AND F.COLUMN_ID=E.COLUMN_ID AND F.COLUMN_FLAGS=1) G JOIN SYS.ALL_VIRTUAL_TABLE_REAL_AGENT H ON G.TABLE_ID=H.TABLE_ID AND H.TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) { + if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT CAST(INDEX_OWNER AS VARCHAR2(128)) AS INDEX_OWNER, CAST(INDEX_NAME AS VARCHAR2(128)) AS INDEX_NAME, CAST(TABLE_OWNER AS VARCHAR2(128)) AS TABLE_OWNER, CAST(H.TABLE_NAME AS VARCHAR2(128)) AS TABLE_NAME, CAST(COLUMN_EXPRESSION /* TODO: LONG */ AS VARCHAR2(1000)) AS COLUMN_EXPRESSION, COLUMN_POSITION FROM ( SELECT INDEX_OWNER, INDEX_NAME, TABLE_OWNER, F.CUR_DEFAULT_VALUE_V2 AS COLUMN_EXPRESSION, E.INDEX_POSITION AS COLUMN_POSITION, E.TABLE_ID AS TABLE_ID FROM (SELECT INDEX_OWNER, INDEX_NAME, TABLE_OWNER, C.TABLE_ID AS TABLE_ID, C.INDEX_ID AS INDEX_ID, D.COLUMN_ID AS COLUMN_ID, D.COLUMN_NAME AS COLUMN_NAME, D.INDEX_POSITION AS INDEX_POSITION FROM (SELECT DATABASE_NAME AS INDEX_OWNER, SUBSTR(TABLE_NAME, 7 + INSTR(SUBSTR(TABLE_NAME, 7), '_')) AS INDEX_NAME, DATABASE_NAME AS TABLE_OWNER, A.DATA_TABLE_ID AS TABLE_ID, A.TABLE_ID AS INDEX_ID FROM SYS.ALL_VIRTUAL_TABLE_REAL_AGENT A JOIN SYS.ALL_VIRTUAL_DATABASE_REAL_AGENT B ON A.DATABASE_ID = B.DATABASE_ID AND B.DATABASE_NAME != '__recyclebin' AND A.TENANT_ID = EFFECTIVE_TENANT_ID() AND B.TENANT_ID = EFFECTIVE_TENANT_ID() WHERE TABLE_TYPE=5 ) C JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT D ON C.INDEX_ID=D.TABLE_ID AND D.TENANT_ID = EFFECTIVE_TENANT_ID() AND D.INDEX_POSITION != 0) E JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT F ON F.TABLE_ID=E.TABLE_ID AND F.TENANT_ID = EFFECTIVE_TENANT_ID() AND F.COLUMN_ID=E.COLUMN_ID AND BITAND(F.COLUMN_FLAGS,3) > 0) G JOIN SYS.ALL_VIRTUAL_TABLE_REAL_AGENT H ON G.TABLE_ID=H.TABLE_ID AND H.TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) { LOG_ERROR("fail to set view_definition", K(ret)); } } @@ -736,7 +736,7 @@ int ObInnerTableSchema::user_ind_expressions_schema(ObTableSchema &table_schema) table_schema.set_create_mem_version(1); if (OB_SUCC(ret)) { - if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT CAST(INDEX_NAME AS VARCHAR2(128)) AS INDEX_NAME, CAST(H.TABLE_NAME AS VARCHAR2(128)) AS TABLE_NAME, CAST(COLUMN_EXPRESSION /* TODO: LONG */ AS VARCHAR2(1000)) AS COLUMN_EXPRESSION, COLUMN_POSITION FROM ( SELECT INDEX_NAME, F.CUR_DEFAULT_VALUE_V2 AS COLUMN_EXPRESSION, E.INDEX_POSITION AS COLUMN_POSITION, E.TABLE_ID AS TABLE_ID FROM (SELECT INDEX_NAME, C.TABLE_ID AS TABLE_ID, C.INDEX_ID AS INDEX_ID, D.COLUMN_ID AS COLUMN_ID, D.COLUMN_NAME AS COLUMN_NAME, D.INDEX_POSITION AS INDEX_POSITION FROM (SELECT SUBSTR(TABLE_NAME, 7 + INSTR(SUBSTR(TABLE_NAME, 7), '_')) AS INDEX_NAME, A.DATA_TABLE_ID AS TABLE_ID, A.TABLE_ID AS INDEX_ID FROM SYS.ALL_VIRTUAL_TABLE_REAL_AGENT A JOIN SYS.ALL_VIRTUAL_DATABASE_REAL_AGENT B ON A.DATABASE_ID = B.DATABASE_ID AND B.DATABASE_NAME != '__recyclebin' AND A.DATABASE_ID = USERENV('SCHEMAID') AND A.TENANT_ID = EFFECTIVE_TENANT_ID() AND B.TENANT_ID = EFFECTIVE_TENANT_ID() WHERE TABLE_TYPE=5 ) C JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT D ON C.INDEX_ID=D.TABLE_ID AND D.TENANT_ID = EFFECTIVE_TENANT_ID()) E JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT F ON F.TABLE_ID=E.TABLE_ID AND F.TENANT_ID = EFFECTIVE_TENANT_ID() AND F.COLUMN_ID=E.COLUMN_ID AND F.COLUMN_FLAGS=1) G JOIN SYS.ALL_VIRTUAL_TABLE_REAL_AGENT H ON G.TABLE_ID=H.TABLE_ID AND H.TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) { + if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT CAST(INDEX_NAME AS VARCHAR2(128)) AS INDEX_NAME, CAST(H.TABLE_NAME AS VARCHAR2(128)) AS TABLE_NAME, CAST(COLUMN_EXPRESSION /* TODO: LONG */ AS VARCHAR2(1000)) AS COLUMN_EXPRESSION, COLUMN_POSITION FROM ( SELECT INDEX_NAME, F.CUR_DEFAULT_VALUE_V2 AS COLUMN_EXPRESSION, E.INDEX_POSITION AS COLUMN_POSITION, E.TABLE_ID AS TABLE_ID FROM (SELECT INDEX_NAME, C.TABLE_ID AS TABLE_ID, C.INDEX_ID AS INDEX_ID, D.COLUMN_ID AS COLUMN_ID, D.COLUMN_NAME AS COLUMN_NAME, D.INDEX_POSITION AS INDEX_POSITION FROM (SELECT SUBSTR(TABLE_NAME, 7 + INSTR(SUBSTR(TABLE_NAME, 7), '_')) AS INDEX_NAME, A.DATA_TABLE_ID AS TABLE_ID, A.TABLE_ID AS INDEX_ID FROM SYS.ALL_VIRTUAL_TABLE_REAL_AGENT A JOIN SYS.ALL_VIRTUAL_DATABASE_REAL_AGENT B ON A.DATABASE_ID = B.DATABASE_ID AND B.DATABASE_NAME != '__recyclebin' AND A.DATABASE_ID = USERENV('SCHEMAID') AND A.TENANT_ID = EFFECTIVE_TENANT_ID() AND B.TENANT_ID = EFFECTIVE_TENANT_ID() WHERE TABLE_TYPE=5 ) C JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT D ON C.INDEX_ID=D.TABLE_ID AND D.TENANT_ID = EFFECTIVE_TENANT_ID() AND D.INDEX_POSITION != 0) E JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT F ON F.TABLE_ID=E.TABLE_ID AND F.TENANT_ID = EFFECTIVE_TENANT_ID() AND F.COLUMN_ID=E.COLUMN_ID AND BITAND(F.COLUMN_FLAGS,3) > 0) G JOIN SYS.ALL_VIRTUAL_TABLE_REAL_AGENT H ON G.TABLE_ID=H.TABLE_ID AND H.TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) { LOG_ERROR("fail to set view_definition", K(ret)); } } @@ -788,7 +788,7 @@ int ObInnerTableSchema::all_ind_expressions_schema(ObTableSchema &table_schema) table_schema.set_create_mem_version(1); if (OB_SUCC(ret)) { - if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT CAST(INDEX_OWNER AS VARCHAR2(128)) AS INDEX_OWNER, CAST(INDEX_NAME AS VARCHAR2(128)) AS INDEX_NAME, CAST(TABLE_OWNER AS VARCHAR2(128)) AS TABLE_OWNER, CAST(H.TABLE_NAME AS VARCHAR2(128)) AS TABLE_NAME, CAST(COLUMN_EXPRESSION /* TODO: LONG */ AS VARCHAR2(1000)) AS COLUMN_EXPRESSION, COLUMN_POSITION FROM ( SELECT INDEX_OWNER, INDEX_NAME, TABLE_OWNER, F.CUR_DEFAULT_VALUE_V2 AS COLUMN_EXPRESSION, E.INDEX_POSITION AS COLUMN_POSITION, E.TABLE_ID AS TABLE_ID FROM (SELECT INDEX_OWNER, INDEX_NAME, TABLE_OWNER, C.TABLE_ID AS TABLE_ID, C.INDEX_ID AS INDEX_ID, D.COLUMN_ID AS COLUMN_ID, D.COLUMN_NAME AS COLUMN_NAME, D.INDEX_POSITION AS INDEX_POSITION FROM (SELECT DATABASE_NAME AS INDEX_OWNER, SUBSTR(TABLE_NAME, 7 + INSTR(SUBSTR(TABLE_NAME, 7), '_')) AS INDEX_NAME, DATABASE_NAME AS TABLE_OWNER, A.DATA_TABLE_ID AS TABLE_ID, A.TABLE_ID AS INDEX_ID FROM SYS.ALL_VIRTUAL_TABLE_REAL_AGENT A JOIN SYS.ALL_VIRTUAL_DATABASE_REAL_AGENT B ON A.DATABASE_ID = B.DATABASE_ID AND A.TENANT_ID = EFFECTIVE_TENANT_ID() AND B.TENANT_ID = EFFECTIVE_TENANT_ID() AND (A.DATABASE_ID = USERENV('SCHEMAID') OR USER_CAN_ACCESS_OBJ(1, A.DATA_TABLE_ID, A.DATABASE_ID) = 1) AND B.DATABASE_NAME != '__recyclebin' WHERE TABLE_TYPE=5 ) C JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT D ON C.INDEX_ID=D.TABLE_ID AND D.TENANT_ID = EFFECTIVE_TENANT_ID()) E JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT F ON F.TABLE_ID=E.TABLE_ID AND F.TENANT_ID = EFFECTIVE_TENANT_ID() AND F.COLUMN_ID=E.COLUMN_ID AND F.COLUMN_FLAGS=1) G JOIN SYS.ALL_VIRTUAL_TABLE_REAL_AGENT H ON G.TABLE_ID=H.TABLE_ID AND H.TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) { + if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT CAST(INDEX_OWNER AS VARCHAR2(128)) AS INDEX_OWNER, CAST(INDEX_NAME AS VARCHAR2(128)) AS INDEX_NAME, CAST(TABLE_OWNER AS VARCHAR2(128)) AS TABLE_OWNER, CAST(H.TABLE_NAME AS VARCHAR2(128)) AS TABLE_NAME, CAST(COLUMN_EXPRESSION /* TODO: LONG */ AS VARCHAR2(1000)) AS COLUMN_EXPRESSION, COLUMN_POSITION FROM ( SELECT INDEX_OWNER, INDEX_NAME, TABLE_OWNER, F.CUR_DEFAULT_VALUE_V2 AS COLUMN_EXPRESSION, E.INDEX_POSITION AS COLUMN_POSITION, E.TABLE_ID AS TABLE_ID FROM (SELECT INDEX_OWNER, INDEX_NAME, TABLE_OWNER, C.TABLE_ID AS TABLE_ID, C.INDEX_ID AS INDEX_ID, D.COLUMN_ID AS COLUMN_ID, D.COLUMN_NAME AS COLUMN_NAME, D.INDEX_POSITION AS INDEX_POSITION FROM (SELECT DATABASE_NAME AS INDEX_OWNER, SUBSTR(TABLE_NAME, 7 + INSTR(SUBSTR(TABLE_NAME, 7), '_')) AS INDEX_NAME, DATABASE_NAME AS TABLE_OWNER, A.DATA_TABLE_ID AS TABLE_ID, A.TABLE_ID AS INDEX_ID FROM SYS.ALL_VIRTUAL_TABLE_REAL_AGENT A JOIN SYS.ALL_VIRTUAL_DATABASE_REAL_AGENT B ON A.DATABASE_ID = B.DATABASE_ID AND A.TENANT_ID = EFFECTIVE_TENANT_ID() AND B.TENANT_ID = EFFECTIVE_TENANT_ID() AND (A.DATABASE_ID = USERENV('SCHEMAID') OR USER_CAN_ACCESS_OBJ(1, A.DATA_TABLE_ID, A.DATABASE_ID) = 1) AND B.DATABASE_NAME != '__recyclebin' WHERE TABLE_TYPE=5 ) C JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT D ON C.INDEX_ID=D.TABLE_ID AND D.TENANT_ID = EFFECTIVE_TENANT_ID() AND D.INDEX_POSITION != 0) E JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT F ON F.TABLE_ID=E.TABLE_ID AND F.TENANT_ID = EFFECTIVE_TENANT_ID() AND F.COLUMN_ID=E.COLUMN_ID AND BITAND(F.COLUMN_FLAGS,3) > 0) G JOIN SYS.ALL_VIRTUAL_TABLE_REAL_AGENT H ON G.TABLE_ID=H.TABLE_ID AND H.TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) { LOG_ERROR("fail to set view_definition", K(ret)); } } diff --git a/src/share/inner_table/ob_inner_table_schema_def.py b/src/share/inner_table/ob_inner_table_schema_def.py index ac5514a59c..72d3ac8f2c 100644 --- a/src/share/inner_table/ob_inner_table_schema_def.py +++ b/src/share/inner_table/ob_inner_table_schema_def.py @@ -23168,11 +23168,12 @@ def_table_schema( AND B.TENANT_ID = EFFECTIVE_TENANT_ID() WHERE TABLE_TYPE=5 ) C JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT D ON C.INDEX_ID=D.TABLE_ID - AND D.TENANT_ID = EFFECTIVE_TENANT_ID()) E + AND D.TENANT_ID = EFFECTIVE_TENANT_ID() + AND D.INDEX_POSITION != 0) E JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT F ON F.TABLE_ID=E.TABLE_ID AND F.TENANT_ID = EFFECTIVE_TENANT_ID() AND F.COLUMN_ID=E.COLUMN_ID - AND F.COLUMN_FLAGS=1) G + AND BITAND(F.COLUMN_FLAGS,3) > 0) G JOIN SYS.ALL_VIRTUAL_TABLE_REAL_AGENT H ON G.TABLE_ID=H.TABLE_ID AND H.TENANT_ID = EFFECTIVE_TENANT_ID() """.replace("\n", " ") @@ -23219,11 +23220,12 @@ def_table_schema( AND B.TENANT_ID = EFFECTIVE_TENANT_ID() WHERE TABLE_TYPE=5 ) C JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT D ON C.INDEX_ID=D.TABLE_ID - AND D.TENANT_ID = EFFECTIVE_TENANT_ID()) E + AND D.TENANT_ID = EFFECTIVE_TENANT_ID() + AND D.INDEX_POSITION != 0) E JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT F ON F.TABLE_ID=E.TABLE_ID AND F.TENANT_ID = EFFECTIVE_TENANT_ID() AND F.COLUMN_ID=E.COLUMN_ID - AND F.COLUMN_FLAGS=1) G + AND BITAND(F.COLUMN_FLAGS,3) > 0) G JOIN SYS.ALL_VIRTUAL_TABLE_REAL_AGENT H ON G.TABLE_ID=H.TABLE_ID AND H.TENANT_ID = EFFECTIVE_TENANT_ID() """.replace("\n", " ") @@ -23276,11 +23278,12 @@ def_table_schema( AND B.DATABASE_NAME != '__recyclebin' WHERE TABLE_TYPE=5 ) C JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT D ON C.INDEX_ID=D.TABLE_ID - AND D.TENANT_ID = EFFECTIVE_TENANT_ID()) E + AND D.TENANT_ID = EFFECTIVE_TENANT_ID() + AND D.INDEX_POSITION != 0) E JOIN SYS.ALL_VIRTUAL_COLUMN_REAL_AGENT F ON F.TABLE_ID=E.TABLE_ID AND F.TENANT_ID = EFFECTIVE_TENANT_ID() AND F.COLUMN_ID=E.COLUMN_ID - AND F.COLUMN_FLAGS=1) G + AND BITAND(F.COLUMN_FLAGS,3) > 0) G JOIN SYS.ALL_VIRTUAL_TABLE_REAL_AGENT H ON G.TABLE_ID=H.TABLE_ID AND H.TENANT_ID = EFFECTIVE_TENANT_ID() """.replace("\n", " ") diff --git a/src/share/ob_index_builder_util.cpp b/src/share/ob_index_builder_util.cpp index 8d2b7974fd..acf3b5136c 100644 --- a/src/share/ob_index_builder_util.cpp +++ b/src/share/ob_index_builder_util.cpp @@ -580,7 +580,7 @@ int ObIndexBuilderUtil::adjust_ordinary_index_column_args( ObColumnSchemaV2* gen_col = NULL; if (new_sort_item.prefix_len_ > 0) { // handle prefix column index - if (OB_FAIL(generate_prefix_column(new_sort_item, data_schema, gen_col))) { + if (OB_FAIL(generate_prefix_column(new_sort_item, arg.sql_mode_, data_schema, gen_col))) { LOG_WARN("generate prefix column failed", K(ret)); } else { new_sort_item.column_name_ = gen_col->get_column_name_str(); @@ -626,7 +626,7 @@ int ObIndexBuilderUtil::adjust_ordinary_index_column_args( LOG_WARN("only pure functions can be indexed", K(ret)); } else if (!expr->is_column_ref_expr()) { // real index expr, so generate hidden generated column in data table schema - if (OB_FAIL(generate_ordinary_generated_column(*expr, data_schema, gen_col))) { + if (OB_FAIL(generate_ordinary_generated_column(*expr, arg.sql_mode_, data_schema, gen_col))) { LOG_WARN("generate ordinary generated column failed", K(ret)); } else { new_sort_item.column_name_ = gen_col->get_column_name_str(); @@ -787,8 +787,8 @@ int ObIndexBuilderUtil::generate_fulltext_column( return ret; } -int ObIndexBuilderUtil::generate_ordinary_generated_column( - ObRawExpr& expr, ObTableSchema& data_schema, ObColumnSchemaV2*& gen_col, const uint64_t index_id) +int ObIndexBuilderUtil::generate_ordinary_generated_column(ObRawExpr& expr, const ObSQLMode sql_mode, + ObTableSchema& data_schema, ObColumnSchemaV2*& gen_col, const uint64_t index_id) { int ret = OB_SUCCESS; ObColumnSchemaV2 tmp_gen_col; @@ -821,6 +821,9 @@ int ObIndexBuilderUtil::generate_ordinary_generated_column( tmp_gen_col.set_table_id(data_schema.get_table_id()); tmp_gen_col.set_column_id(data_schema.get_max_used_column_id() + 1); tmp_gen_col.add_column_flag(VIRTUAL_GENERATED_COLUMN_FLAG); + if (is_pad_char_to_full_length(sql_mode)) { + tmp_gen_col.add_column_flag(PAD_WHEN_CALC_GENERATED_COLUMN_FLAG); + } tmp_gen_col.set_is_hidden(true); tmp_gen_col.set_data_type(expr.get_data_type()); tmp_gen_col.set_collation_type(expr.get_collation_type()); @@ -884,8 +887,8 @@ int ObIndexBuilderUtil::generate_ordinary_generated_column( return ret; } -int ObIndexBuilderUtil::generate_prefix_column( - const ObColumnSortItem& sort_item, ObTableSchema& data_schema, ObColumnSchemaV2*& prefix_col) +int ObIndexBuilderUtil::generate_prefix_column(const ObColumnSortItem& sort_item, const ObSQLMode sql_mode, + ObTableSchema& data_schema, ObColumnSchemaV2*& prefix_col) { int ret = OB_SUCCESS; ObColumnSchemaV2* old_column = NULL; @@ -963,6 +966,9 @@ int ObIndexBuilderUtil::generate_prefix_column( int32_t data_len = static_cast(min(sort_item.prefix_len_, old_column->get_data_length())); prefix_column.set_data_length(data_len); prefix_column.add_column_flag(VIRTUAL_GENERATED_COLUMN_FLAG); + if (is_pad_char_to_full_length(sql_mode)) { + prefix_column.add_column_flag(PAD_WHEN_CALC_GENERATED_COLUMN_FLAG); + } prefix_column.set_is_hidden(true); // for debug old_column->add_column_flag(GENERATED_DEPS_CASCADE_FLAG); prefix_column.set_prev_column_id(UINT64_MAX); diff --git a/src/share/ob_index_builder_util.h b/src/share/ob_index_builder_util.h index 239198420f..94d5069f07 100644 --- a/src/share/ob_index_builder_util.h +++ b/src/share/ob_index_builder_util.h @@ -41,8 +41,9 @@ class ObIndexBuilderUtil { public: static int adjust_expr_index_args(obrpc::ObCreateIndexArg& arg, share::schema::ObTableSchema& data_schema, common::ObIArray& gen_columns); - static int generate_ordinary_generated_column(sql::ObRawExpr& expr, share::schema::ObTableSchema& data_schema, - share::schema::ObColumnSchemaV2*& gen_col, const uint64_t index_id = OB_INVALID_ID); + static int generate_ordinary_generated_column(sql::ObRawExpr& expr, const ObSQLMode sql_mode, + share::schema::ObTableSchema& data_schema, share::schema::ObColumnSchemaV2*& gen_col, + const uint64_t index_id = OB_INVALID_ID); static int set_index_table_columns(const obrpc::ObCreateIndexArg& arg, const share::schema::ObTableSchema& data_schema, share::schema::ObTableSchema& index_schema, bool check_data_schema = true); @@ -67,8 +68,8 @@ private: }; static int generate_fulltext_column(OrderFTColumns& ft_cols, share::schema::ObTableSchema& data_schema, uint64_t specified_virtual_cid, share::schema::ObColumnSchemaV2*& ft_col); - static int generate_prefix_column(const obrpc::ObColumnSortItem& sort_item, share::schema::ObTableSchema& data_schema, - share::schema::ObColumnSchemaV2*& prefix_col); + static int generate_prefix_column(const obrpc::ObColumnSortItem& sort_item, const ObSQLMode sql_mode, + share::schema::ObTableSchema& data_schema, share::schema::ObColumnSchemaV2*& prefix_col); static int adjust_fulltext_args(obrpc::ObCreateIndexArg& arg, share::schema::ObTableSchema& data_schema, share::schema::ObColumnSchemaV2*& ft_col); static int adjust_fulltext_columns(obrpc::ObCreateIndexArg& arg, OrderFTColumns& ft_columns); diff --git a/src/share/ob_rpc_struct.cpp b/src/share/ob_rpc_struct.cpp index 67c2d47aef..d915a1e0c3 100644 --- a/src/share/ob_rpc_struct.cpp +++ b/src/share/ob_rpc_struct.cpp @@ -1701,14 +1701,19 @@ DEF_TO_STRING(ObCreateIndexArg) K_(index_table_id), K_(if_not_exist), K_(index_schema), - K_(is_inner)); + K_(is_inner), + K_(nls_date_format), + K_(nls_timestamp_format), + K_(nls_timestamp_tz_format), + K_(sql_mode)); J_OBJ_END(); return pos; } OB_SERIALIZE_MEMBER((ObCreateIndexArg, ObIndexArg), index_type_, index_columns_, store_columns_, index_option_, index_using_type_, fulltext_columns_, create_mode_, data_table_id_, index_table_id_, if_not_exist_, with_rowid_, - index_schema_, is_inner_, hidden_store_columns_); + index_schema_, is_inner_, hidden_store_columns_, nls_date_format_, nls_timestamp_format_, nls_timestamp_tz_format_, + sql_mode_); bool ObAlterIndexArg::is_valid() const { diff --git a/src/share/ob_rpc_struct.h b/src/share/ob_rpc_struct.h index 2eceadab49..3a822abb08 100644 --- a/src/share/ob_rpc_struct.h +++ b/src/share/ob_rpc_struct.h @@ -1800,7 +1800,11 @@ public: if_not_exist_(false), with_rowid_(false), index_schema_(), - is_inner_(false) + is_inner_(false), + nls_date_format_(), + nls_timestamp_format_(), + nls_timestamp_tz_format_(), + sql_mode_(0) { index_action_type_ = ADD_INDEX; index_using_type_ = share::schema::USING_BTREE; @@ -1824,6 +1828,10 @@ public: with_rowid_ = false; index_schema_.reset(); is_inner_ = false; + nls_date_format_.reset(); + nls_timestamp_format_.reset(); + nls_timestamp_tz_format_.reset(); + sql_mode_ = 0; } bool is_valid() const; int assign(const ObCreateIndexArg& other) @@ -1851,6 +1859,10 @@ public: if_not_exist_ = other.if_not_exist_; with_rowid_ = other.with_rowid_; is_inner_ = other.is_inner_; + nls_date_format_ = other.nls_date_format_; + nls_timestamp_format_ = other.nls_timestamp_format_; + nls_timestamp_tz_format_ = other.nls_timestamp_tz_format_; + sql_mode_ = other.sql_mode_; } return ret; } @@ -1877,6 +1889,11 @@ public: bool with_rowid_; share::schema::ObTableSchema index_schema_; // Index table schema bool is_inner_; + // Nls_xx_format is required when creating a functional index + common::ObString nls_date_format_; + common::ObString nls_timestamp_format_; + common::ObString nls_timestamp_tz_format_; + ObSQLMode sql_mode_; }; struct ObCreateForeignKeyArg : public ObIndexArg { diff --git a/src/share/schema/ob_schema_struct.h b/src/share/schema/ob_schema_struct.h index 94c28549f4..f477d8202c 100644 --- a/src/share/schema/ob_schema_struct.h +++ b/src/share/schema/ob_schema_struct.h @@ -88,6 +88,7 @@ static const uint64_t OB_MIN_ID = 0; // used for lower_bound #define INVISIBLE_COLUMN_FLAG (INT64_C(1) << 6) // The logic of the new table without a primary key changes the column (partition key) to the primary key #define HEAP_ALTER_ROWKEY_FLAG (INT64_C(1) << 8) +#define PAD_WHEN_CALC_GENERATED_COLUMN_FLAG (INT64_C(1) << 19) // the high 32-bit flag isn't stored in __all_column #define GENERATED_DEPS_CASCADE_FLAG (INT64_C(1) << 32) #define GENERATED_CTXCAT_CASCADE_FLAG (INT64_C(1) << 33) diff --git a/src/sql/ob_sql_utils.cpp b/src/sql/ob_sql_utils.cpp index 3bf26fb707..6e9de1a027 100644 --- a/src/sql/ob_sql_utils.cpp +++ b/src/sql/ob_sql_utils.cpp @@ -897,7 +897,9 @@ int ObSQLUtils::make_generated_expression_from_str(const common::ObString& expr_ } if (OB_SUCC(ret)) { - if (OB_FAIL(expr->formalize(&session))) { + if (OB_FAIL(ObRawExprUtils::build_pad_expr_recursively(expr_factory, session, schema, gen_col, expr))) { + LOG_WARN("add pad expr failed", K(ret)); + } else if (OB_FAIL(expr->formalize(&session))) { LOG_WARN("formalize expression failed", K(ret)); } } @@ -1000,6 +1002,7 @@ int ObSQLUtils::make_default_expr_context(uint64_t tenant_id, ObIAllocator &allo LOG_WARN("allocate memory failed", K(ret)); } else { exec_ctx = new (exec_ctx) ObExecContext(); + exec_ctx->set_my_session(default_session); expr_ctx.exec_ctx_ = exec_ctx; } } diff --git a/src/sql/resolver/ddl/ob_alter_table_resolver.cpp b/src/sql/resolver/ddl/ob_alter_table_resolver.cpp index f2784d9554..c092c4a6bc 100644 --- a/src/sql/resolver/ddl/ob_alter_table_resolver.cpp +++ b/src/sql/resolver/ddl/ob_alter_table_resolver.cpp @@ -906,6 +906,9 @@ int ObAlterTableResolver::resolve_add_index(const ParseNode& node) } } } + if (OB_SUCC(ret)) { + create_index_arg->sql_mode_ = session_info_->get_sql_mode(); + } if (OB_SUCC(ret)) { if (table_schema_->is_old_no_pk_table() && table_schema_->is_partitioned_table() && OB_FAIL(store_part_key(*table_schema_, *create_index_arg))) { diff --git a/src/sql/resolver/ddl/ob_create_index_resolver.cpp b/src/sql/resolver/ddl/ob_create_index_resolver.cpp index c29ab4cdfb..3f1f78236d 100644 --- a/src/sql/resolver/ddl/ob_create_index_resolver.cpp +++ b/src/sql/resolver/ddl/ob_create_index_resolver.cpp @@ -579,6 +579,7 @@ int ObCreateIndexResolver::set_table_option_to_stmt(bool is_partitioned) index_arg.with_rowid_ = with_rowid_; index_arg.index_schema_.set_data_table_id(data_table_id_); index_arg.index_schema_.set_table_id(index_table_id_); + index_arg.sql_mode_ = session_info_->get_sql_mode(); create_index_stmt->set_comment(comment_); } return ret; diff --git a/src/sql/resolver/ddl/ob_create_table_resolver.cpp b/src/sql/resolver/ddl/ob_create_table_resolver.cpp index 8694aed938..14c0ea8cd4 100644 --- a/src/sql/resolver/ddl/ob_create_table_resolver.cpp +++ b/src/sql/resolver/ddl/ob_create_table_resolver.cpp @@ -1710,7 +1710,7 @@ int ObCreateTableResolver::generate_index_arg() { int ret = OB_SUCCESS; - if (OB_ISNULL(stmt_)) { + if (OB_ISNULL(stmt_) || OB_ISNULL(session_info_)) { ret = OB_NOT_INIT; SQL_RESV_LOG(WARN, "variables are not inited.", K(ret), KP(stmt_)); } else if (OB_FAIL(set_index_name())) { @@ -1766,6 +1766,7 @@ int ObCreateTableResolver::generate_index_arg() // create table with index .the status of index is available index_arg_.index_option_.index_status_ = INDEX_STATUS_AVAILABLE; index_arg_.index_option_.index_attributes_set_ = index_attributes_set_; + index_arg_.sql_mode_ = session_info_->get_sql_mode(); } if (OB_FAIL(ret)) { // skip @@ -2182,8 +2183,8 @@ int ObCreateTableResolver::resolve_index_node(const ParseNode* node) LOG_WARN("build generated column expr failed", K(ret)); } else if (!expr->is_column_ref_expr()) { // real index expr, so generate hidden generated column in data table schema - if (OB_FAIL( - ObIndexBuilderUtil::generate_ordinary_generated_column(*expr, tbl_schema, column_schema))) { + if (OB_FAIL(ObIndexBuilderUtil::generate_ordinary_generated_column( + *expr, session_info_->get_sql_mode(), tbl_schema, column_schema))) { LOG_WARN("generate ordinary generated column failed", K(ret)); } else { sort_item.column_name_ = column_schema->get_column_name_str(); diff --git a/src/sql/resolver/ddl/ob_ddl_resolver.cpp b/src/sql/resolver/ddl/ob_ddl_resolver.cpp index f7f73661e6..1b5d16f241 100644 --- a/src/sql/resolver/ddl/ob_ddl_resolver.cpp +++ b/src/sql/resolver/ddl/ob_ddl_resolver.cpp @@ -1960,6 +1960,9 @@ int ObDDLResolver::resolve_column_definition(ObColumnSchemaV2& column, ParseNode } else { column.add_column_flag(VIRTUAL_GENERATED_COLUMN_FLAG); } + if (OB_SUCC(ret) && is_pad_char_to_full_length(session_info_->get_sql_mode())) { + column.add_column_flag(PAD_WHEN_CALC_GENERATED_COLUMN_FLAG); + } } } if (OB_SUCC(ret)) { diff --git a/src/sql/resolver/dml/ob_dml_resolver.cpp b/src/sql/resolver/dml/ob_dml_resolver.cpp index bd215a7b80..1c04fbe26f 100644 --- a/src/sql/resolver/dml/ob_dml_resolver.cpp +++ b/src/sql/resolver/dml/ob_dml_resolver.cpp @@ -4889,6 +4889,63 @@ int ObDMLResolver::resolve_assignments(const ParseNode& parse_node, ObTablesAssi return ret; } +// Check the pad flag on generated_column is consistent with the sql_mode on session. +// For the upgraded cluster, the flag is not set, so only returns error if the dependent column +// is char type and the generated column is stored or used by an index +int ObDMLResolver::check_pad_generated_column( + const ObSQLSessionInfo& session_info, const ObTableSchema& table_schema, const ObColumnSchemaV2& column_schema) +{ + int ret = OB_SUCCESS; + if (!column_schema.is_generated_column()) { + // do nothing + } else if (is_pad_char_to_full_length(session_info.get_sql_mode()) == + column_schema.has_column_flag(PAD_WHEN_CALC_GENERATED_COLUMN_FLAG)) { + // do nothing + } else { + bool has_char_dep_column = false; + bool is_stored_column = column_schema.is_stored_generated_column(); + ObSEArray cascaded_columns; + ObSEArray simple_index_infos; + if (OB_FAIL(column_schema.get_cascaded_column_ids(cascaded_columns))) { + LOG_WARN("failed to get cascaded_column_ids", K(column_schema)); + } else if (OB_FAIL(table_schema.get_simple_index_infos_without_delay_deleted_tid(simple_index_infos))) { + LOG_WARN("get simple_index_infos without delay_deleted_tid failed", K(ret)); + } + for (int64_t i = 0; OB_SUCC(ret) && !has_char_dep_column && i < cascaded_columns.count(); ++i) { + uint64_t column_id = cascaded_columns.at(i); + const ObColumnSchemaV2 *cascaded_col_schema = table_schema.get_column_schema(column_id); + if (OB_ISNULL(cascaded_col_schema)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("failed to get column", K(table_schema), K(column_id), K(ret)); + } else if (ObCharType == cascaded_col_schema->get_data_type() || + ObNCharType == cascaded_col_schema->get_data_type()) { + has_char_dep_column = true; + } + } + for (int64_t i = 0; OB_SUCC(ret) && !is_stored_column && i < simple_index_infos.count(); ++i) { + const ObTableSchema *index_table_schema = NULL; + if (OB_FAIL(schema_checker_->get_table_schema(simple_index_infos.at(i).table_id_, index_table_schema))) { + LOG_WARN("get_table_schema failed", "table id", simple_index_infos.at(i).table_id_, K(ret)); + } else if (OB_ISNULL(index_table_schema)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("table schema should not be null", K(ret)); + } else if (OB_FAIL(index_table_schema->has_column(column_schema.get_column_id(), is_stored_column))) { + LOG_WARN("falied to check if column is in index schema", K(ret)); + } + } + if (OB_FAIL(ret)) { + } else if (has_char_dep_column && is_stored_column) { + ret = OB_NOT_SUPPORTED; + LOG_WARN("change PAD_CHAR option after created generated column", + K(session_info.get_sql_mode()), + K(column_schema), + K(ret)); + LOG_USER_ERROR(OB_NOT_SUPPORTED, "change PAD_CHAR option after created generated column"); + } + } + return ret; +} + int ObDMLResolver::build_padding_expr(const ObSQLSessionInfo* session, const ColumnItem* column, ObRawExpr*& expr) { int ret = OB_SUCCESS; @@ -5702,9 +5759,14 @@ int ObDMLResolver::resolve_generated_column_expr(const ObString& expr_str, const ObArray columns; ObRawExprFactory* expr_factory = NULL; ObSQLSessionInfo* session_info = NULL; - if (OB_ISNULL(expr_factory = params_.expr_factory_) || OB_ISNULL(session_info = params_.session_info_)) { + const ObTableSchema* table_schema = NULL; + if (OB_ISNULL(expr_factory = params_.expr_factory_) || OB_ISNULL(session_info = params_.session_info_) || + OB_ISNULL(schema_checker_)) { ret = OB_NOT_INIT; LOG_WARN("expr_factory is null", K_(params_.expr_factory), K_(params_.session_info)); + } else if (OB_NOT_NULL(column_schema) && + OB_FAIL(schema_checker_->get_table_schema(column_schema->get_table_id(), table_schema))) { + LOG_WARN("get table schema error", K(ret)); } else if (OB_FAIL(ObRawExprUtils::build_generated_column_expr( expr_str, *expr_factory, *session_info, ref_expr, columns, schema_checker_))) { LOG_WARN("build generated column expr failed", K(ret)); @@ -5763,10 +5825,15 @@ int ObDMLResolver::resolve_generated_column_expr(const ObString& expr_str, const } if (OB_SUCC(ret)) { - if (OB_FAIL(ref_expr->formalize(session_info))) { - LOG_WARN("formailize column reference expr failed", K(ret)); + if (OB_FAIL(check_pad_generated_column(*session_info, *table_schema, *column_schema))) { + LOG_WARN("check pad generated column failed", K(ret)); + } else if (OB_FAIL(ObRawExprUtils::build_pad_expr_recursively( + *expr_factory, *session_info, *table_schema, *column_schema, ref_expr))) { + LOG_WARN("build padding expr for column_ref failed", K(ret)); } else if (OB_FAIL(build_padding_expr(session_info, column_schema, ref_expr))) { - LOG_WARN("build padding expr error", K(ret)); + LOG_WARN("build padding expr for self failed", K(ret)); + } else if (OB_FAIL(ref_expr->formalize(session_info))) { + LOG_WARN("formailize column reference expr failed", K(ret)); } else if (ObRawExprUtils::need_column_conv(column.get_result_type(), *ref_expr)) { if (OB_FAIL(ObRawExprUtils::build_column_conv_expr(*expr_factory, *allocator_, column, ref_expr, session_info))) { LOG_WARN("build column convert expr failed", K(ret)); diff --git a/src/sql/resolver/dml/ob_dml_resolver.h b/src/sql/resolver/dml/ob_dml_resolver.h index 0aa252f68e..ccc9c03547 100644 --- a/src/sql/resolver/dml/ob_dml_resolver.h +++ b/src/sql/resolver/dml/ob_dml_resolver.h @@ -253,6 +253,8 @@ protected: int build_partition_key_info(const share::schema::ObTableSchema& table_schema, ObRawExpr*& part_expr); virtual int expand_view(TableItem& view_item); int do_expand_view(TableItem& view_item, ObChildStmtResolver& view_resolver); + int check_pad_generated_column(const ObSQLSessionInfo& session_info, const share::schema::ObTableSchema& table_schema, + const share::schema::ObColumnSchemaV2& column_schema); int build_padding_expr(const ObSQLSessionInfo* session, const ColumnItem* column, ObRawExpr*& expr); int build_padding_expr( diff --git a/src/sql/resolver/expr/ob_raw_expr_util.cpp b/src/sql/resolver/expr/ob_raw_expr_util.cpp index fef912847b..e277e1b415 100644 --- a/src/sql/resolver/expr/ob_raw_expr_util.cpp +++ b/src/sql/resolver/expr/ob_raw_expr_util.cpp @@ -1371,6 +1371,46 @@ int ObRawExprUtils::build_generated_column_expr(const ObString& expr_str, ObRawE return ret; } +int ObRawExprUtils::build_pad_expr_recursively(ObRawExprFactory &expr_factory, const ObSQLSessionInfo &session, + const ObTableSchema &table_schema, const ObColumnSchemaV2 &gen_col_schema, ObRawExpr *&expr) +{ + int ret = OB_SUCCESS; + CK(OB_NOT_NULL(expr)); + + if (OB_SUCC(ret) && expr->get_param_count() > 0) { + for (int i = 0; OB_SUCC(ret) && i < expr->get_param_count(); i++) { + OZ(SMART_CALL( + build_pad_expr_recursively(expr_factory, session, table_schema, gen_col_schema, expr->get_param_expr(i)))); + } + } + if (OB_SUCC(ret) && expr->is_column_ref_expr()) { + ObColumnRefRawExpr *b_expr = static_cast(expr); + uint64_t column_id = b_expr->get_column_id(); + if (OB_SUCC(ret)) { + const ObColumnSchemaV2 *column_schema = table_schema.get_column_schema(column_id); + if (NULL == column_schema) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("get column schema fail", K(column_schema)); + } else if (ObObjMeta::is_binary(column_schema->get_data_type(), column_schema->get_collation_type())) { + if (OB_FAIL(build_pad_expr(expr_factory, false, column_schema, expr, &session))) { + LOG_WARN("fail to build pading expr for binary", K(ret)); + } + } else if (ObCharType == column_schema->get_data_type() || ObNCharType == column_schema->get_data_type()) { + if (gen_col_schema.has_column_flag(PAD_WHEN_CALC_GENERATED_COLUMN_FLAG)) { + if (OB_FAIL(build_pad_expr(expr_factory, true, column_schema, expr, &session))) { + LOG_WARN("fail to build pading expr for char", K(ret)); + } + } else { + if (OB_FAIL(build_trim_expr(column_schema, expr_factory, &session, expr))) { + LOG_WARN("fail to build trime expr for char", K(ret)); + } + } + } + } + } + return ret; +} + // compare two raw expressions bool ObRawExprUtils::is_same_raw_expr(const ObRawExpr* src, const ObRawExpr* dst) { @@ -2665,7 +2705,7 @@ int ObRawExprUtils::build_null_expr(ObRawExprFactory& expr_factory, ObRawExpr*& } int ObRawExprUtils::build_trim_expr(const ObColumnSchemaV2* column_schema, ObRawExprFactory& expr_factory, - ObSQLSessionInfo* session_info, ObRawExpr*& expr) + const ObSQLSessionInfo* session_info, ObRawExpr*& expr) { int ret = OB_SUCCESS; ObSysFunRawExpr* trim_expr = NULL; @@ -2716,7 +2756,7 @@ int ObRawExprUtils::build_trim_expr(const ObColumnSchemaV2* column_schema, ObRaw } int ObRawExprUtils::build_pad_expr(ObRawExprFactory& expr_factory, bool is_char, const ObColumnSchemaV2* column_schema, - ObRawExpr*& expr, sql::ObSQLSessionInfo* session_info) + ObRawExpr*& expr, const sql::ObSQLSessionInfo* session_info) { int ret = OB_SUCCESS; ObSysFunRawExpr* pad_expr = NULL; diff --git a/src/sql/resolver/expr/ob_raw_expr_util.h b/src/sql/resolver/expr/ob_raw_expr_util.h index 7c51909e0b..d8c777490a 100644 --- a/src/sql/resolver/expr/ob_raw_expr_util.h +++ b/src/sql/resolver/expr/ob_raw_expr_util.h @@ -195,6 +195,9 @@ public: const share::schema::ObColumnSchemaV2& gen_col_schema, ObRawExpr*& expr, const ObSchemaChecker* schema_checker = NULL, const ObResolverUtils::PureFunctionCheckStatus check_status = ObResolverUtils::DISABLE_CHECK); + static int build_pad_expr_recursively(ObRawExprFactory& expr_factory, const ObSQLSessionInfo& session, + const share::schema::ObTableSchema& table_schema, const share::schema::ObColumnSchemaV2& gen_col_schema, + ObRawExpr*& expr); static int build_raw_expr(ObRawExprFactory& expr_factory, const ObSQLSessionInfo& session_info, const ParseNode& node, ObRawExpr*& expr, common::ObIArray& columns, common::ObIArray& sys_vars, common::ObIArray& aggr_exprs, common::ObIArray& win_exprs, @@ -273,10 +276,11 @@ public: static int create_param_expr( ObRawExprFactory& expr_factory, int64_t param_idx, ObRawExpr*& expr, bool is_exec_param = false); static int build_trim_expr(const share::schema::ObColumnSchemaV2* column_schema, ObRawExprFactory& expr_factory, - ObSQLSessionInfo* session_info, ObRawExpr*& expr); + const ObSQLSessionInfo* session_info, ObRawExpr*& expr); static bool need_column_conv(const ColumnItem& column, ObRawExpr& expr); static int build_pad_expr(ObRawExprFactory& expr_factory, bool is_char, - const share::schema::ObColumnSchemaV2* column_schema, ObRawExpr*& expr, sql::ObSQLSessionInfo* session_info); + const share::schema::ObColumnSchemaV2* column_schema, ObRawExpr*& expr, + const sql::ObSQLSessionInfo* session_info); static bool need_column_conv(const ObExprResType& expected_type, const ObRawExpr& expr); static int build_column_conv_expr(ObRawExprFactory& expr_factory, const share::schema::ObColumnSchemaV2* column_schema, ObRawExpr*& expr,