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");