Fix incorrect xml hidden column name mapping during table redefinition

src/rootserver/ddl_task/ob_ddl_redefinition_task.cpp

@@ -65,6 +65,7 @@ ObDDLRedefinitionSSTableBuildTask::ObDDLRedefinitionSSTableBuildTask(
 
 int ObDDLRedefinitionSSTableBuildTask::init(
     const ObTableSchema &orig_table_schema,
+    const ObTableSchema &hidden_table_schema,
     const AlterTableSchema &alter_table_schema,
     const ObTimeZoneInfoWrap &tz_info_wrap,
     const ObIArray<ObBasedSchemaObjectInfo> &based_schema_object_infos)
@@ -77,7 +78,7 @@ int ObDDLRedefinitionSSTableBuildTask::init(
     LOG_WARN("ddl sim failure", K(ret), K(tenant_id_), K(task_id_));
   } else if (OB_FAIL(tz_info_wrap_.deep_copy(tz_info_wrap))) {
     LOG_WARN("fail to copy time zone info wrap", K(ret), K(tz_info_wrap));
-  } else if (OB_FAIL(col_name_map_.init(orig_table_schema, alter_table_schema))) {
+  } else if (OB_FAIL(col_name_map_.init(orig_table_schema, hidden_table_schema, alter_table_schema))) {
     LOG_WARN("failed to init column name map", K(ret));
   } else if (OB_FAIL(based_schema_object_infos_.assign(based_schema_object_infos))) {
     LOG_WARN("fail to assign based schema object infos", K(ret), K(based_schema_object_infos));
@@ -613,7 +614,7 @@ int ObDDLRedefinitionTask::get_validate_checksum_columns_id(const ObTableSchema
     ObColumnNameMap col_name_map;
     if (OB_FAIL(data_table_schema.get_column_ids(column_ids))) {
       LOG_WARN("get column ids failed", K(ret), K(object_id_));
-    } else if (OB_FAIL(col_name_map.init(data_table_schema, alter_table_arg_.alter_table_schema_))) {
+    } else if (OB_FAIL(col_name_map.init(data_table_schema, dest_table_schema, alter_table_arg_.alter_table_schema_))) {
       LOG_WARN("failed to build column name map", K(ret));
     }
     for (int64_t i = 0; OB_SUCC(ret) && i < column_ids.count(); ++i) {
@@ -1272,7 +1273,7 @@ int ObDDLRedefinitionTask::modify_autoinc(const ObDDLTaskStatus next_task_status
     } else if (OB_ISNULL(orig_table_schema) || OB_ISNULL(new_table_schema)) {
       ret = OB_ERR_UNEXPECTED;
       LOG_WARN("table schemas should not be null", K(ret), K(orig_table_schema), K(new_table_schema));
-    } else if (OB_FAIL(col_name_map.init(*orig_table_schema, alter_table_schema))) {
+    } else if (OB_FAIL(col_name_map.init(*orig_table_schema, *new_table_schema, alter_table_schema))) {
       LOG_WARN("failed to init column name map", K(ret));
     } else if (!is_update_autoinc_end && update_autoinc_job_time_ == 0) {
       ObTableSchema::const_column_iterator iter = alter_table_schema.column_begin();
@@ -2123,7 +2124,7 @@ int ObDDLRedefinitionTask::sync_column_level_stats_info(common::ObMySQLTransacti
   int ret = OB_SUCCESS;
   AlterTableSchema &alter_table_schema = alter_table_arg_.alter_table_schema_;
   ObColumnNameMap col_name_map;
-  if (OB_FAIL(col_name_map.init(data_table_schema, alter_table_schema))) {
+  if (OB_FAIL(col_name_map.init(data_table_schema, new_table_schema, alter_table_schema))) {
     LOG_WARN("failed to init column name map", K(ret));
   } else {
     ObTableSchema::const_column_iterator iter = data_table_schema.column_begin();

src/rootserver/ddl_task/ob_ddl_redefinition_task.h

@@ -45,6 +45,7 @@ public:
       const int64_t data_format_version = 0);
   int init(
       const ObTableSchema &orig_table_schema,
+      const ObTableSchema &hidden_table_schema,
       const AlterTableSchema &alter_table_schema,
       const ObTimeZoneInfoWrap &tz_info_wrap,
       const common::ObIArray<share::schema::ObBasedSchemaObjectInfo> &based_schema_object_infos);

src/rootserver/ddl_task/ob_table_redefinition_task.cpp

@@ -287,6 +287,7 @@ int ObTableRedefinitionTask::send_build_replica_request_by_sql()
     }
     ObSchemaGetterGuard schema_guard;
     const ObTableSchema *orig_table_schema = nullptr;
+    const ObTableSchema *hidden_table_schema = nullptr;
     ObDDLRedefinitionSSTableBuildTask task(
         task_id_,
         tenant_id_,
@@ -309,7 +310,9 @@ int ObTableRedefinitionTask::send_build_replica_request_by_sql()
       LOG_WARN("get schema guard failed", K(ret));
     } else if (OB_FAIL(schema_guard.get_table_schema(tenant_id_, object_id_, orig_table_schema))) {
       LOG_WARN("failed to get orig table schema", K(ret));
-    } else if (OB_FAIL(task.init(*orig_table_schema, alter_table_arg_.alter_table_schema_, alter_table_arg_.tz_info_wrap_, alter_table_arg_.based_schema_object_infos_))) {
+    } else if (OB_FAIL(schema_guard.get_table_schema(dst_tenant_id_, target_object_id_, hidden_table_schema))) {
+      LOG_WARN("fail to get table schema", K(ret), K(target_object_id_));
+    } else if (OB_FAIL(task.init(*orig_table_schema, *hidden_table_schema, alter_table_arg_.alter_table_schema_, alter_table_arg_.tz_info_wrap_, alter_table_arg_.based_schema_object_infos_))) {
       LOG_WARN("fail to init table redefinition sstable build task", K(ret));
     } else if (OB_FAIL(root_service->submit_ddl_single_replica_build_task(task))) {
       LOG_WARN("fail to submit ddl build single replica", K(ret));

src/rootserver/ob_ddl_service.cpp

@@ -17278,7 +17278,7 @@ int ObDDLService::rebuild_hidden_table_index_in_trans(obrpc::ObAlterTableArg &al
       }
     } else {
       ObDDLOperator ddl_operator(*schema_service_, *sql_proxy_);
-      if (OB_FAIL(col_name_map.init(*orig_table_schema, alter_table_schema))) {
+      if (OB_FAIL(col_name_map.init(*orig_table_schema, *hidden_table_schema, alter_table_schema))) {
         LOG_WARN("failed to init column name map", K(ret), K(alter_table_schema), KPC(orig_table_schema));
       } else if (OB_FAIL(get_all_dropped_column_ids(alter_table_arg, *orig_table_schema, drop_cols_id_arr))) {
         LOG_WARN("fail to get drop cols id set", K(ret));
@@ -17488,7 +17488,7 @@ int ObDDLService::rebuild_hidden_table_constraints(
     LOG_WARN("fail to get constraints that need to rebuild", K(ret));
   } else if (rebuild_constraints.count() == 0) {
     // no constraints, or constraints have been rebuilt.
-  } else if (OB_FAIL(col_name_map.init(orig_table_schema, alter_table_arg.alter_table_schema_))) {
+  } else if (OB_FAIL(col_name_map.init(orig_table_schema, hidden_table_schema, alter_table_arg.alter_table_schema_))) {
     LOG_WARN("failed to init column name map", K(ret));
   } else {
     new_table_schema.clear_constraint();
@@ -17978,7 +17978,7 @@ int ObDDLService::rebuild_hidden_table_foreign_key(
     LOG_WARN("fail to get fk infos that need to rebuild", K(ret));
   } else if (OB_FAIL(inc_table_schema.set_foreign_key_infos(rebuild_fk_infos))) {
     LOG_WARN("fail to set fk infos", K(ret));
-  } else if (OB_FAIL(col_name_map.init(orig_table_schema, alter_table_arg.alter_table_schema_))) {
+  } else if (OB_FAIL(col_name_map.init(orig_table_schema, hidden_table_schema, alter_table_arg.alter_table_schema_))) {
     LOG_WARN("failed to init column name map", K(ret));
   } else {
     ObIArray<ObForeignKeyInfo> &foreign_key_infos = inc_table_schema.get_foreign_key_infos();
@@ -19294,7 +19294,7 @@ int ObDDLService::modify_hidden_table_fk_state(obrpc::ObAlterTableArg &alter_tab
       uint64_t hidden_column_id = 0;
       if (nullptr == orig_table_schema->get_column_schema(orig_column_id)) {
         hidden_column_id = orig_column_id;
-      } else if (OB_FAIL(col_name_map.init(*orig_table_schema, alter_table_schema))) {
+      } else if (OB_FAIL(col_name_map.init(*orig_table_schema, *hidden_table_schema, alter_table_schema))) {
         LOG_WARN("failed to init column name map", K(ret));
       } else if (OB_FAIL(get_hidden_table_column_id_by_orig_column_id(*orig_table_schema,
                                                                       *hidden_table_schema,

src/share/ob_ddl_common.cpp

@@ -142,6 +142,7 @@ const char *oceanbase::share::get_ddl_type(ObDDLType ddl_type)
 }
 
 int ObColumnNameMap::init(const ObTableSchema &orig_table_schema,
+                          const ObTableSchema &new_table_schema,
                           const AlterTableSchema &alter_table_schema)
 {
   int ret = OB_SUCCESS;
@@ -207,6 +208,66 @@ int ObColumnNameMap::init(const ObTableSchema &orig_table_schema,
       }
     }
   }
+  if (OB_FAIL(ret)) {
+  } else if (OB_FAIL(init_xml_hidden_column_name_map(orig_table_schema, new_table_schema))) {
+    LOG_WARN("failed to init xml hidden column name map", K(ret));
+  }
+  return ret;
+}
+
+int ObColumnNameMap::init_xml_hidden_column_name_map(const ObTableSchema &orig_table_schema,
+                                                     const ObTableSchema &new_table_schema)
+{
+  int ret = OB_SUCCESS;
+  lib::CompatModeGuard guard(compat_mode_);
+  for (ObTableSchema::const_column_iterator it = orig_table_schema.column_begin();
+      OB_SUCC(ret) && it != orig_table_schema.column_end(); it++) {
+    ObColumnSchemaV2 *column = *it;
+    if (OB_ISNULL(column)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("invalid column", K(ret));
+    } else if (column->is_xmltype()) {
+      ObString new_column_name;
+      const ObColumnSchemaV2 *new_column = nullptr;
+      if (OB_FAIL(get(column->get_column_name_str(), new_column_name))) {
+        if (OB_ENTRY_NOT_EXIST == ret) {
+          ret = OB_SUCCESS;
+        } else {
+          LOG_WARN("failed to get new xml column name", K(ret));
+        }
+      } else if (OB_ISNULL(new_column = new_table_schema.get_column_schema(new_column_name))) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_WARN("failed to find new column", K(ret), K(new_column_name), K(new_table_schema));
+      } else if (new_column->is_xmltype()) {
+        const uint64_t orig_column_id = column->get_column_id();
+        const uint64_t orig_udt_set_id = column->get_udt_set_id();
+        const uint64_t new_column_id = new_column->get_column_id();
+        const uint64_t new_udt_set_id = new_column->get_udt_set_id();
+        ObColumnSchemaV2 *orig_xml_hidden_column = nullptr;
+        ObColumnSchemaV2 *new_xml_hidden_column = nullptr;
+        if (OB_UNLIKELY(orig_udt_set_id <= 0 || new_udt_set_id <= 0)) {
+          ret = OB_ERR_UNEXPECTED;
+          LOG_WARN("invalid udt set id for xml column", K(ret), KPC(column), KPC(new_column));
+        } else if (OB_ISNULL(orig_xml_hidden_column = orig_table_schema.get_xml_hidden_column_schema(orig_column_id, orig_udt_set_id))) {
+          ret = OB_ERR_UNEXPECTED;
+          LOG_WARN("orig xml hidden column not found", K(ret), K(orig_column_id), K(orig_udt_set_id));
+        } else if (OB_ISNULL(new_xml_hidden_column = new_table_schema.get_xml_hidden_column_schema(new_column_id, new_udt_set_id))) {
+          ret = OB_ERR_UNEXPECTED;
+          LOG_WARN("new xml hidden column not found", K(ret), K(new_column_id), K(new_udt_set_id));
+        } else {
+          const ObString &orig_xml_hidden_column_name = orig_xml_hidden_column->get_column_name_str();
+          const ObString &new_xml_hidden_column_name = new_xml_hidden_column->get_column_name_str();
+          if (orig_xml_hidden_column_name != new_xml_hidden_column_name) {
+            if (OB_FAIL(col_name_map_.erase_refactored(ObColumnNameHashWrapper(orig_xml_hidden_column_name)))) {
+              LOG_WARN("failed to erase col name map", K(ret));
+            } else if (OB_FAIL(set(orig_xml_hidden_column_name, new_xml_hidden_column_name))) {
+              LOG_WARN("failed to set column name map", K(ret));
+            }
+          }
+        }
+      }
+    }
+  }
   return ret;
 }
 

src/share/ob_ddl_common.h

@@ -305,7 +305,11 @@ public:
   ObColumnNameMap() {}
   ~ObColumnNameMap() {}
   int init(const schema::ObTableSchema &orig_table_schema,
+           const schema::ObTableSchema &new_table_schema,
            const schema::AlterTableSchema &alter_table_arg);
+  int init_xml_hidden_column_name_map(
+      const schema::ObTableSchema &orig_table_schema,
+      const schema::ObTableSchema &new_table_schema);
   int assign(const ObColumnNameMap &other);
   int set(const ObString &orig_column_name, const ObString &new_column_name);
   int get(const ObString &orig_column_name, ObString &new_column_name) const;