This is an automated email from the ASF dual-hosted git repository.
JackieTien97 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 554ac2620ad Fixed the pre-Alter in table display logic && The
compatible type written in CN for alter column type && Sequence of limit &
offset in tree model show-devices (#17558)
554ac2620ad is described below
commit 554ac2620ad22594f977b3a49e9dfcb172c384e4
Author: Caideyipi <[email protected]>
AuthorDate: Tue Apr 28 13:19:28 2026 +0800
Fixed the pre-Alter in table display logic && The compatible type written
in CN for alter column type && Sequence of limit & offset in tree model
show-devices (#17558)
---
.../confignode/persistence/schema/ConfigMTree.java | 24 +++++++-
.../persistence/schema/ConfigMTreeTest.java | 47 ++++++++++++++++
.../InformationSchemaContentSupplierFactory.java | 64 +++++++++++++++++-----
.../relational/DescribeTableDetailsTask.java | 15 +++--
.../plan/planner/LogicalPlanVisitor.java | 4 +-
.../table/TableColumnMetadataUtil.java | 62 +++++++++++++++++++++
.../logical/RegionScanLogicalPlannerTest.java | 8 +--
.../logical/SchemaQueryLogicalPlannerTest.java | 17 ++++++
.../table/TableColumnMetadataUtilTest.java | 60 ++++++++++++++++++++
9 files changed, 269 insertions(+), 32 deletions(-)
diff --git
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/persistence/schema/ConfigMTree.java
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/persistence/schema/ConfigMTree.java
index 5ec58655249..c39c5fe3ff9 100644
---
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/persistence/schema/ConfigMTree.java
+++
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/persistence/schema/ConfigMTree.java
@@ -36,6 +36,7 @@ import
org.apache.iotdb.commons.schema.node.utils.IMNodeIterator;
import org.apache.iotdb.commons.schema.table.TableNodeStatus;
import org.apache.iotdb.commons.schema.table.TreeViewSchema;
import org.apache.iotdb.commons.schema.table.TsTable;
+import org.apache.iotdb.commons.schema.table.column.FieldColumnSchema;
import org.apache.iotdb.commons.schema.table.column.TsTableColumnCategory;
import org.apache.iotdb.commons.schema.table.column.TsTableColumnSchema;
import org.apache.iotdb.commons.utils.MetadataUtils;
@@ -55,6 +56,7 @@ import
org.apache.iotdb.db.schemaengine.schemaregion.mtree.traverser.collector.M
import
org.apache.iotdb.db.schemaengine.schemaregion.mtree.traverser.collector.MNodeCollector;
import
org.apache.iotdb.db.schemaengine.schemaregion.mtree.traverser.counter.DatabaseCounter;
import org.apache.iotdb.db.schemaengine.schemaregion.utils.MetaFormatUtils;
+import org.apache.iotdb.db.utils.SchemaUtils;
import org.apache.iotdb.rpc.TSStatusCode;
import org.apache.tsfile.enums.TSDataType;
@@ -1016,8 +1018,14 @@ public class ConfigMTree {
throws MetadataException {
final ConfigTableNode node = getTableNode(database, tableName);
final TsTable table = getTable(database, tableName);
- if (Objects.nonNull(table.getColumnSchema(columnName))) {
- table.getColumnSchema(columnName).setDataType(dataType);
+ final TsTableColumnSchema columnSchema = table.getColumnSchema(columnName);
+ if (Objects.nonNull(columnSchema)) {
+ columnSchema.setDataType(dataType);
+ if (columnSchema instanceof FieldColumnSchema) {
+ final FieldColumnSchema fieldColumnSchema = (FieldColumnSchema)
columnSchema;
+ fieldColumnSchema.setEncoding(
+ SchemaUtils.getDataTypeCompatibleEncoding(dataType,
fieldColumnSchema.getEncoding()));
+ }
node.removePreAlteredColumn(columnName);
}
}
@@ -1034,7 +1042,17 @@ public class ConfigMTree {
}
if (!node.getPreAlteredColumns().isEmpty()) {
node.getPreAlteredColumns()
- .forEach((col, type) ->
newTable.getColumnSchema(col).setDataType(type));
+ .forEach(
+ (col, type) -> {
+ final TsTableColumnSchema columnSchema =
newTable.getColumnSchema(col);
+ columnSchema.setDataType(type);
+ if (columnSchema instanceof FieldColumnSchema) {
+ final FieldColumnSchema fieldColumnSchema =
(FieldColumnSchema) columnSchema;
+ fieldColumnSchema.setEncoding(
+ SchemaUtils.getDataTypeCompatibleEncoding(
+ type, fieldColumnSchema.getEncoding()));
+ }
+ });
}
return newTable;
}
diff --git
a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/persistence/schema/ConfigMTreeTest.java
b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/persistence/schema/ConfigMTreeTest.java
index 6f2df1e129a..f4dbd9a3972 100644
---
a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/persistence/schema/ConfigMTreeTest.java
+++
b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/persistence/schema/ConfigMTreeTest.java
@@ -31,6 +31,7 @@ import
org.apache.iotdb.commons.schema.table.column.TagColumnSchema;
import org.apache.iotdb.commons.utils.PathUtils;
import org.apache.iotdb.confignode.persistence.schema.mnode.IConfigMNode;
import org.apache.iotdb.confignode.rpc.thrift.TDatabaseSchema;
+import org.apache.iotdb.db.utils.SchemaUtils;
import org.apache.tsfile.enums.TSDataType;
import org.apache.tsfile.file.metadata.enums.CompressionType;
@@ -406,6 +407,52 @@ public class ConfigMTreeTest {
}
}
+ @Test
+ public void testAlterColumnTypeUpdatesCompatibleEncoding() throws Exception {
+ root = new ConfigMTree(true);
+
+ final PartialPath database = new PartialPath("root.sg");
+ root.setStorageGroup(database);
+ final IDatabaseMNode<IConfigMNode> databaseNode =
root.getDatabaseNodeByDatabasePath(database);
+ databaseNode
+ .getAsMNode()
+ .getDatabaseSchema()
+ .setName(PathUtils.unQualifyDatabaseName(database.getFullPath()));
+ databaseNode.getAsMNode().getDatabaseSchema().setIsTableModel(true);
+
+ final TsTable table = new TsTable("table1");
+ table.addColumnSchema(new TagColumnSchema("id", TSDataType.STRING));
+ table.addColumnSchema(
+ new FieldColumnSchema(
+ "measurement", TSDataType.DOUBLE, TSEncoding.GORILLA,
CompressionType.SNAPPY));
+ root.preCreateTable(database, table);
+ root.commitCreateTable(database, table.getTableName());
+
+ root.preAlterColumnDataType(database, table.getTableName(), "measurement",
TSDataType.STRING);
+
+ final TSEncoding expectedEncoding =
+ SchemaUtils.getDataTypeCompatibleEncoding(TSDataType.STRING,
TSEncoding.GORILLA);
+ Assert.assertNotEquals(TSEncoding.GORILLA, expectedEncoding);
+
+ final TsTable preAlteredTable = root.getUsingTableSchema(database,
table.getTableName());
+ final FieldColumnSchema preAlteredField =
+ (FieldColumnSchema) preAlteredTable.getColumnSchema("measurement");
+ Assert.assertEquals(TSDataType.STRING, preAlteredField.getDataType());
+ Assert.assertEquals(expectedEncoding, preAlteredField.getEncoding());
+
+ root.commitAlterColumnDataType(
+ database, table.getTableName(), "measurement", TSDataType.STRING);
+
+ final TsTable committedTable = root.getUsingTableSchema(database,
table.getTableName());
+ final FieldColumnSchema committedField =
+ (FieldColumnSchema) committedTable.getColumnSchema("measurement");
+ Assert.assertEquals(TSDataType.STRING, committedField.getDataType());
+ Assert.assertEquals(expectedEncoding, committedField.getEncoding());
+
+ Assert.assertTrue(
+ root.getTableSchemaDetails(database,
table.getTableName()).preAlteredColumns.isEmpty());
+ }
+
@Test
public void testSetTemplate() throws MetadataException {
root.setStorageGroup(new PartialPath("root.a"));
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/InformationSchemaContentSupplierFactory.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/InformationSchemaContentSupplierFactory.java
index a1ea9c9dbb8..9c31a23251b 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/InformationSchemaContentSupplierFactory.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/InformationSchemaContentSupplierFactory.java
@@ -90,6 +90,7 @@ import
org.apache.iotdb.db.queryengine.plan.relational.planner.node.TableDiskUsa
import org.apache.iotdb.db.queryengine.plan.relational.security.AccessControl;
import org.apache.iotdb.db.relational.grammar.sql.RelationalSqlKeywords;
import org.apache.iotdb.db.schemaengine.table.InformationSchemaUtils;
+import org.apache.iotdb.db.schemaengine.table.TableColumnMetadataUtil;
import org.apache.iotdb.db.storageengine.dataregion.DataRegion;
import
org.apache.iotdb.db.storageengine.dataregion.utils.StorageEngineTimePartitionIterator;
import
org.apache.iotdb.db.storageengine.dataregion.utils.tableDiskUsageIndex.DataRegionTableSizeQueryContext;
@@ -463,12 +464,13 @@ public class InformationSchemaContentSupplierFactory {
}
private static class ColumnSupplier extends TsBlockSupplier {
- private final Iterator<Map.Entry<String, Map<String, Pair<TsTable,
Set<String>>>>> dbIterator;
- private Iterator<Map.Entry<String, Pair<TsTable, Set<String>>>>
tableInfoIterator;
+ private final Iterator<Map.Entry<String, Map<String,
TableColumnDetailInfo>>> dbIterator;
+ private Iterator<Map.Entry<String, TableColumnDetailInfo>>
tableInfoIterator;
private Iterator<TsTableColumnSchema> columnSchemaIterator;
private String dbName;
private String tableName;
private Set<String> preDeletedColumns;
+ private Map<String, Byte> preAlteredColumns;
private final UserEntity userEntity;
private ColumnSupplier(final List<TSDataType> dataTypes, final UserEntity
userEntity)
@@ -477,9 +479,8 @@ public class InformationSchemaContentSupplierFactory {
this.userEntity = userEntity;
try (final ConfigNodeClient client =
ConfigNodeClientManager.getInstance().borrowClient(ConfigNodeInfo.CONFIG_REGION_ID))
{
- final TDescTable4InformationSchemaResp resp =
client.descTables4InformationSchema();
- final Map<String, Map<String, Pair<TsTable, Set<String>>>> resultMap =
- resp.getTableColumnInfoMap().entrySet().stream()
+ final Map<String, Map<String, TableColumnDetailInfo>> resultMap =
+
client.descTables4InformationSchema().getTableColumnInfoMap().entrySet().stream()
.collect(
Collectors.toMap(
Map.Entry::getKey,
@@ -489,17 +490,20 @@ public class InformationSchemaContentSupplierFactory {
Collectors.toMap(
Map.Entry::getKey,
tableEntry ->
- new Pair<>(
+ new TableColumnDetailInfo(
TsTableInternalRPCUtil.deserializeSingleTsTable(
tableEntry.getValue().getTableInfo()),
-
tableEntry.getValue().getPreDeletedColumns())))));
+
tableEntry.getValue().getPreDeletedColumns(),
+
tableEntry.getValue().getPreAlteredColumns())))));
resultMap.put(
InformationSchema.INFORMATION_DATABASE,
InformationSchema.getSchemaTables().values().stream()
.collect(
Collectors.toMap(
TsTable::getTableName,
- table -> new Pair<>(table, Collections.emptySet()))));
+ table ->
+ new TableColumnDetailInfo(
+ table, Collections.emptySet(),
Collections.emptyMap()))));
dbIterator = resultMap.entrySet().iterator();
}
}
@@ -512,12 +516,15 @@ public class InformationSchemaContentSupplierFactory {
columnBuilders[2].writeBinary(
new Binary(schema.getColumnName(), TSFileConfig.STRING_CHARSET));
columnBuilders[3].writeBinary(
- new Binary(schema.getDataType().name(),
TSFileConfig.STRING_CHARSET));
+ new Binary(
+ TableColumnMetadataUtil.getColumnDataTypeName(schema,
preAlteredColumns),
+ TSFileConfig.STRING_CHARSET));
columnBuilders[4].writeBinary(
new Binary(schema.getColumnCategory().name(),
TSFileConfig.STRING_CHARSET));
columnBuilders[5].writeBinary(
new Binary(
- preDeletedColumns.contains(schema.getColumnName()) ?
"PRE_DELETE" : "USING",
+ TableColumnMetadataUtil.getColumnStatus(
+ schema.getColumnName(), preDeletedColumns,
preAlteredColumns),
TSFileConfig.STRING_CHARSET));
if (schema.getProps().containsKey(TsTable.COMMENT_KEY)) {
@@ -536,8 +543,7 @@ public class InformationSchemaContentSupplierFactory {
if (!dbIterator.hasNext()) {
return false;
}
- final Map.Entry<String, Map<String, Pair<TsTable, Set<String>>>>
entry =
- dbIterator.next();
+ final Map.Entry<String, Map<String, TableColumnDetailInfo>> entry =
dbIterator.next();
dbName = entry.getKey();
if (!canShowDB(accessControl, userEntity.getUsername(), dbName,
userEntity)) {
continue;
@@ -545,14 +551,15 @@ public class InformationSchemaContentSupplierFactory {
tableInfoIterator = entry.getValue().entrySet().iterator();
}
- Map.Entry<String, Pair<TsTable, Set<String>>> tableEntry;
+ Map.Entry<String, TableColumnDetailInfo> tableEntry;
while (tableInfoIterator.hasNext()) {
tableEntry = tableInfoIterator.next();
if (canShowTable(
accessControl, userEntity.getUsername(), dbName,
tableEntry.getKey(), userEntity)) {
tableName = tableEntry.getKey();
- preDeletedColumns = tableEntry.getValue().getRight();
- columnSchemaIterator =
tableEntry.getValue().getLeft().getColumnList().iterator();
+ preDeletedColumns = tableEntry.getValue().getPreDeletedColumns();
+ preAlteredColumns = tableEntry.getValue().getPreAlteredColumns();
+ columnSchemaIterator =
tableEntry.getValue().getTable().getColumnList().iterator();
break;
}
}
@@ -561,6 +568,33 @@ public class InformationSchemaContentSupplierFactory {
}
}
+ private static class TableColumnDetailInfo {
+ private final TsTable table;
+ private final Set<String> preDeletedColumns;
+ private final Map<String, Byte> preAlteredColumns;
+
+ private TableColumnDetailInfo(
+ final TsTable table,
+ final Set<String> preDeletedColumns,
+ final Map<String, Byte> preAlteredColumns) {
+ this.table = table;
+ this.preDeletedColumns = preDeletedColumns;
+ this.preAlteredColumns = preAlteredColumns;
+ }
+
+ private TsTable getTable() {
+ return table;
+ }
+
+ private Set<String> getPreDeletedColumns() {
+ return preDeletedColumns;
+ }
+
+ private Map<String, Byte> getPreAlteredColumns() {
+ return preAlteredColumns;
+ }
+ }
+
private static class RegionSupplier extends TsBlockSupplier {
private final Iterator<TRegionInfo> iterator;
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/metadata/relational/DescribeTableDetailsTask.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/metadata/relational/DescribeTableDetailsTask.java
index ac2fe718850..79e9a016d5b 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/metadata/relational/DescribeTableDetailsTask.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/metadata/relational/DescribeTableDetailsTask.java
@@ -27,6 +27,7 @@ import
org.apache.iotdb.db.queryengine.common.header.DatasetHeader;
import org.apache.iotdb.db.queryengine.common.header.DatasetHeaderFactory;
import org.apache.iotdb.db.queryengine.plan.execution.config.ConfigTaskResult;
import
org.apache.iotdb.db.queryengine.plan.execution.config.executor.IConfigTaskExecutor;
+import org.apache.iotdb.db.schemaengine.table.TableColumnMetadataUtil;
import org.apache.iotdb.rpc.TSStatusCode;
import com.google.common.util.concurrent.ListenableFuture;
@@ -65,14 +66,12 @@ public class DescribeTableDetailsTask extends
AbstractTableTask {
final TsBlockBuilder builder = new TsBlockBuilder(outputDataTypes);
for (final TsTableColumnSchema columnSchema : table.getColumnList()) {
builder.getTimeColumnBuilder().writeLong(0L);
- String columnStatus = "USING";
- String dataTypeName = columnSchema.getDataType().name();
- if (preDeletedColumns.contains(columnSchema.getColumnName())) {
- columnStatus = "PRE_DELETE";
- }
- builder
- .getColumnBuilder(0)
- .writeBinary(new Binary(columnSchema.getColumnName(),
TSFileConfig.STRING_CHARSET));
+ final String columnName = columnSchema.getColumnName();
+ final String columnStatus =
+ TableColumnMetadataUtil.getColumnStatus(columnName,
preDeletedColumns, preAlteredColumns);
+ final String dataTypeName =
+ TableColumnMetadataUtil.getColumnDataTypeName(columnSchema,
preAlteredColumns);
+ builder.getColumnBuilder(0).writeBinary(new Binary(columnName,
TSFileConfig.STRING_CHARSET));
builder
.getColumnBuilder(1)
.writeBinary(new Binary(dataTypeName, TSFileConfig.STRING_CHARSET));
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanVisitor.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanVisitor.java
index 35011051839..a9b0b9d83f4 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanVisitor.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LogicalPlanVisitor.java
@@ -658,8 +658,8 @@ public class LogicalPlanVisitor extends
StatementVisitor<PlanNode, MPPQueryConte
planBuilder =
planBuilder
.planDeviceRegionScan(analysis.getDevicePathToContextMap(),
false)
- .planLimit(showDevicesStatement.getLimit())
- .planOffset(showDevicesStatement.getOffset());
+ .planOffset(showDevicesStatement.getOffset())
+ .planLimit(showDevicesStatement.getLimit());
return planBuilder.getRoot();
}
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/table/TableColumnMetadataUtil.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/table/TableColumnMetadataUtil.java
new file mode 100644
index 00000000000..268564056b1
--- /dev/null
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/table/TableColumnMetadataUtil.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.iotdb.db.schemaengine.table;
+
+import org.apache.iotdb.commons.schema.table.column.TsTableColumnSchema;
+
+import org.apache.tsfile.enums.TSDataType;
+
+import java.util.Map;
+import java.util.Set;
+
+public final class TableColumnMetadataUtil {
+
+ public static final String USING_STATUS = "USING";
+ public static final String PRE_DELETE_STATUS = "PRE_DELETE";
+ public static final String PRE_ALTER_STATUS = "PRE_ALTER";
+
+ private TableColumnMetadataUtil() {
+ // Utility class
+ }
+
+ public static String getColumnStatus(
+ final String columnName,
+ final Set<String> preDeletedColumns,
+ final Map<String, ?> preAlteredColumns) {
+ if (preDeletedColumns != null && preDeletedColumns.contains(columnName)) {
+ return PRE_DELETE_STATUS;
+ }
+ if (preAlteredColumns != null &&
preAlteredColumns.containsKey(columnName)) {
+ return PRE_ALTER_STATUS;
+ }
+ return USING_STATUS;
+ }
+
+ public static String getColumnDataTypeName(
+ final TsTableColumnSchema columnSchema, final Map<String, Byte>
preAlteredColumns) {
+ if (preAlteredColumns != null) {
+ final Byte serializedType =
preAlteredColumns.get(columnSchema.getColumnName());
+ if (serializedType != null) {
+ return TSDataType.deserialize(serializedType).name();
+ }
+ }
+ return columnSchema.getDataType().name();
+ }
+}
diff --git
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/RegionScanLogicalPlannerTest.java
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/RegionScanLogicalPlannerTest.java
index b7accedfd29..dd3b8b6281e 100644
---
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/RegionScanLogicalPlannerTest.java
+++
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/RegionScanLogicalPlannerTest.java
@@ -216,13 +216,13 @@ public class RegionScanLogicalPlannerTest {
DeviceRegionScanNode regionScanNode =
new DeviceRegionScanNode(queryId.genPlanNodeId(), deviceContextMap,
false, null);
- LimitNode limitNode = new LimitNode(queryId.genPlanNodeId(), 20);
- limitNode.addChild(regionScanNode);
OffsetNode offsetNode = new OffsetNode(queryId.genPlanNodeId(), 10);
- offsetNode.addChild(limitNode);
+ offsetNode.addChild(regionScanNode);
+ LimitNode limitNode = new LimitNode(queryId.genPlanNodeId(), 20);
+ limitNode.addChild(offsetNode);
PlanNode actualPlan = parseSQLToPlanNode(sql);
- Assert.assertEquals(actualPlan, offsetNode);
+ Assert.assertEquals(actualPlan, limitNode);
}
@Test
diff --git
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/SchemaQueryLogicalPlannerTest.java
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/SchemaQueryLogicalPlannerTest.java
index e3448929a12..945bad7f6ee 100644
---
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/SchemaQueryLogicalPlannerTest.java
+++
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/planner/logical/SchemaQueryLogicalPlannerTest.java
@@ -47,6 +47,7 @@ import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.GroupByTag
import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.LimitNode;
import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.OffsetNode;
import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.RawDataAggregationNode;
+import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.source.DeviceRegionScanNode;
import
org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.AggregationStep;
import
org.apache.iotdb.db.queryengine.plan.planner.plan.parameter.CrossSeriesAggregationDescriptor;
import org.apache.iotdb.db.queryengine.plan.statement.component.Ordering;
@@ -644,6 +645,22 @@ public class SchemaQueryLogicalPlannerTest {
}
}
+ @Test
+ public void testShowDevicesWithTimeConditionPaginationOrder() {
+ String sql = "SHOW DEVICES root.ln.wf01.wt01 WHERE time >= 10 limit 20
offset 10";
+ try {
+ LimitNode limitNode = (LimitNode) parseSQLToPlanNode(sql);
+ Assert.assertEquals(20, limitNode.getLimit());
+
+ OffsetNode offsetNode = (OffsetNode) limitNode.getChild();
+ Assert.assertEquals(10, offsetNode.getOffset());
+ Assert.assertTrue(offsetNode.getChild() instanceof DeviceRegionScanNode);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail();
+ }
+ }
+
@Test
public void testCountNodes() {
String sql = "COUNT NODES root.ln LEVEL=1";
diff --git
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/schemaengine/table/TableColumnMetadataUtilTest.java
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/schemaengine/table/TableColumnMetadataUtilTest.java
new file mode 100644
index 00000000000..879c3cdc94e
--- /dev/null
+++
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/schemaengine/table/TableColumnMetadataUtilTest.java
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.iotdb.db.schemaengine.table;
+
+import org.apache.iotdb.commons.schema.table.column.FieldColumnSchema;
+
+import org.apache.tsfile.enums.TSDataType;
+import org.junit.Test;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+
+public class TableColumnMetadataUtilTest {
+
+ @Test
+ public void testPreAlteredColumnUsesPendingTypeAndStatus() {
+ final FieldColumnSchema columnSchema = new FieldColumnSchema("s1",
TSDataType.INT32);
+ final Map<String, Byte> preAlteredColumns = new HashMap<>();
+ preAlteredColumns.put("s1", TSDataType.INT64.serialize());
+
+ assertEquals(
+ TableColumnMetadataUtil.PRE_ALTER_STATUS,
+ TableColumnMetadataUtil.getColumnStatus("s1", Collections.emptySet(),
preAlteredColumns));
+ assertEquals(
+ TSDataType.INT64.name(),
+ TableColumnMetadataUtil.getColumnDataTypeName(columnSchema,
preAlteredColumns));
+ }
+
+ @Test
+ public void testPreDeleteStatusTakesPriority() {
+ final Set<String> preDeletedColumns = Collections.singleton("s1");
+ final Map<String, Byte> preAlteredColumns = new HashMap<>();
+ preAlteredColumns.put("s1", TSDataType.FLOAT.serialize());
+
+ assertEquals(
+ TableColumnMetadataUtil.PRE_DELETE_STATUS,
+ TableColumnMetadataUtil.getColumnStatus("s1", preDeletedColumns,
preAlteredColumns));
+ }
+}
