You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by ja...@apache.org on 2023/03/24 00:53:42 UTC

[iotdb] branch rel/1.1 updated: [To rel/1.1] [IOTDB-5722] Fix wrong default execution branch in PlanVisitor (#9437)

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

jackietien pushed a commit to branch rel/1.1
in repository https://gitbox.apache.org/repos/asf/iotdb.git


The following commit(s) were added to refs/heads/rel/1.1 by this push:
     new fbf2ecc5e9 [To rel/1.1] [IOTDB-5722] Fix wrong default execution branch in PlanVisitor (#9437)
fbf2ecc5e9 is described below

commit fbf2ecc5e9438209278c2ae30d6341684a71cb2f
Author: liuminghui233 <36...@users.noreply.github.com>
AuthorDate: Fri Mar 24 08:53:35 2023 +0800

    [To rel/1.1] [IOTDB-5722] Fix wrong default execution branch in PlanVisitor (#9437)
---
 .../db/it/alignbydevice/IoTDBAlignByDeviceIT.java  | 108 ++++++++++++
 .../db/mpp/plan/planner/plan/node/PlanVisitor.java | 188 ++++++++++++---------
 2 files changed, 212 insertions(+), 84 deletions(-)

diff --git a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceIT.java b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceIT.java
index e9fa955cf9..90ad82e5a2 100644
--- a/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceIT.java
+++ b/integration-test/src/test/java/org/apache/iotdb/db/it/alignbydevice/IoTDBAlignByDeviceIT.java
@@ -192,6 +192,114 @@ public class IoTDBAlignByDeviceIT {
     }
   }
 
+  @Test
+  public void selectTestWithLimitOffset1() {
+    String[] retArray =
+        new String[] {
+          "1,root.vehicle.d1,999,null,null,null,null,",
+          "2,root.vehicle.d0,10000,40000,2.22,null,null,",
+          "3,root.vehicle.d0,null,null,3.33,null,null,",
+          "4,root.vehicle.d0,null,null,4.44,null,null,",
+          "50,root.vehicle.d0,10000,50000,null,null,null,"
+        };
+
+    try (Connection connection = EnvFactory.getEnv().getConnection();
+        Statement statement = connection.createStatement()) {
+
+      try (ResultSet resultSet =
+          statement.executeQuery(
+              "select * from root.vehicle.** order by time asc limit 5 offset 1 align by device")) {
+        ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+        List<Integer> actualIndexToExpectedIndexList =
+            checkHeader(
+                resultSetMetaData,
+                "Time,Device,s0,s1,s2,s3,s4",
+                new int[] {
+                  Types.TIMESTAMP,
+                  Types.VARCHAR,
+                  Types.INTEGER,
+                  Types.BIGINT,
+                  Types.FLOAT,
+                  Types.VARCHAR,
+                  Types.BOOLEAN
+                });
+
+        int cnt = 0;
+        while (resultSet.next()) {
+          String[] expectedStrings = retArray[cnt].split(",");
+          StringBuilder expectedBuilder = new StringBuilder();
+          StringBuilder actualBuilder = new StringBuilder();
+          for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+            actualBuilder.append(resultSet.getString(i)).append(",");
+            expectedBuilder
+                .append(expectedStrings[actualIndexToExpectedIndexList.get(i - 1)])
+                .append(",");
+          }
+          Assert.assertEquals(expectedBuilder.toString(), actualBuilder.toString());
+          cnt++;
+        }
+        Assert.assertEquals(retArray.length, cnt);
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+      fail(e.getMessage());
+    }
+  }
+
+  @Test
+  public void selectTestWithLimitOffset2() {
+    String[] retArray =
+        new String[] {
+          "1,root.vehicle.d1,999,null,null,null,null,",
+          "946684800000,root.vehicle.d0,null,100,null,good,null,",
+          "1000,root.vehicle.d0,22222,55555,1000.11,null,null,",
+          "106,root.vehicle.d0,99,null,null,null,null,",
+          "105,root.vehicle.d0,99,199,11.11,null,null,",
+        };
+
+    try (Connection connection = EnvFactory.getEnv().getConnection();
+        Statement statement = connection.createStatement()) {
+
+      try (ResultSet resultSet =
+          statement.executeQuery(
+              "select * from root.vehicle.** order by device desc, time desc limit 5 offset 1 align by device")) {
+        ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+        List<Integer> actualIndexToExpectedIndexList =
+            checkHeader(
+                resultSetMetaData,
+                "Time,Device,s0,s1,s2,s3,s4",
+                new int[] {
+                  Types.TIMESTAMP,
+                  Types.VARCHAR,
+                  Types.INTEGER,
+                  Types.BIGINT,
+                  Types.FLOAT,
+                  Types.VARCHAR,
+                  Types.BOOLEAN
+                });
+
+        int cnt = 0;
+        while (resultSet.next()) {
+          String[] expectedStrings = retArray[cnt].split(",");
+          StringBuilder expectedBuilder = new StringBuilder();
+          StringBuilder actualBuilder = new StringBuilder();
+          for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+            actualBuilder.append(resultSet.getString(i)).append(",");
+            expectedBuilder
+                .append(expectedStrings[actualIndexToExpectedIndexList.get(i - 1)])
+                .append(",");
+          }
+          Assert.assertEquals(expectedBuilder.toString(), actualBuilder.toString());
+          cnt++;
+        }
+        Assert.assertEquals(retArray.length, cnt);
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+      fail(e.getMessage());
+    }
+  }
+
   @Test
   public void selectWithDuplicatedPathsTest() {
     String[] retArray =
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/PlanVisitor.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/PlanVisitor.java
index cf3fbe02af..d9430963ff 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/PlanVisitor.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/PlanVisitor.java
@@ -97,15 +97,13 @@ public abstract class PlanVisitor<R, C> {
 
   public abstract R visitPlan(PlanNode node, C context);
 
-  public R visitSourceNode(SourceNode node, C context) {
-    return visitPlan(node, context);
-  }
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Data Query Node
+  /////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public R visitSingleChildProcess(SingleChildProcessNode node, C context) {
-    return visitPlan(node, context);
-  }
+  // source --------------------------------------------------------------------------------------
 
-  public R visitMultiChildProcess(MultiChildProcessNode node, C context) {
+  public R visitSourceNode(SourceNode node, C context) {
     return visitPlan(node, context);
   }
 
@@ -125,12 +123,18 @@ public abstract class PlanVisitor<R, C> {
     return visitSourceNode(node, context);
   }
 
-  public R visitDeviceView(DeviceViewNode node, C context) {
-    return visitMultiChildProcess(node, context);
+  public R visitLastQueryScan(LastQueryScanNode node, C context) {
+    return visitSourceNode(node, context);
   }
 
-  public R visitDeviceMerge(DeviceMergeNode node, C context) {
-    return visitMultiChildProcess(node, context);
+  public R visitAlignedLastQueryScan(AlignedLastQueryScanNode node, C context) {
+    return visitSourceNode(node, context);
+  }
+
+  // single child --------------------------------------------------------------------------------
+
+  public R visitSingleChildProcess(SingleChildProcessNode node, C context) {
+    return visitPlan(node, context);
   }
 
   public R visitFill(FillNode node, C context) {
@@ -141,239 +145,255 @@ public abstract class PlanVisitor<R, C> {
     return visitSingleChildProcess(node, context);
   }
 
-  public R visitGroupByLevel(GroupByLevelNode node, C context) {
-    return visitMultiChildProcess(node, context);
+  public R visitSlidingWindowAggregation(SlidingWindowAggregationNode node, C context) {
+    return visitSingleChildProcess(node, context);
   }
 
-  public R visitGroupByTag(GroupByTagNode node, C context) {
-    return visitMultiChildProcess(node, context);
+  public R visitLimit(LimitNode node, C context) {
+    return visitSingleChildProcess(node, context);
   }
 
-  public R visitSlidingWindowAggregation(SlidingWindowAggregationNode node, C context) {
+  public R visitOffset(OffsetNode node, C context) {
     return visitSingleChildProcess(node, context);
   }
 
-  public R visitLimit(LimitNode node, C context) {
+  public R visitSort(SortNode node, C context) {
     return visitSingleChildProcess(node, context);
   }
 
-  public R visitOffset(OffsetNode node, C context) {
+  public R visitProject(ProjectNode node, C context) {
     return visitSingleChildProcess(node, context);
   }
 
-  public R visitAggregation(AggregationNode node, C context) {
-    return visitMultiChildProcess(node, context);
+  public R visitExchange(ExchangeNode node, C context) {
+    return visitSingleChildProcess(node, context);
   }
 
-  public R visitSort(SortNode node, C context) {
+  public R visitTransform(TransformNode node, C context) {
     return visitSingleChildProcess(node, context);
   }
 
-  public R visitProject(ProjectNode node, C context) {
+  public R visitInto(IntoNode node, C context) {
     return visitSingleChildProcess(node, context);
   }
 
-  public R visitTimeJoin(TimeJoinNode node, C context) {
-    return visitMultiChildProcess(node, context);
+  public R visitDeviceViewInto(DeviceViewIntoNode node, C context) {
+    return visitSingleChildProcess(node, context);
   }
 
-  public R visitExchange(ExchangeNode node, C context) {
+  public R visitSingleDeviceView(SingleDeviceViewNode node, C context) {
     return visitSingleChildProcess(node, context);
   }
 
-  public R visitSchemaQueryMerge(SchemaQueryMergeNode node, C context) {
+  // multi child --------------------------------------------------------------------------------
+
+  public R visitMultiChildProcess(MultiChildProcessNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitSchemaQueryScan(SchemaQueryScanNode node, C context) {
-    return visitPlan(node, context);
+  public R visitDeviceView(DeviceViewNode node, C context) {
+    return visitMultiChildProcess(node, context);
   }
 
-  public R visitSchemaQueryOrderByHeat(SchemaQueryOrderByHeatNode node, C context) {
-    return visitPlan(node, context);
+  public R visitDeviceMerge(DeviceMergeNode node, C context) {
+    return visitMultiChildProcess(node, context);
   }
 
-  public R visitTimeSeriesSchemaScan(TimeSeriesSchemaScanNode node, C context) {
-    return visitPlan(node, context);
+  public R visitGroupByLevel(GroupByLevelNode node, C context) {
+    return visitMultiChildProcess(node, context);
   }
 
-  public R visitDevicesSchemaScan(DevicesSchemaScanNode node, C context) {
-    return visitPlan(node, context);
+  public R visitGroupByTag(GroupByTagNode node, C context) {
+    return visitMultiChildProcess(node, context);
   }
 
-  public R visitDevicesCount(DevicesCountNode node, C context) {
-    return visitPlan(node, context);
+  public R visitAggregation(AggregationNode node, C context) {
+    return visitMultiChildProcess(node, context);
   }
 
-  public R visitTimeSeriesCount(TimeSeriesCountNode node, C context) {
-    return visitPlan(node, context);
+  public R visitTimeJoin(TimeJoinNode node, C context) {
+    return visitMultiChildProcess(node, context);
   }
 
-  public R visitLevelTimeSeriesCount(LevelTimeSeriesCountNode node, C context) {
-    return visitPlan(node, context);
+  public R visitLastQuery(LastQueryNode node, C context) {
+    return visitMultiChildProcess(node, context);
   }
 
-  public R visitCountMerge(CountSchemaMergeNode node, C context) {
-    return visitPlan(node, context);
+  public R visitLastQueryMerge(LastQueryMergeNode node, C context) {
+    return visitMultiChildProcess(node, context);
   }
 
-  public R visitCreateTimeSeries(CreateTimeSeriesNode node, C context) {
-    return visitPlan(node, context);
+  public R visitLastQueryCollect(LastQueryCollectNode node, C context) {
+    return visitMultiChildProcess(node, context);
   }
 
-  public R visitSchemaFetchMerge(SchemaFetchMergeNode node, C context) {
-    return visitPlan(node, context);
+  public R visitMergeSort(MergeSortNode node, C context) {
+    return visitMultiChildProcess(node, context);
   }
 
-  public R visitSchemaFetchScan(SchemaFetchScanNode node, C context) {
+  public R visitHorizontallyConcat(HorizontallyConcatNode node, C context) {
+    return visitMultiChildProcess(node, context);
+  }
+
+  // others -----------------------------------------------------------------------------------
+
+  public R visitShowQueries(ShowQueriesNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitCreateAlignedTimeSeries(CreateAlignedTimeSeriesNode node, C context) {
+  public R visitIdentitySink(IdentitySinkNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitCreateMultiTimeSeries(CreateMultiTimeSeriesNode node, C context) {
+  public R visitShuffleSink(ShuffleSinkNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitAlterTimeSeries(AlterTimeSeriesNode node, C context) {
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Schema Write & Query Node
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public R visitSchemaQueryMerge(SchemaQueryMergeNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitTransform(TransformNode node, C context) {
+  public R visitSchemaQueryScan(SchemaQueryScanNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitInsertRow(InsertRowNode node, C context) {
+  public R visitSchemaQueryOrderByHeat(SchemaQueryOrderByHeatNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitInsertTablet(InsertTabletNode node, C context) {
+  public R visitTimeSeriesSchemaScan(TimeSeriesSchemaScanNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitInsertRows(InsertRowsNode node, C context) {
+  public R visitDevicesSchemaScan(DevicesSchemaScanNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitInsertMultiTablets(InsertMultiTabletsNode node, C context) {
+  public R visitDevicesCount(DevicesCountNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitInsertRowsOfOneDevice(InsertRowsOfOneDeviceNode node, C context) {
+  public R visitTimeSeriesCount(TimeSeriesCountNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitNodePathsSchemaScan(NodePathsSchemaScanNode node, C context) {
+  public R visitLevelTimeSeriesCount(LevelTimeSeriesCountNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitNodeManagementMemoryMerge(NodeManagementMemoryMergeNode node, C context) {
+  public R visitCountMerge(CountSchemaMergeNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitNodePathConvert(NodePathsConvertNode node, C context) {
+  public R visitCreateTimeSeries(CreateTimeSeriesNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitNodePathsCount(NodePathsCountNode node, C context) {
+  public R visitSchemaFetchMerge(SchemaFetchMergeNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitLastQueryScan(LastQueryScanNode node, C context) {
+  public R visitSchemaFetchScan(SchemaFetchScanNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitAlignedLastQueryScan(AlignedLastQueryScanNode node, C context) {
+  public R visitCreateAlignedTimeSeries(CreateAlignedTimeSeriesNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitLastQuery(LastQueryNode node, C context) {
+  public R visitCreateMultiTimeSeries(CreateMultiTimeSeriesNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitLastQueryMerge(LastQueryMergeNode node, C context) {
+  public R visitAlterTimeSeries(AlterTimeSeriesNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitLastQueryCollect(LastQueryCollectNode node, C context) {
+  public R visitInternalCreateTimeSeries(InternalCreateTimeSeriesNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitDeleteTimeseries(DeleteTimeSeriesNode node, C context) {
+  public R visitActivateTemplate(ActivateTemplateNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitConstructSchemaBlackList(ConstructSchemaBlackListNode node, C context) {
+  public R visitPreDeactivateTemplate(PreDeactivateTemplateNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitRollbackSchemaBlackList(RollbackSchemaBlackListNode node, C context) {
+  public R visitRollbackPreDeactivateTemplate(RollbackPreDeactivateTemplateNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitDeleteData(DeleteDataNode node, C context) {
+  public R visitDeactivateTemplate(DeactivateTemplateNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitInternalCreateTimeSeries(InternalCreateTimeSeriesNode node, C context) {
+  public R visitInternalBatchActivateTemplate(InternalBatchActivateTemplateNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitActivateTemplate(ActivateTemplateNode node, C context) {
+  public R visitInternalCreateMultiTimeSeries(InternalCreateMultiTimeSeriesNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitPreDeactivateTemplate(PreDeactivateTemplateNode node, C context) {
+  public R visitNodePathsSchemaScan(NodePathsSchemaScanNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitRollbackPreDeactivateTemplate(RollbackPreDeactivateTemplateNode node, C context) {
+  public R visitNodeManagementMemoryMerge(NodeManagementMemoryMergeNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitDeactivateTemplate(DeactivateTemplateNode node, C context) {
+  public R visitNodePathConvert(NodePathsConvertNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitInto(IntoNode node, C context) {
+  public R visitNodePathsCount(NodePathsCountNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitDeviceViewInto(DeviceViewIntoNode node, C context) {
+  public R visitDeleteTimeseries(DeleteTimeSeriesNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitSingleDeviceView(SingleDeviceViewNode node, C context) {
+  public R visitConstructSchemaBlackList(ConstructSchemaBlackListNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitMergeSort(MergeSortNode node, C context) {
+  public R visitRollbackSchemaBlackList(RollbackSchemaBlackListNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitHorizontallyConcat(HorizontallyConcatNode node, C context) {
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Data Write Node
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public R visitInsertRow(InsertRowNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitShowQueries(ShowQueriesNode node, C context) {
+  public R visitInsertTablet(InsertTabletNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitInternalBatchActivateTemplate(InternalBatchActivateTemplateNode node, C context) {
+  public R visitInsertRows(InsertRowsNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitInternalCreateMultiTimeSeries(InternalCreateMultiTimeSeriesNode node, C context) {
+  public R visitInsertMultiTablets(InsertMultiTabletsNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitIdentitySink(IdentitySinkNode node, C context) {
+  public R visitInsertRowsOfOneDevice(InsertRowsOfOneDeviceNode node, C context) {
     return visitPlan(node, context);
   }
 
-  public R visitShuffleSink(ShuffleSinkNode node, C context) {
+  public R visitDeleteData(DeleteDataNode node, C context) {
     return visitPlan(node, context);
   }
 }