This is an automated email from the ASF dual-hosted git repository.

jt2594838 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/iotdb.git


The following commit(s) were added to refs/heads/master by this push:
     new 6a835428868 Allow compatible types when loading TsFiles (#19293)
6a835428868 is described below

commit 6a8354288686e9fbf15f4d299a53f9c6ce13698b
Author: Caideyipi <[email protected]>
AuthorDate: Tue Nov 17 16:25:17 2026 +0800

    Allow compatible types when loading TsFiles (#19293)
    
    * [Load] Support compatible TsFile data types in LOAD
    
    * [Load] Fix compatible LOAD integration tests
    
    * Fix incompatible schema fixtures in active load IT
    
    * Avoid tablet conversion for compatible TsFile types
    
    * Keep active load retry test on conversion path
---
 .../iotdb/it/utils/TsFileTableGenerator.java       |  4 ++
 .../iotdb/db/it/IoTDBLoadTsFileActiveRetryIT.java  | 14 ++++--
 .../org/apache/iotdb/db/it/IoTDBLoadTsFileIT.java  | 34 +++++++++++++
 .../relational/it/db/it/IoTDBLoadTsFileIT.java     | 38 +++++++++++++++
 .../plan/analyze/load/LoadTsFileAnalyzer.java      |  4 ++
 .../analyze/load/LoadTsFileTableSchemaCache.java   | 33 ++++++++-----
 .../load/TreeSchemaAutoCreatorAndVerifier.java     | 20 ++++----
 .../LoadConvertedInsertTabletStatement.java        |  4 ++
 .../PipeConvertedInsertTabletStatementTest.java    | 32 ++++++++++++
 .../plan/analyze/load/LoadTsFileAnalyzerTest.java  | 57 ++++++++++++++++++++--
 10 files changed, 209 insertions(+), 31 deletions(-)

diff --git 
a/integration-test/src/main/java/org/apache/iotdb/it/utils/TsFileTableGenerator.java
 
b/integration-test/src/main/java/org/apache/iotdb/it/utils/TsFileTableGenerator.java
index 613ea8bd159..ae84d72cf62 100644
--- 
a/integration-test/src/main/java/org/apache/iotdb/it/utils/TsFileTableGenerator.java
+++ 
b/integration-test/src/main/java/org/apache/iotdb/it/utils/TsFileTableGenerator.java
@@ -79,6 +79,10 @@ public class TsFileTableGenerator implements AutoCloseable {
     table2ColumnCategory.put(tableName, columnCategoryList);
   }
 
+  public void resetRandom(final long seed) {
+    random = new Random(seed);
+  }
+
   public void generateData(final String tableName, final int number, final 
long timeGap)
       throws IOException, WriteProcessException {
     final List<IMeasurementSchema> schemas = 
table2MeasurementSchema.get(tableName);
diff --git 
a/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBLoadTsFileActiveRetryIT.java
 
b/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBLoadTsFileActiveRetryIT.java
index 3fd7205dd74..6caedf6b482 100644
--- 
a/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBLoadTsFileActiveRetryIT.java
+++ 
b/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBLoadTsFileActiveRetryIT.java
@@ -74,6 +74,8 @@ public class IoTDBLoadTsFileActiveRetryIT {
       Long.MAX_VALUE / 4;
   private static final MeasurementSchema TSFILE_SCHEMA =
       new MeasurementSchema(MEASUREMENT, TSDataType.INT32, TSEncoding.RLE);
+  private static final MeasurementSchema INCOMPATIBLE_TSFILE_SCHEMA =
+      new MeasurementSchema(MEASUREMENT, TSDataType.BOOLEAN, TSEncoding.RLE);
 
   private File tmpDir;
 
@@ -111,8 +113,9 @@ public class IoTDBLoadTsFileActiveRetryIT {
     final DataNodeWrapper dataNodeWrapper = 
EnvFactory.getEnv().getDataNodeWrapper(0);
     final File retryTsFile = new File(tmpDir, "1-0-0-0.tsfile");
     final File permanentFailureTsFile = new File(tmpDir, "2-0-0-0.tsfile");
-    generateTsFile(retryTsFile);
-    generateTsFile(permanentFailureTsFile);
+    generateTsFile(retryTsFile, INCOMPATIBLE_TSFILE_SCHEMA);
+    // BOOLEAN -> INT64 stays incompatible when type-mismatch conversion is 
disabled.
+    generateTsFile(permanentFailureTsFile, INCOMPATIBLE_TSFILE_SCHEMA);
 
     try (final Connection connection =
             
EnvFactory.getEnv().getConnectionWithSpecifiedDataNode(dataNodeWrapper);
@@ -192,7 +195,7 @@ public class IoTDBLoadTsFileActiveRetryIT {
       statement.execute(
           String.format(
               "create timeseries %s.%s %s",
-              COLLISION_DEVICE, MEASUREMENT, TSDataType.INT64.name()));
+              COLLISION_DEVICE, MEASUREMENT, TSDataType.BOOLEAN.name()));
       for (final File tsFile : sourceTsFiles) {
         statement.execute(
             String.format(
@@ -567,9 +570,10 @@ public class IoTDBLoadTsFileActiveRetryIT {
     }
   }
 
-  private void generateTsFile(final File tsFile) throws Exception {
+  private void generateTsFile(final File tsFile, final IMeasurementSchema 
measurementSchema)
+      throws Exception {
     try (final TsFileGenerator generator = new TsFileGenerator(tsFile)) {
-      generator.registerTimeseries(DEVICE, 
Collections.singletonList(TSFILE_SCHEMA));
+      generator.registerTimeseries(DEVICE, 
Collections.singletonList(measurementSchema));
       generator.generateData(DEVICE, 10, 1, false);
     }
   }
diff --git 
a/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBLoadTsFileIT.java 
b/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBLoadTsFileIT.java
index b17c6a19b57..f3a0df6dbd0 100644
--- 
a/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBLoadTsFileIT.java
+++ 
b/integration-test/src/test/java/org/apache/iotdb/db/it/IoTDBLoadTsFileIT.java
@@ -75,6 +75,7 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Random;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
@@ -631,6 +632,39 @@ public class IoTDBLoadTsFileIT {
     }
   }
 
+  @Test
+  public void testLoadWithCompatibleDataType() throws Exception {
+    registerSchema();
+
+    final String device = "root.sg.test_0.compatible_type";
+    final MeasurementSchema fileSchema = new MeasurementSchema("s", 
TSDataType.INT32);
+    final MeasurementSchema targetSchema = new MeasurementSchema("s", 
TSDataType.INT64);
+    final long seed = 42L;
+    final long expectedValue = new Random(seed).nextInt();
+    final File file = new File(tmpDir, "1-0-0-0.tsfile");
+
+    try (final TsFileGenerator generator = new TsFileGenerator(file)) {
+      generator.registerTimeseries(device, 
Collections.singletonList(fileSchema));
+      generator.resetRandom(seed);
+      generator.generateData(device, 1, 1000L, false);
+    }
+
+    try (final Connection connection = EnvFactory.getEnv().getConnection();
+        final Statement statement = connection.createStatement()) {
+      statement.execute(convert2SQL(device, targetSchema));
+      statement.execute(
+          String.format(
+              "load \"%s\" with ('tablet-conversion-threshold'='-1')", 
file.getAbsolutePath()));
+
+      try (final ResultSet resultSet =
+          statement.executeQuery(String.format("select s from %s where 
time=1000", device))) {
+        Assert.assertTrue(resultSet.next());
+        Assert.assertEquals(expectedValue, resultSet.getLong(2));
+        Assert.assertFalse(resultSet.next());
+      }
+    }
+  }
+
   // Loading aligned and non-aligned devices extends the bound template and 
preserves every point.
   @Test
   public void testLoadWithExtendTemplate() throws Exception {
diff --git 
a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBLoadTsFileIT.java
 
b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBLoadTsFileIT.java
index 26e3fb0ac5a..e18f03b0fdb 100644
--- 
a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBLoadTsFileIT.java
+++ 
b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBLoadTsFileIT.java
@@ -67,6 +67,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
+import java.util.Random;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
@@ -288,6 +289,43 @@ public class IoTDBLoadTsFileIT {
     }
   }
 
+  @Test
+  public void testLoadWithCompatibleDataType() throws Exception {
+    final String tableName = "load_compatible_type";
+    final MeasurementSchema fileSchema = new MeasurementSchema("f", 
TSDataType.INT32);
+    final MeasurementSchema targetSchema = new MeasurementSchema("f", 
TSDataType.INT64);
+    final List<ColumnCategory> columnCategories = 
Collections.singletonList(ColumnCategory.FIELD);
+    final long seed = 42L;
+    final long expectedValue = new Random(seed).nextInt();
+    final File file = new File(tmpDir, "1-0-0-0.tsfile");
+
+    try (final TsFileTableGenerator generator = new 
TsFileTableGenerator(file)) {
+      generator.registerTable(tableName, 
Collections.singletonList(fileSchema), columnCategories);
+      generator.resetRandom(seed);
+      generator.generateData(tableName, 1, 1000L);
+    }
+
+    try (final Connection connection =
+            EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+        final Statement statement = connection.createStatement()) {
+      statement.execute(String.format("create database if not exists %s", 
database));
+      statement.execute(String.format("use %s", database));
+      statement.execute(
+          convert2TableSQL(tableName, Collections.singletonList(targetSchema), 
columnCategories));
+      statement.execute(
+          String.format(
+              "load '%s' with ('database'='%s', 
'tablet-conversion-threshold'='-1')",
+              file.getAbsolutePath(), database));
+
+      try (final ResultSet resultSet =
+          statement.executeQuery(String.format("select f from %s order by 
time", tableName))) {
+        Assert.assertTrue(resultSet.next());
+        Assert.assertEquals(expectedValue, resultSet.getLong(1));
+        Assert.assertFalse(resultSet.next());
+      }
+    }
+  }
+
   /**
    * Generate two tables with 10,000 rows each and delete all rows from the 
second through TsFile
    * mods; after loading, expect 10,000 rows in the first table and only that 
table to be visible.
diff --git 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzer.java
 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzer.java
index 5193a352acb..551130ad6b9 100644
--- 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzer.java
+++ 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzer.java
@@ -807,6 +807,10 @@ public class LoadTsFileAnalyzer implements AutoCloseable {
       return;
     }
 
+    executeTabletConversion(analysis);
+  }
+
+  private void executeTabletConversion(final IAnalysis analysis) {
     if (isTableModelTsFileReliableIndex < tsFiles.size() - 1) {
       try {
         getFileModelInfoBeforeTabletConversion();
diff --git 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileTableSchemaCache.java
 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileTableSchemaCache.java
index bfe316d8f18..69ca1f2bf13 100644
--- 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileTableSchemaCache.java
+++ 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileTableSchemaCache.java
@@ -58,6 +58,7 @@ import 
org.apache.iotdb.db.utils.datastructure.PatternTreeMapFactory;
 import org.apache.iotdb.rpc.TSStatusCode;
 
 import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.tsfile.enums.TSDataType;
 import org.apache.tsfile.file.metadata.IDeviceID;
 import org.apache.tsfile.read.TsFileSequenceReader;
 import org.apache.tsfile.utils.Pair;
@@ -504,19 +505,25 @@ public class LoadTsFileTableSchemaCache {
       } else if (fileColumn.getColumnCategory() == 
TsTableColumnCategory.FIELD) {
         ColumnSchema realColumn = 
fieldColumnNameToSchema.get(fileColumn.getName());
         if (realColumn != null && 
!fileColumn.getType().equals(realColumn.getType())) {
-          final String message =
-              String.format(
-                  DataNodeQueryMessages
-                      
.MESSAGE_DATA_TYPE_MISMATCH_FOR_COLUMN_ARG_IN_TABLE_ARG_TYPE_IN_TSFILE_ARG_TYPE_IN_IOTDB_ARG_ECAD0C63,
-                  fileColumn.getName(),
-                  realSchema.getTableName(),
-                  fileColumn.getType(),
-                  realColumn.getType());
-          if (shouldVerifyDataType) {
-            throw new LoadAnalyzeTypeMismatchException(message);
-          }
-          if (LOGGER.isDebugEnabled()) {
-            LOGGER.debug(message);
+          final TSDataType realDataType =
+              TSDataType.valueOf(realColumn.getType().getTypeEnum().name());
+          final TSDataType fileDataType =
+              TSDataType.valueOf(fileColumn.getType().getTypeEnum().name());
+          if (!realDataType.isCompatible(fileDataType)) {
+            final String message =
+                String.format(
+                    DataNodeQueryMessages
+                        
.MESSAGE_DATA_TYPE_MISMATCH_FOR_COLUMN_ARG_IN_TABLE_ARG_TYPE_IN_TSFILE_ARG_TYPE_IN_IOTDB_ARG_ECAD0C63,
+                    fileColumn.getName(),
+                    realSchema.getTableName(),
+                    fileColumn.getType(),
+                    realColumn.getType());
+            if (shouldVerifyDataType) {
+              throw new LoadAnalyzeTypeMismatchException(message);
+            }
+            if (LOGGER.isDebugEnabled()) {
+              LOGGER.debug(message);
+            }
           }
         } else if (LOGGER.isDebugEnabled() && realColumn == null) {
           LOGGER.debug(
diff --git 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/TreeSchemaAutoCreatorAndVerifier.java
 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/TreeSchemaAutoCreatorAndVerifier.java
index d27da400dfa..9ba07e23be8 100644
--- 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/TreeSchemaAutoCreatorAndVerifier.java
+++ 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/load/TreeSchemaAutoCreatorAndVerifier.java
@@ -605,15 +605,17 @@ public class TreeSchemaAutoCreatorAndVerifier {
 
         // check datatype
         if (!tsFileSchema.getType().equals(iotdbSchema.getType())) {
-          throw new LoadAnalyzeTypeMismatchException(
-              String.format(
-                  DataNodeQueryMessages
-                      
.EXCEPTION_DATA_TYPE_MISMATCH_FOR_MEASUREMENT_ARGARGARG_TYPE_IN_TSFILE_ARG_TYPE_IN_IOTDB_ARG_C5BA7DBD,
-                  device,
-                  TsFileConstant.PATH_SEPARATOR,
-                  iotdbSchema.getMeasurementName(),
-                  tsFileSchema.getType(),
-                  iotdbSchema.getType()));
+          if (!iotdbSchema.getType().isCompatible(tsFileSchema.getType())) {
+            throw new LoadAnalyzeTypeMismatchException(
+                String.format(
+                    DataNodeQueryMessages
+                        
.EXCEPTION_DATA_TYPE_MISMATCH_FOR_MEASUREMENT_ARGARGARG_TYPE_IN_TSFILE_ARG_TYPE_IN_IOTDB_ARG_C5BA7DBD,
+                    device,
+                    TsFileConstant.PATH_SEPARATOR,
+                    iotdbSchema.getMeasurementName(),
+                    tsFileSchema.getType(),
+                    iotdbSchema.getType()));
+          }
         }
 
         // check encoding
diff --git 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/converter/LoadConvertedInsertTabletStatement.java
 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/converter/LoadConvertedInsertTabletStatement.java
index 3edf9e150b8..a5abc3ccc98 100644
--- 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/converter/LoadConvertedInsertTabletStatement.java
+++ 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/converter/LoadConvertedInsertTabletStatement.java
@@ -53,6 +53,10 @@ public class LoadConvertedInsertTabletStatement extends 
PipeConvertedInsertTable
       return false;
     }
 
+    if (dataType.isCompatible(dataTypes[columnIndex])) {
+      return originalCheckAndCastDataType(columnIndex, dataType);
+    }
+
     LOGGER.info(
         
StorageEngineMessages.STORAGE_LOG_LOAD_INSERTING_TABLET_TO_CASTING_TYPE_FROM_TO_AE808A8B,
         devicePath,
diff --git 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/receiver/transform/statement/PipeConvertedInsertTabletStatementTest.java
 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/receiver/transform/statement/PipeConvertedInsertTabletStatementTest.java
index a6bd537bee4..05432fee358 100644
--- 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/receiver/transform/statement/PipeConvertedInsertTabletStatementTest.java
+++ 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/receiver/transform/statement/PipeConvertedInsertTabletStatementTest.java
@@ -113,6 +113,38 @@ public class PipeConvertedInsertTabletStatementTest {
     Assert.assertArrayEquals(new double[] {1.0, 2.0}, (double[]) 
tablet.getValues()[0], 0.0);
   }
 
+  @Test
+  public void testLoadCompatibleTypeUsesInsertTabletCasting() throws Exception 
{
+    final InsertTabletStatement source = new InsertTabletStatement();
+    source.setDevicePath(new PartialPath("root.sg.d1"));
+    source.setMeasurements(new String[] {"s1"});
+    source.setDataTypes(new TSDataType[] {TSDataType.INT32});
+    source.setMeasurementSchemas(
+        new MeasurementSchema[] {new MeasurementSchema("s1", 
TSDataType.INT64)});
+    source.setTimes(new long[] {1L, 2L});
+    source.setColumns(new Object[] {new int[] {Integer.MIN_VALUE, 
Integer.MAX_VALUE}});
+    source.setRowCount(2);
+
+    final InsertTabletStatement ordinaryInsert = new InsertTabletStatement();
+    ordinaryInsert.setDevicePath(new PartialPath("root.sg.d1"));
+    ordinaryInsert.setMeasurements(new String[] {"s1"});
+    ordinaryInsert.setDataTypes(new TSDataType[] {TSDataType.INT32});
+    ordinaryInsert.setMeasurementSchemas(
+        new MeasurementSchema[] {new MeasurementSchema("s1", 
TSDataType.INT64)});
+    ordinaryInsert.setTimes(new long[] {1L, 2L});
+    ordinaryInsert.setColumns(new Object[] {new int[] {Integer.MIN_VALUE, 
Integer.MAX_VALUE}});
+    ordinaryInsert.setRowCount(2);
+    ordinaryInsert.selfCheckDataTypes(0);
+
+    final LoadConvertedInsertTabletStatement loadInsert =
+        new LoadConvertedInsertTabletStatement(source, true);
+    loadInsert.selfCheckDataTypes(0);
+
+    Assert.assertEquals(TSDataType.INT64, loadInsert.getDataTypes()[0]);
+    Assert.assertArrayEquals(
+        (long[]) ordinaryInsert.getColumns()[0], (long[]) 
loadInsert.getColumns()[0]);
+  }
+
   private static InsertTabletStatement 
createPartiallyFailedStatementWithMissingColumn()
       throws Exception {
     final InsertTabletStatement source = new InsertTabletStatement();
diff --git 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzerTest.java
 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzerTest.java
index 9ef5f7b7f62..dcdf4f269bc 100644
--- 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzerTest.java
+++ 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/analyze/load/LoadTsFileAnalyzerTest.java
@@ -487,8 +487,8 @@ public class LoadTsFileAnalyzerTest {
                   getVerifyTableDataTypeMethod()
                       .invoke(
                           schemaCache,
-                          createTableSchema(TSDataType.INT64),
-                          createTableSchema(TSDataType.DOUBLE)));
+                          createTableSchema(TSDataType.INT32),
+                          createTableSchema(TSDataType.BOOLEAN)));
 
       Assert.assertTrue(exception.getCause() instanceof 
LoadAnalyzeTypeMismatchException);
     } finally {
@@ -496,6 +496,20 @@ public class LoadTsFileAnalyzerTest {
     }
   }
 
+  @Test
+  public void testTableSchemaCacheAllowsCompatibleDataType() throws Exception {
+    final LoadTsFileTableSchemaCache schemaCache = 
createTableSchemaCache(true);
+    try {
+      getVerifyTableDataTypeMethod()
+          .invoke(
+              schemaCache,
+              createTableSchema(TSDataType.INT32),
+              createTableSchema(TSDataType.INT64));
+    } finally {
+      schemaCache.close();
+    }
+  }
+
   @Test
   public void 
testTableSchemaCacheShouldNotThrowMismatchWhenSkippingDataTypeVerification()
       throws Exception {
@@ -504,8 +518,8 @@ public class LoadTsFileAnalyzerTest {
       getVerifyTableDataTypeMethod()
           .invoke(
               schemaCache,
-              createTableSchema(TSDataType.INT64),
-              createTableSchema(TSDataType.DOUBLE));
+              createTableSchema(TSDataType.INT32),
+              createTableSchema(TSDataType.BOOLEAN));
     } finally {
       schemaCache.close();
     }
@@ -556,6 +570,41 @@ public class LoadTsFileAnalyzerTest {
     }
   }
 
+  @Test
+  public void testTreeSchemaVerifierAllowsCompatibleDataType() throws 
Exception {
+    final File tsFile = File.createTempFile("load-tree-compatible-type", 
".tsfile");
+
+    try (final LoadTsFileAnalyzer analyzer =
+        new LoadTsFileAnalyzer(
+            LoadTsFileStatement.createUnchecked(tsFile.getAbsolutePath()),
+            false,
+            new MPPQueryContext(new 
QueryId("load_tree_compatible_type_test")))) {
+      final TreeSchemaAutoCreatorAndVerifier verifier =
+          new TreeSchemaAutoCreatorAndVerifier(analyzer);
+      try {
+        final IDeviceID device = 
IDeviceID.Factory.DEFAULT_FACTORY.create("root.sg.d1");
+        getTreeSchemaCache(verifier)
+            .addTimeSeries(device, new MeasurementSchema("s1", 
TSDataType.INT32));
+        getTreeSchemaCache(verifier).addIsAlignedCache(device, true, true);
+
+        final ClusterSchemaTree schemaTree = new ClusterSchemaTree();
+        schemaTree.appendSingleMeasurement(
+            new PartialPath("root.sg.d1.s1"),
+            new MeasurementSchema("s1", TSDataType.INT64),
+            null,
+            null,
+            null,
+            true);
+
+        getVerifyTreeSchemaMethod().invoke(verifier, schemaTree);
+      } finally {
+        verifier.close();
+      }
+    } finally {
+      Assert.assertTrue(tsFile.delete());
+    }
+  }
+
   @Test
   public void testTreeSchemaVerifierShouldRejectDeviceWithEmptyPathNode() 
throws Exception {
     final File tsFile = File.createTempFile("load-tree-illegal-device", 
".tsfile");

Reply via email to