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 2025/05/13 09:44:10 UTC
(iotdb) branch master updated: add it & fix bugs for TreeDeviceViewScan
This is an automated email from the ASF dual-hosted git repository.
jackietien 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 b0a69febb9d add it & fix bugs for TreeDeviceViewScan
b0a69febb9d is described below
commit b0a69febb9dae6e1b07ef0ca1c4799b754af7a35
Author: shuwenwei <55...@users.noreply.github.com>
AuthorDate: Tue May 13 17:44:04 2025 +0800
add it & fix bugs for TreeDeviceViewScan
---
.../view/old/IoTDBFilterBetweenTableViewIT.java | 222 +
.../query/view/old/IoTDBFilterNullTableViewIT.java | 131 +
.../it/query/view/old/IoTDBFilterTableViewIT.java | 242 +
.../view/old/IoTDBNestedQueryTableViewIT.java | 505 ++
.../view/old/IoTDBSimpleQueryTableViewIT.java | 575 +++
.../IoTDBAlignByDeviceTableView2IT.java | 46 +
.../IoTDBAlignByDeviceTableView3IT.java | 46 +
.../IoTDBAlignByDeviceTableViewIT.java | 568 +++
...IoTDBAlignByDeviceWithTemplateTableView2IT.java | 48 +
.../IoTDBAlignByDeviceWithTemplateTableViewIT.java | 543 +++
...rderByLimitOffsetAlignByDeviceTableView2IT.java | 48 +
...OrderByLimitOffsetAlignByDeviceTableViewIT.java | 170 +
.../IoTDBOrderByWithAlignByDeviceTableView2IT.java | 48 +
.../IoTDBOrderByWithAlignByDeviceTableView3IT.java | 48 +
.../IoTDBOrderByWithAlignByDeviceTableViewIT.java | 1588 ++++++
...IoTDBAlignedOffsetLimitPushDownTableViewIT.java | 166 +
.../IoTDBAlignedSeriesQueryTableView2IT.java | 53 +
.../IoTDBAlignedSeriesQueryTableView3IT.java | 53 +
.../IoTDBAlignedSeriesQueryTableView4IT.java | 54 +
.../IoTDBAlignedSeriesQueryTableView5IT.java | 55 +
.../IoTDBAlignedSeriesQueryTableViewIT.java | 3698 ++++++++++++++
.../IoTDBPredicatePushDownTableView2IT.java | 54 +
.../IoTDBPredicatePushDownTableView3IT.java | 54 +
.../IoTDBPredicatePushDownTableView4IT.java | 54 +
.../aligned/IoTDBPredicatePushDownTableViewIT.java | 744 +++
.../it/query/view/old/aligned/TableViewUtils.java | 224 +
.../view/old/orderby/IoTDBOrderByTableViewIT.java | 1599 +++++++
.../view/old/query/IoTDBArithmeticTableViewIT.java | 411 ++
.../view/old/query/IoTDBPaginationTableViewIT.java | 218 +
.../view/recent/IoTDBColumnsMatchTableViewIT.java | 364 ++
.../view/recent/IoTDBComplexQueryTableViewIT.java | 100 +
.../view/recent/IoTDBDistinctTagTableViewIT.java | 173 +
.../it/query/view/recent/IoTDBFillTableViewIT.java | 740 +++
.../query/view/recent/IoTDBGapFillTableViewIT.java | 559 +++
.../view/recent/IoTDBNullIdQueryTableViewIT.java | 543 +++
.../view/recent/IoTDBNullValueTableViewIT.java | 84 +
...oTDBTableViewAggregationFunctionDistinctIT.java | 381 ++
.../view/recent/IoTDBTableViewAggregationIT.java | 5054 ++++++++++++++++++++
.../IoTDBTableViewAggregationNonStreamIT.java | 5054 ++++++++++++++++++++
.../query/view/recent/IoTDBTableViewQueryIT.java | 368 ++
.../process/join/LeftOuterTimeJoinOperator.java | 2 +-
.../plan/planner/TableOperatorGenerator.java | 122 +-
.../planner/plan/parameter/SeriesScanOptions.java | 9 +-
.../distribute/TableDistributedPlanGenerator.java | 17 +-
.../iterative/rule/PruneTableScanColumns.java | 3 +
.../node/AggregationTreeDeviceViewScanNode.java | 2 +-
.../node/TreeAlignedDeviceViewScanNode.java | 2 +-
.../node/TreeNonAlignedDeviceViewScanNode.java | 2 +-
.../table/DataNodeTreeViewSchemaUtils.java | 10 +
...nAlignedTreeDeviceViewScanOperatorTreeTest.java | 29 +-
.../plan/relational/analyzer/TreeViewTest.java | 19 +
51 files changed, 25867 insertions(+), 35 deletions(-)
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBFilterBetweenTableViewIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBFilterBetweenTableViewIT.java
new file mode 100644
index 00000000000..598303f1ca9
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBFilterBetweenTableViewIT.java
@@ -0,0 +1,222 @@
+/*
+ * 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.relational.it.query.view.old;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+import org.apache.iotdb.itbase.env.BaseEnv;
+
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.apache.iotdb.db.it.utils.TestUtils.defaultFormatDataTime;
+import static org.apache.iotdb.db.it.utils.TestUtils.prepareTableData;
+import static org.apache.iotdb.db.it.utils.TestUtils.tableResultSetEqualTest;
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBFilterBetweenTableViewIT {
+ protected static final int ITERATION_TIMES = 10;
+ private static final String DATABASE_NAME = "test";
+ private static final List<String> SQLs = new ArrayList<>();
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv().initClusterEnvironment();
+ createTimeSeries();
+ generateTreeData();
+ generateTableView(SQLs);
+ prepareTableData(SQLs);
+ }
+
+ private static void createTimeSeries() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE root.vehicle");
+ statement.execute("CREATE TIMESERIES root.vehicle.d1.s1 with datatype=INT32,encoding=PLAIN");
+ statement.execute("CREATE TIMESERIES root.vehicle.d1.s2 with datatype=INT32,encoding=PLAIN");
+ statement.execute("CREATE TIMESERIES root.vehicle.d1.s3 with datatype=TEXT,encoding=PLAIN");
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void generateTreeData() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ for (int i = 1; i <= ITERATION_TIMES; ++i) {
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3) values(%d,%d,%d,%s)", i, i, i, i));
+ }
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+
+ private static void generateTableView(List<String> SQLs) {
+ SQLs.add("CREATE DATABASE " + DATABASE_NAME);
+ SQLs.add("USE " + DATABASE_NAME);
+ SQLs.add(
+ "CREATE TABLE VIEW table1 (device STRING TAG, s1 INT32 FIELD, s2 INT32 FIELD, s3 TEXT FIELD) as root.vehicle.**");
+ }
+
+ @Test
+ public void testBetweenExpression() {
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+ int start = 1, end = 5;
+ String query = "SELECT * FROM table1 WHERE s1 BETWEEN " + start + " AND " + end;
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = start; i <= end; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(defaultFormatDataTime(i), rs.getString("time"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s1"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s2"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s3"));
+ }
+ }
+
+ query =
+ "SELECT * FROM table1 WHERE s1 NOT BETWEEN " // test not between
+ + (end + 1)
+ + " AND "
+ + ITERATION_TIMES;
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = start; i <= end; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(defaultFormatDataTime(i), rs.getString("time"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s1"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s2"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s3"));
+ }
+ }
+
+ query = "SELECT * FROM table1 WHERE time BETWEEN " + start + " AND " + end;
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = start; i <= end; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(defaultFormatDataTime(i), rs.getString("time"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s1"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s2"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s3"));
+ }
+ }
+
+ query =
+ "SELECT * FROM table1 WHERE time NOT BETWEEN " // test not between
+ + (end + 1)
+ + " AND "
+ + ITERATION_TIMES;
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = start; i <= end; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(defaultFormatDataTime(i), rs.getString("time"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s1"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s2"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s3"));
+ }
+ }
+
+ query = "SELECT * FROM table1 WHERE " + start + " BETWEEN time AND " + end;
+ try (ResultSet rs = statement.executeQuery(query)) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(defaultFormatDataTime(1), rs.getString("time"));
+ Assert.assertEquals("1", rs.getString("s1"));
+ Assert.assertEquals("1", rs.getString("s2"));
+ Assert.assertEquals("1", rs.getString("s3"));
+ }
+
+ query = "SELECT * FROM table1 WHERE " + start + " NOT BETWEEN time AND " + end;
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = start + 1; i <= end; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(defaultFormatDataTime(i), rs.getString("time"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s1"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s2"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s3"));
+ }
+ }
+
+ query = "SELECT * FROM table1 WHERE " + start + " BETWEEN " + end + " AND time";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ Assert.assertFalse(rs.next());
+ }
+
+ query = "SELECT * FROM table1 WHERE " + start + " NOT BETWEEN " + end + " AND time";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = start; i <= end; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(defaultFormatDataTime(i), rs.getString("time"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s1"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s2"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s3"));
+ }
+ }
+
+ String[] expectedHeader = new String[] {"_col0", "_col1"};
+ String[] retArray = new String[] {"true,true,", "true,false,", "false,false,"};
+ tableResultSetEqualTest(
+ "select s1 between 1 and 2, time between 0 and 1 from table1 where time between 1 and 3",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ expectedHeader = new String[] {"r1", "r2"};
+ retArray = new String[] {"true,true,", "true,false,", "false,false,"};
+ tableResultSetEqualTest(
+ "select s1 between 1 and 2 as r1, time between 0 and 1 as r2 from table1 where time between 1 and 3",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ expectedHeader = new String[] {"_col0", "_col1"};
+ retArray = new String[] {"true,true,", "true,false,", "false,false,"};
+ tableResultSetEqualTest(
+ "select s1 between 1 and 2, time between 0 and 1 from table1 where time between 1 and 3 order by device",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ } catch (SQLException e) {
+ e.printStackTrace();
+ Assert.fail(e.getMessage());
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBFilterNullTableViewIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBFilterNullTableViewIT.java
new file mode 100644
index 00000000000..f6bed6f31c4
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBFilterNullTableViewIT.java
@@ -0,0 +1,131 @@
+/*
+ * 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.relational.it.query.view.old;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+import org.apache.iotdb.itbase.env.BaseEnv;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.Statement;
+
+import static org.apache.iotdb.db.it.utils.TestUtils.defaultFormatDataTime;
+import static org.apache.iotdb.db.it.utils.TestUtils.prepareData;
+import static org.apache.iotdb.db.it.utils.TestUtils.prepareTableData;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBFilterNullTableViewIT {
+ private static final String DATABASE_NAME = "test";
+
+ private static final String[] createSqls =
+ new String[] {
+ "CREATE DATABASE root.testNullFilter",
+ "CREATE TIMESERIES root.testNullFilter.d1.s1 WITH DATATYPE=INT32, ENCODING=PLAIN",
+ "CREATE TIMESERIES root.testNullFilter.d1.s2 WITH DATATYPE=BOOLEAN, ENCODING=PLAIN",
+ "CREATE TIMESERIES root.testNullFilter.d1.s3 WITH DATATYPE=DOUBLE, ENCODING=PLAIN"
+ };
+
+ private static final String[] insertSqls =
+ new String[] {
+ "INSERT INTO root.testNullFilter.d1(timestamp,s2,s3) " + "values(1, false, 11.1)",
+ "INSERT INTO root.testNullFilter.d1(timestamp,s1,s2) " + "values(2, 22, true)",
+ "INSERT INTO root.testNullFilter.d1(timestamp,s1,s3) " + "values(3, 23, 33.3)",
+ };
+
+ private static final String[] createTableViewSqls =
+ new String[] {
+ "CREATE DATABASE " + DATABASE_NAME,
+ "USE " + DATABASE_NAME,
+ "CREATE TABLE VIEW testNullFilter(device STRING TAG, s1 INT32 FIELD, s2 BOOLEAN FIELD, s3 DOUBLE FIELD) as root.testNullFilter.**",
+ };
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv().initClusterEnvironment();
+ prepareData(createSqls);
+ prepareData(insertSqls);
+ prepareTableData(createTableViewSqls);
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+
+ @Test
+ public void nullFilterTest() {
+ String[] retArray =
+ new String[] {
+ defaultFormatDataTime(1) + ",null,false,11.1",
+ defaultFormatDataTime(2) + ",22,true,null",
+ defaultFormatDataTime(3) + ",23,null,33.3"
+ };
+ try (Connection connectionIsNull =
+ EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connectionIsNull.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+ int count = 0;
+
+ ResultSet resultSet = statement.executeQuery("select * from testNullFilter where s1 is null");
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString("time")
+ + ","
+ + resultSet.getString("s1")
+ + ","
+ + resultSet.getString("s2")
+ + ","
+ + resultSet.getString("s3");
+ assertEquals(retArray[count], ans);
+ count++;
+ }
+
+ resultSet = statement.executeQuery("select * from testNullFilter where s1 is not null");
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString("time")
+ + ","
+ + resultSet.getString("s1")
+ + ","
+ + resultSet.getString("s2")
+ + ","
+ + resultSet.getString("s3");
+ assertEquals(retArray[count], ans);
+ count++;
+ }
+ assertEquals(retArray.length, count);
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBFilterTableViewIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBFilterTableViewIT.java
new file mode 100644
index 00000000000..18ebd801e6d
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBFilterTableViewIT.java
@@ -0,0 +1,242 @@
+/*
+ * 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.relational.it.query.view.old;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+import org.apache.iotdb.itbase.env.BaseEnv;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import static org.apache.iotdb.db.it.utils.TestUtils.tableResultSetEqualTest;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBFilterTableViewIT {
+ protected static final int ITERATION_TIMES = 10;
+ private static final String DATABASE_NAME = "test";
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv()
+ .getConfig()
+ .getCommonConfig()
+ .setEnableSeqSpaceCompaction(false)
+ .setEnableUnseqSpaceCompaction(false)
+ .setEnableCrossSpaceCompaction(false)
+ .setUdfMemoryBudgetInMB(5);
+ EnvFactory.getEnv().initClusterEnvironment();
+ createTimeSeries();
+ generateData();
+ createTableView();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+
+ private static void createTimeSeries() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE root.vehicle");
+ statement.execute(
+ "create TIMESERIES root.vehicle.testNaN.d1.n1 with datatype=DOUBLE,encoding=PLAIN");
+ statement.execute(
+ "create TIMESERIES root.vehicle.testNaN.d1.n2 with datatype=DOUBLE,encoding=PLAIN");
+ statement.execute(
+ "create TIMESERIES root.vehicle.testTimeSeries.d1.s1 with datatype=BOOLEAN,encoding=PLAIN");
+ statement.execute(
+ "create TIMESERIES root.vehicle.testTimeSeries.d1.s2 with datatype=BOOLEAN,encoding=PLAIN");
+ statement.execute(
+ "create TIMESERIES root.vehicle.testUDTF.d1.s1 with datatype=TEXT,encoding=PLAIN");
+ statement.execute(
+ "create TIMESERIES root.vehicle.testUDTF.d1.s2 with datatype=DOUBLE,encoding=PLAIN");
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void generateData() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ for (int i = 0; i < ITERATION_TIMES; i++) {
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.testNaN.d1(timestamp,n1,n2) values(%d,%d,%d)", i, i, i));
+
+ switch (i % 3) {
+ case 0:
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.testTimeSeries.d1(timestamp,s1,s2) values(%d,true,true)",
+ i));
+ break;
+ case 1:
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.testTimeSeries.d1(timestamp,s1,s2) values(%d,true,false)",
+ i));
+ break;
+ case 2:
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.testTimeSeries.d1(timestamp,s1,s2) values(%d,false,false)",
+ i));
+ break;
+ }
+ }
+ statement.execute(
+ " insert into root.sg1.d1(time, s1, s2) aligned values (1,1, \"1\"), (2,2,\"2\")");
+ statement.execute(
+ " insert into root.vehicle.testUDTF.d1(time, s1, s2) values (1,\"ss\",0), (2,\"d\",3)");
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void createTableView() {
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE " + DATABASE_NAME);
+ statement.execute("USE " + DATABASE_NAME);
+ statement.execute(
+ "CREATE TABLE VIEW testNaN(device STRING TAG, n1 DOUBLE FIELD, n2 DOUBLE FIELD) as root.vehicle.testNaN.**");
+ statement.execute(
+ "CREATE TABLE VIEW testTimeSeries(device STRING TAG, s1 BOOLEAN FIELD, s2 BOOLEAN FIELD) as root.vehicle.testTimeSeries.**");
+ statement.execute(
+ "CREATE TABLE VIEW testUDTF(device STRING TAG, s1 TEXT FIELD, s2 DOUBLE FIELD) as root.vehicle.testUDTF.**");
+ statement.execute(
+ "CREATE TABLE VIEW sg1(device STRING TAG, s1 DOUBLE FIELD, s2 TEXT FIELD) as root.sg1.**");
+
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testFilterBooleanSeries() {
+ String[] expectedHeader = new String[] {"s1", "s2"};
+ String[] retArray = new String[] {"true,true,", "true,true,", "true,true,", "true,true,"};
+ tableResultSetEqualTest(
+ "select s1, s2 from testTimeSeries " + "Where s2", expectedHeader, retArray, DATABASE_NAME);
+
+ tableResultSetEqualTest(
+ "select s1, s2 from testTimeSeries " + "Where s1 and s2",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ retArray =
+ new String[] {
+ "true,true,",
+ "true,false,",
+ "true,true,",
+ "true,false,",
+ "true,true,",
+ "true,false,",
+ "true,true,"
+ };
+ tableResultSetEqualTest(
+ "select s1, s2 from testTimeSeries " + "Where s1 or s2",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ tableResultSetEqualTest(
+ "select s1, s2 from testTimeSeries " + "Where s1 or false",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void testFilterNaN() {
+ String sqlStr = "select n1 from testNaN where n1/n2 > 0";
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ int count = 0;
+ while (resultSet.next()) {
+ ++count;
+ }
+
+ // 0.0/0.0 is NaN which should not be kept.
+ assertEquals(ITERATION_TIMES - 1, count);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testSameConstantWithDifferentType() {
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+ ResultSet resultSet =
+ statement.executeQuery("select s2 from sg1 where s1 = 1 and s2 >= '1' and s2 <= '2'");
+ int count = 0;
+ while (resultSet.next()) {
+ ++count;
+ }
+ assertEquals(1, count);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testCompareWithNull() {
+ tableResultSetEqualTest(
+ "select s1 from sg1 where s1 != null", new String[] {"s1"}, new String[] {}, DATABASE_NAME);
+ tableResultSetEqualTest(
+ "select s1 from sg1 where s1 <> null", new String[] {"s1"}, new String[] {}, DATABASE_NAME);
+ tableResultSetEqualTest(
+ "select s1 from sg1 where s1 = null", new String[] {"s1"}, new String[] {}, DATABASE_NAME);
+ }
+
+ @Test
+ public void testCalculateWithNull() {
+ tableResultSetEqualTest(
+ "select s1 + null from sg1",
+ new String[] {"_col0"},
+ new String[] {"null,", "null,"},
+ DATABASE_NAME);
+ tableResultSetEqualTest(
+ "select s1 - null from sg1",
+ new String[] {"_col0"},
+ new String[] {"null,", "null,"},
+ DATABASE_NAME);
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBNestedQueryTableViewIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBNestedQueryTableViewIT.java
new file mode 100644
index 00000000000..94defc8cdf7
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBNestedQueryTableViewIT.java
@@ -0,0 +1,505 @@
+/*
+ * 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.relational.it.query.view.old;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+import org.apache.iotdb.itbase.env.BaseEnv;
+
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBNestedQueryTableViewIT {
+
+ private static final String DATABASE_NAME = "db";
+
+ protected static final int ITERATION_TIMES = 10;
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv()
+ .getConfig()
+ .getCommonConfig()
+ .setEnableSeqSpaceCompaction(false)
+ .setEnableUnseqSpaceCompaction(false)
+ .setEnableCrossSpaceCompaction(false)
+ .setUdfMemoryBudgetInMB(5);
+
+ EnvFactory.getEnv().initClusterEnvironment();
+ createTimeSeries();
+ generateData();
+ createTableView();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+
+ private static void createTimeSeries() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE root.vehicle");
+ statement.execute("CREATE TIMESERIES root.vehicle.d1.s1 with datatype=INT32,encoding=PLAIN");
+ statement.execute("CREATE TIMESERIES root.vehicle.d1.s2 with datatype=INT32,encoding=PLAIN");
+ statement.execute("CREATE TIMESERIES root.vehicle.d1.s3 with datatype=TEXT,encoding=PLAIN");
+ statement.execute("CREATE TIMESERIES root.vehicle.d1.s4 with datatype=STRING,encoding=PLAIN");
+ statement.execute("CREATE TIMESERIES root.vehicle.d1.s5 with datatype=DATE,encoding=PLAIN");
+ statement.execute(
+ "CREATE TIMESERIES root.vehicle.d1.s6 with datatype=TIMESTAMP,encoding=PLAIN");
+ statement.execute("CREATE TIMESERIES root.vehicle2.d1.s1 with datatype=FLOAT,encoding=PLAIN");
+ statement.execute(
+ "CREATE TIMESERIES root.vehicle2.d1.s2 with datatype=DOUBLE,encoding=PLAIN");
+ statement.execute(
+ "CREATE TIMESERIES root.vehicle2.d1.empty with datatype=DOUBLE,encoding=PLAIN");
+
+ statement.execute("CREATE TIMESERIES root.likeTest.d1.s1 with datatype=TEXT,encoding=PLAIN");
+ statement.execute(
+ "CREATE TIMESERIES root.likeTest.d1.s2 with datatype=STRING,encoding=PLAIN");
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void generateData() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ for (int i = 1; i <= ITERATION_TIMES; ++i) {
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s6) values(%d,%d,%d,%s,%s,%d)",
+ i, i, i, i, i, i));
+ statement.execute(
+ (String.format(
+ "insert into root.vehicle2.d1(timestamp,s1,s2) values(%d,%d,%d)", i, i, i)));
+ }
+ statement.execute("insert into root.vehicle.d1(timestamp,s5) values(1,'2024-01-01')");
+ statement.execute("insert into root.vehicle.d1(timestamp,s5) values(2,'2024-01-02')");
+ statement.execute("insert into root.vehicle.d1(timestamp,s5) values(3,'2024-01-03')");
+
+ statement.execute(
+ "insert into root.likeTest.d1(timestamp,s1,s2) values(1,'abcdef', '123456')");
+ statement.execute(
+ "insert into root.likeTest.d1(timestamp,s1,s2) values(2,'_abcdef', '123\\456')");
+ statement.execute(
+ "insert into root.likeTest.d1(timestamp,s1,s2) values(3,'abcdef%', '123#456')");
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void createTableView() {
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE " + DATABASE_NAME);
+ statement.execute("USE " + DATABASE_NAME);
+ statement.execute(
+ "create table view vehicle1(device_id STRING TAG, s1 INT32 FIELD, s2 INT32 FIELD, s3 TEXT FIELD, s4 STRING FIELD, s5 DATE FIELD, s6 TIMESTAMP FIELD) as root.vehicle.**");
+
+ statement.execute(
+ "create table view vehicle2(device_id STRING TAG, s1 FLOAT FIELD, s2 DOUBLE FIELD, empty DOUBLE FIELD) as root.vehicle2.**");
+ statement.execute(
+ "create table view likeTest(device_id STRING TAG, s1 TEXT FIELD, s2 STRING FIELD) as root.likeTest.**");
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void testNestedRowByRowUDFExpressions() {
+ String sqlStr =
+ "select time, s1, s2, sin(sin(s1) * sin(s2) + cos(s1) * cos(s1)) + sin(sin(s1 - s1 + s2) * sin(s2) + cos(s1) * cos(s1)), asin(sin(asin(sin(s1 - s2 / (-s1))))) from vehicle2";
+
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+
+ assertEquals(1 + 4, resultSet.getMetaData().getColumnCount());
+
+ int count = 0;
+ while (resultSet.next()) {
+ ++count;
+
+ assertEquals(count, resultSet.getLong(1));
+ assertEquals(count, Double.parseDouble(resultSet.getString(2)), 0);
+ assertEquals(count, Double.parseDouble(resultSet.getString(3)), 0);
+ assertEquals(2 * Math.sin(1.0), Double.parseDouble(resultSet.getString(4)), 1e-5);
+ assertEquals(
+ Math.asin(Math.sin(Math.asin(Math.sin(count - count / (-count))))),
+ Double.parseDouble(resultSet.getString(5)),
+ 1e-5);
+ }
+
+ assertEquals(ITERATION_TIMES, count);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testRawDataQueryWithConstants() {
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+
+ String query = "SELECT time, 1 + s1 FROM vehicle1 where device_id='d1'";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = 1; i <= ITERATION_TIMES; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(i, rs.getLong(1));
+ Assert.assertEquals(i + 1, rs.getInt(2), 0.01);
+ }
+ Assert.assertFalse(rs.next());
+ }
+
+ query = "SELECT time, (1 + 4) * 2 / 10 + s1 FROM vehicle1 where device_id='d1'";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = 1; i <= ITERATION_TIMES; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(i, rs.getLong(1));
+ Assert.assertEquals(i + 1, rs.getInt(2), 0.01);
+ }
+ Assert.assertFalse(rs.next());
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ Assert.fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void testDuplicatedRawDataQueryWithConstants() {
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+
+ String query = "SELECT time, 1 + s1, 1 + s1 FROM vehicle1 where device_id='d1'";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = 1; i <= ITERATION_TIMES; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(i, rs.getLong(1));
+ Assert.assertEquals(i + 1, rs.getInt(2), 0.01);
+ Assert.assertEquals(i + 1, rs.getInt(3), 0.01);
+ }
+ Assert.assertFalse(rs.next());
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ Assert.fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void testCommutativeLaws() {
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+
+ String query =
+ "SELECT time, s1, s1 + 1, 1 + s1, s1 * 2, 2 * s1 FROM vehicle1 where device_id='d1'";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = 1; i <= ITERATION_TIMES; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(i, rs.getLong(1));
+ Assert.assertEquals(i, rs.getInt(2));
+ Assert.assertEquals(i + 1, rs.getInt(3), 0.01);
+ Assert.assertEquals(i + 1, rs.getInt(4), 0.01);
+ Assert.assertEquals(i * 2, rs.getInt(5), 0.01);
+ Assert.assertEquals(i * 2, rs.getInt(6), 0.01);
+ }
+ Assert.assertFalse(rs.next());
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ Assert.fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void testAssociativeLaws() {
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+
+ String query =
+ "SELECT time, s1, s1 + 1 + 2, (s1 + 1) + 2, s1 + (1 + 2), s1 * 2 * 3, s1 * (2 * 3), (s1 * 2) * 3 FROM vehicle1 where device_id='d1'";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = 1; i <= ITERATION_TIMES; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(i, rs.getLong(1));
+ Assert.assertEquals(i, rs.getInt(2));
+ Assert.assertEquals(i + 3, rs.getInt(3), 0.01);
+ Assert.assertEquals(i + 3, rs.getInt(4), 0.01);
+ Assert.assertEquals(i + 3, rs.getInt(5), 0.01);
+ Assert.assertEquals(i * 6, rs.getInt(6), 0.01);
+ Assert.assertEquals(i * 6, rs.getInt(7), 0.01);
+ Assert.assertEquals(i * 6, rs.getInt(8), 0.01);
+ }
+ Assert.assertFalse(rs.next());
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ Assert.fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void testDistributiveLaw() {
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+
+ String query =
+ "SELECT time, s1, (s1 + 1) * 2, s1 * 2 + 1 * 2, (s1 + 1) / 2, s1 / 2 + 1 / 2 FROM vehicle1 where device_id='d1'";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = 1; i <= ITERATION_TIMES; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(i, rs.getLong(1));
+ Assert.assertEquals(i, rs.getInt(2));
+ Assert.assertEquals(2 * i + 2, rs.getInt(3), 0.01);
+ Assert.assertEquals(2 * i + 2, rs.getInt(4), 0.01);
+ Assert.assertEquals((i + 1) / 2, rs.getInt(5), 0.01);
+ Assert.assertEquals(i / 2 + 1 / 2, rs.getInt(6), 0.01);
+ }
+ Assert.assertFalse(rs.next());
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ Assert.fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void testOrderOfArithmeticOperations() {
+ // Priority from high to low:
+ // 1. exponentiation and root extraction (not supported yet)
+ // 2. multiplication and division
+ // 3. addition and subtraction
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+
+ String query =
+ "SELECT time, 1 + s1 * 2 + 1, (1 + s1) * 2 + 1, (1 + s1) * (2 + 1) FROM vehicle1 where device_id='d1'";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = 1; i <= ITERATION_TIMES; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(i, rs.getLong(1));
+ Assert.assertEquals(2 * i + 2, rs.getInt(2), 0.01);
+ Assert.assertEquals(2 * i + 3, rs.getInt(3), 0.01);
+ Assert.assertEquals(3 * i + 3, rs.getInt(4), 0.01);
+ }
+ Assert.assertFalse(rs.next());
+ }
+
+ query =
+ "SELECT time, 1 - s1 / 2 + 1, (1 - s1) / 2 + 1, (1 - s1) / (2 + 1) FROM vehicle1 where device_id='d1'";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = 1; i <= ITERATION_TIMES; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(i, rs.getLong(1));
+ Assert.assertEquals(2 - i / 2, rs.getInt(2), 0.01);
+ Assert.assertEquals((1 - i) / 2 + 1, rs.getInt(3), 0.01);
+ Assert.assertEquals((1 - i) / (2 + 1), rs.getInt(4), 0.01);
+ }
+ Assert.assertFalse(rs.next());
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ Assert.fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void testBetweenExpression() {
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ int start = 2, end = 8;
+ statement.execute("USE " + DATABASE_NAME);
+ String query =
+ "SELECT * FROM vehicle1 where device_id='d1' and (s1 BETWEEN "
+ + start
+ + " AND "
+ + end
+ + ")";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = start; i <= end; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(i, rs.getLong("time"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s1"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s2"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s3"));
+ }
+ }
+
+ query =
+ "SELECT * FROM vehicle1 where device_id='d1' and (s1 NOT BETWEEN " // test not between
+ + (end + 1)
+ + " AND "
+ + ITERATION_TIMES
+ + ")";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(1, rs.getLong("time"));
+ Assert.assertEquals("1", rs.getString("s1"));
+ Assert.assertEquals("1", rs.getString("s2"));
+ Assert.assertEquals("1", rs.getString("s3"));
+ for (int i = start; i <= end; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(i, rs.getLong("time"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s1"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s2"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s3"));
+ }
+ }
+
+ query =
+ "SELECT * FROM vehicle1 where device_id='d1' and (time BETWEEN "
+ + start
+ + " AND "
+ + end
+ + ")";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = start; i <= end; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(i, rs.getLong("time"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s1"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s2"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s3"));
+ }
+ }
+
+ query =
+ "SELECT * FROM vehicle1 where device_id='d1' and (time NOT BETWEEN " // test not between
+ + (end + 1)
+ + " AND "
+ + ITERATION_TIMES
+ + ")";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(1, rs.getLong("time"));
+ Assert.assertEquals("1", rs.getString("s1"));
+ Assert.assertEquals("1", rs.getString("s2"));
+ Assert.assertEquals("1", rs.getString("s3"));
+ for (int i = start; i <= end; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(i, rs.getLong("time"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s1"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s2"));
+ Assert.assertEquals(String.valueOf(i), rs.getString("s3"));
+ }
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ Assert.fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void testRegularLikeInExpressions() {
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+ String[] ans = new String[] {"abcdef"};
+ String query = "SELECT s1 FROM likeTest where s1 LIKE 'abcdef'";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = 2; i < 3; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(ans[i - 2], rs.getString(1));
+ }
+ Assert.assertFalse(rs.next());
+ }
+
+ ans = new String[] {"_abcdef"};
+ query = "SELECT s1 FROM likeTest where s1 LIKE '\\_%' escape '\\'";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = 2; i < 3; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(ans[i - 2], rs.getString(1));
+ }
+ Assert.assertFalse(rs.next());
+ }
+
+ ans = new String[] {"abcdef", "_abcdef", "abcdef%"};
+ query = "SELECT s1 FROM likeTest where s1 LIKE '%abcde%' escape '\\'";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = 2; i < 5; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(ans[i - 2], rs.getString(1));
+ }
+ Assert.assertFalse(rs.next());
+ }
+
+ ans = new String[] {"123456"};
+ query = "SELECT s2 FROM likeTest where s2 LIKE '12345_'";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = 2; i < 3; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(ans[i - 2], rs.getString(1));
+ }
+ Assert.assertFalse(rs.next());
+ }
+
+ ans = new String[] {"123\\456"};
+ query = "SELECT s2 FROM likeTest where s2 LIKE '%\\\\%' escape '\\'";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = 2; i < 3; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(ans[i - 2], rs.getString(1));
+ }
+ Assert.assertFalse(rs.next());
+ }
+
+ ans = new String[] {"123#456"};
+ query = "SELECT s2 FROM likeTest where s2 LIKE '123##456' escape '#'";
+ try (ResultSet rs = statement.executeQuery(query)) {
+ for (int i = 2; i < 3; i++) {
+ Assert.assertTrue(rs.next());
+ Assert.assertEquals(ans[i - 2], rs.getString(1));
+ }
+ Assert.assertFalse(rs.next());
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ Assert.fail(e.getMessage());
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBSimpleQueryTableViewIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBSimpleQueryTableViewIT.java
new file mode 100644
index 00000000000..9cc8e273233
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/IoTDBSimpleQueryTableViewIT.java
@@ -0,0 +1,575 @@
+/*
+ * 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.relational.it.query.view.old;
+
+import org.apache.iotdb.commons.schema.column.ColumnHeaderConstant;
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+import org.apache.iotdb.itbase.env.BaseEnv;
+
+import org.apache.tsfile.enums.TSDataType;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Types;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+
+import static org.apache.iotdb.db.it.utils.TestUtils.defaultFormatDataTime;
+import static org.apache.iotdb.db.it.utils.TestUtils.tableResultSetEqualTest;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBSimpleQueryTableViewIT {
+ private static final String DATABASE_NAME = "test";
+
+ @Before
+ public void setUp() throws Exception {
+ EnvFactory.getEnv().initClusterEnvironment();
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+
+ @Test
+ public void testCreateTimeseries1() {
+
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.setFetchSize(5);
+ statement.execute("CREATE DATABASE root.sg1");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s1 WITH DATATYPE=INT32,ENCODING=PLAIN");
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.setFetchSize(5);
+ statement.execute("CREATE DATABASE " + DATABASE_NAME);
+ statement.execute("USE " + DATABASE_NAME);
+ statement.execute(
+ "CREATE TABLE VIEW table1(device STRING TAG, s1 INT32 FIELD) as root.sg1.**");
+
+ try (ResultSet resultSet = statement.executeQuery("describe table1")) {
+ if (resultSet.next()
+ && resultSet.getString(ColumnHeaderConstant.COLUMN_NAME).equals("s1")) {
+ assertEquals("INT32", resultSet.getString(ColumnHeaderConstant.DATATYPE).toUpperCase());
+ assertEquals(
+ "FIELD", resultSet.getString(ColumnHeaderConstant.COLUMN_CATEGORY).toUpperCase());
+ }
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+
+ @Test
+ public void testOrderByTimeDesc() throws Exception {
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TREE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.setFetchSize(5);
+ statement.execute("CREATE DATABASE root.sg1");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s0 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s1 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (1, 1)");
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (2, 2)");
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (3, 3)");
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (4, 4)");
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s1) VALUES (3, 3)");
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s1) VALUES (1, 1)");
+ statement.execute("flush");
+ }
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.setFetchSize(5);
+ statement.execute("CREATE DATABASE " + DATABASE_NAME);
+ statement.execute("USE " + DATABASE_NAME);
+ statement.execute(
+ "CREATE TABLE VIEW table1(device STRING TAG, s0 INT32 FIELD, s1 INT32 FIELD) as root.sg1.**");
+ statement.execute("flush");
+
+ String[] expectedHeader = new String[] {"time", "device", "s0", "s1"};
+ String[] ret =
+ new String[] {
+ defaultFormatDataTime(4) + ",d0,4,null,",
+ defaultFormatDataTime(3) + ",d0,3,3,",
+ defaultFormatDataTime(2) + ",d0,2,null,",
+ defaultFormatDataTime(1) + ",d0,1,1,",
+ };
+
+ tableResultSetEqualTest(
+ "select * from table1 order by time desc", expectedHeader, ret, DATABASE_NAME);
+ }
+ }
+
+ @Test
+ public void testShowTimeseriesDataSet1() throws SQLException {
+
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TREE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.setFetchSize(5);
+ statement.execute("CREATE DATABASE root.sg1");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s1 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s2 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s3 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s4 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s5 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s6 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s7 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s8 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s9 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s10 WITH DATATYPE=INT32,ENCODING=PLAIN");
+
+ statement.execute("flush");
+ }
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.setFetchSize(5);
+ statement.execute("CREATE DATABASE " + DATABASE_NAME);
+ statement.execute("USE " + DATABASE_NAME);
+ statement.execute(
+ "CREATE TABLE VIEW table1(device STRING TAG, s1 INT32 FIELD, s2 INT32 FIELD, s3 INT32 FIELD, s4 INT32 FIELD, s5 INT32 FIELD, s6 INT32 FIELD, s7 INT32 FIELD, s8 INT32 FIELD, s9 INT32 FIELD, s10 INT32 FIELD) as root.sg1.**");
+
+ int count = 0;
+ try (ResultSet resultSet = statement.executeQuery("describe table1")) {
+ while (resultSet.next()) {
+ count++;
+ }
+ }
+
+ Assert.assertEquals(12, count);
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ throw e;
+ }
+ }
+
+ @Test
+ public void testShowTimeseriesDataSet2() throws SQLException {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.setFetchSize(10);
+ statement.execute("CREATE DATABASE root.sg1");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s1 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s2 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s3 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s4 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s5 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s6 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s7 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s8 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s9 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s10 WITH DATATYPE=INT32,ENCODING=PLAIN");
+
+ statement.execute("flush");
+ }
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.setFetchSize(10);
+ statement.execute("CREATE DATABASE " + DATABASE_NAME);
+ statement.execute("USE " + DATABASE_NAME);
+ statement.execute(
+ "CREATE TABLE VIEW table1(device STRING TAG, s1 INT32 FIELD, s2 INT32 FIELD, s3 INT32 FIELD, s4 INT32 FIELD, s5 INT32 FIELD, s6 INT32 FIELD, s7 INT32 FIELD, s8 INT32 FIELD, s9 INT32 FIELD, s10 INT32 FIELD) as root.sg1.**");
+
+ statement.execute("flush");
+
+ int count = 0;
+ try (ResultSet resultSet = statement.executeQuery("describe table1")) {
+ while (resultSet.next()) {
+ count++;
+ }
+ }
+
+ Assert.assertEquals(12, count);
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ throw e;
+ }
+ }
+
+ @Test
+ public void testShowTimeseriesDataSet3() throws SQLException {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.setFetchSize(15);
+ statement.execute("CREATE DATABASE root.sg1");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s1 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s2 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s3 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s4 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s5 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s6 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s7 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s8 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s9 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s10 WITH DATATYPE=INT32,ENCODING=PLAIN");
+
+ statement.execute("flush");
+ }
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.setFetchSize(15);
+ statement.execute("CREATE DATABASE " + DATABASE_NAME);
+ statement.execute("USE " + DATABASE_NAME);
+ statement.execute(
+ "CREATE TABLE VIEW table1(device STRING TAG, s1 INT32 FIELD, s2 INT32 FIELD, s3 INT32 FIELD, s4 INT32 FIELD, s5 INT32 FIELD, s6 INT32 FIELD, s7 INT32 FIELD, s8 INT32 FIELD, s9 INT32 FIELD, s10 INT32 FIELD) as root.sg1.**");
+
+ statement.execute("flush");
+
+ int count = 0;
+ try (ResultSet resultSet = statement.executeQuery("describe table1")) {
+ while (resultSet.next()) {
+ count++;
+ }
+ }
+
+ Assert.assertEquals(12, count);
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ throw e;
+ }
+ }
+
+ @Test
+ public void testFirstOverlappedPageFiltered() throws SQLException {
+
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE root.sg1");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s0 WITH DATATYPE=INT32,ENCODING=PLAIN");
+
+ // seq chunk : [1,10]
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (1, 1)");
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (10, 10)");
+
+ statement.execute("flush");
+
+ // seq chunk : [13,20]
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (13, 13)");
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (20, 20)");
+
+ statement.execute("flush");
+
+ // unseq chunk : [5,15]
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (5, 5)");
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (15, 15)");
+
+ statement.execute("flush");
+ }
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE " + DATABASE_NAME);
+ statement.execute("USE " + DATABASE_NAME);
+ statement.execute(
+ "CREATE TABLE VIEW table1(device STRING TAG, s0 INT32 FIELD) as root.sg1.**");
+
+ long count = 0;
+ try (ResultSet resultSet = statement.executeQuery("select s0 from table1 where s0 > 18")) {
+ while (resultSet.next()) {
+ count++;
+ }
+ }
+
+ Assert.assertEquals(1, count);
+ }
+ }
+
+ @Test
+ public void testPartialInsertion() throws SQLException {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE root.sg1");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s0 WITH DATATYPE=INT32,ENCODING=PLAIN");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s1 WITH DATATYPE=INT32,ENCODING=PLAIN");
+
+ try {
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0, s1) VALUES (1, 1, 2.2)");
+ fail();
+ } catch (SQLException e) {
+ assertTrue(e.getMessage().contains("s1"));
+ }
+ }
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE " + DATABASE_NAME);
+ statement.execute("USE " + DATABASE_NAME);
+ statement.execute(
+ "CREATE TABLE VIEW table1(device STRING TAG, s0 INT32 FIELD, s1 INT32 FIELD) as root.sg1.**");
+
+ try (ResultSet resultSet = statement.executeQuery("select s0, s1 from table1")) {
+ while (resultSet.next()) {
+ assertEquals(1, resultSet.getInt("s0"));
+ assertEquals(null, resultSet.getString("s1"));
+ }
+ }
+ }
+ }
+
+ @Test
+ public void testOverlappedPagesMerge() throws SQLException {
+
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE root.sg1");
+ statement.execute("CREATE TIMESERIES root.sg1.d0.s0 WITH DATATYPE=INT32,ENCODING=PLAIN");
+
+ // seq chunk : start-end [1000, 1000]
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (1000, 0)");
+
+ statement.execute("flush");
+
+ // unseq chunk : [1,10]
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (1, 1)");
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (10, 10)");
+
+ statement.execute("flush");
+
+ // usneq chunk : [5,15]
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (5, 5)");
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (15, 15)");
+
+ statement.execute("flush");
+
+ // unseq chunk : [15,15]
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s0) VALUES (15, 150)");
+
+ statement.execute("flush");
+ }
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE " + DATABASE_NAME);
+ statement.execute("USE " + DATABASE_NAME);
+ statement.execute(
+ "CREATE TABLE VIEW table1(device STRING TAG, s0 INT32 FIELD) as root.sg1.**");
+
+ long count = 0;
+
+ try (ResultSet resultSet = statement.executeQuery("select s0 from table1 where s0 < 100")) {
+ while (resultSet.next()) {
+ count++;
+ }
+ }
+
+ Assert.assertEquals(4, count);
+ }
+ }
+
+ @Test
+ public void testTimeseriesMetadataCache() throws SQLException {
+
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE root.sg1");
+ for (int i = 0; i < 10000; i++) {
+ statement.execute(
+ "CREATE TIMESERIES root.sg1.d0.s" + i + " WITH DATATYPE=INT32,ENCODING=PLAIN");
+ }
+ for (int i = 1; i < 10000; i++) {
+ statement.execute("INSERT INTO root.sg1.d0(timestamp, s" + i + ") VALUES (1000, 1)");
+ }
+ statement.execute("flush");
+ }
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE test");
+ statement.execute("USE " + DATABASE_NAME);
+ StringBuilder createTableBuilder = new StringBuilder();
+ createTableBuilder.append("CREATE TABLE VIEW table1(device STRING TAG,");
+ for (int i = 0; i < 1000; i++) {
+ String columnName = "s" + i;
+ createTableBuilder.append(columnName).append(" INT32 FIELD,");
+ }
+ createTableBuilder
+ .deleteCharAt(createTableBuilder.lastIndexOf(","))
+ .append(") as root.sg1.**");
+ statement.execute(createTableBuilder.toString());
+ statement.executeQuery("select s0 from table1");
+ } catch (SQLException e) {
+ fail();
+ }
+ }
+
+ @Test
+ public void testUseSameStatement() throws SQLException {
+
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE root.sg1");
+ statement.execute(
+ "CREATE TIMESERIES root.sg1.d0.s0 WITH DATATYPE=INT64, ENCODING=RLE, COMPRESSOR=SNAPPY");
+ statement.execute(
+ "CREATE TIMESERIES root.sg1.d0.s1 WITH DATATYPE=INT64, ENCODING=RLE, COMPRESSOR=SNAPPY");
+ statement.execute(
+ "CREATE TIMESERIES root.sg1.d1.s0 WITH DATATYPE=INT64, ENCODING=RLE, COMPRESSOR=SNAPPY");
+ statement.execute(
+ "CREATE TIMESERIES root.sg1.d1.s1 WITH DATATYPE=INT64, ENCODING=RLE, COMPRESSOR=SNAPPY");
+
+ statement.execute("insert into root.sg1.d0(timestamp,s0,s1) values(1,1,1)");
+ statement.execute("insert into root.sg1.d1(timestamp,s0,s1) values(1000,1000,1000)");
+ statement.execute("insert into root.sg1.d0(timestamp,s0,s1) values(10,10,10)");
+ }
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE test");
+ statement.execute("USE " + DATABASE_NAME);
+ statement.execute(
+ "CREATE TABLE VIEW table1(device STRING TAG, s0 INT64 FIELD, s1 INT64 FIELD) as root.sg1.**");
+
+ List<ResultSet> resultSetList = new ArrayList<>();
+
+ ResultSet r1 = statement.executeQuery("select * from table1 where device='d0' and time <= 1");
+ resultSetList.add(r1);
+
+ ResultSet r2 = statement.executeQuery("select * from table1 where device='d1' and s0 = 1000");
+ resultSetList.add(r2);
+
+ ResultSet r3 = statement.executeQuery("select * from table1 where device='d0' and s1 = 10");
+ resultSetList.add(r3);
+
+ r1.next();
+ Assert.assertEquals(r1.getLong(1), 1L);
+ Assert.assertEquals(r1.getLong(3), 1L);
+ Assert.assertEquals(r1.getLong(4), 1L);
+
+ r2.next();
+ Assert.assertEquals(r2.getLong(1), 1000L);
+ Assert.assertEquals(r2.getLong(3), 1000L);
+ Assert.assertEquals(r2.getLong(4), 1000L);
+
+ r3.next();
+ Assert.assertEquals(r3.getLong(1), 10L);
+ Assert.assertEquals(r3.getLong(3), 10L);
+ Assert.assertEquals(r3.getLong(4), 10L);
+ }
+ }
+
+ @Test
+ public void testEnableAlign() throws Exception {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE TIMESERIES root.sg1.d1.s1 WITH DATATYPE=INT32");
+ statement.execute("CREATE TIMESERIES root.sg1.d1.s2 WITH DATATYPE=BOOLEAN");
+ }
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE test");
+ statement.execute("USE " + DATABASE_NAME);
+ statement.execute(
+ "CREATE TABLE VIEW table1(device STRING TAG, s1 INT32 FIELD, s2 BOOLEAN FIELD) as root.sg1.**");
+ ResultSet resultSet = statement.executeQuery("select time, s1, s2 from table1");
+ ResultSetMetaData metaData = resultSet.getMetaData();
+ int[] types = {Types.TIMESTAMP, Types.INTEGER, Types.BOOLEAN};
+ int columnCount = metaData.getColumnCount();
+ for (int i = 0; i < columnCount; i++) {
+ Assert.assertEquals(types[i], metaData.getColumnType(i + 1));
+ }
+ }
+ }
+
+ @Test
+ public void testNewDataType() throws SQLException {
+
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+
+ statement.execute("CREATE DATABASE root.sg1");
+ statement.execute(
+ "CREATE TIMESERIES root.sg1.d1.s4 WITH DATATYPE=DATE, ENCODING=PLAIN, COMPRESSOR=SNAPPY");
+ statement.execute(
+ "CREATE TIMESERIES root.sg1.d1.s5 WITH DATATYPE=TIMESTAMP, ENCODING=PLAIN, COMPRESSOR=SNAPPY");
+ statement.execute(
+ "CREATE TIMESERIES root.sg1.d1.s6 WITH DATATYPE=BLOB, ENCODING=PLAIN, COMPRESSOR=SNAPPY");
+ statement.execute(
+ "CREATE TIMESERIES root.sg1.d1.s7 WITH DATATYPE=STRING, ENCODING=PLAIN, COMPRESSOR=SNAPPY");
+ for (int i = 1; i <= 10; i++) {
+ statement.execute(
+ String.format(
+ "insert into root.sg1.d1(timestamp, s4, s5, s6, s7) values(%d, \"%s\", %d, %s, \"%s\")",
+ i, LocalDate.of(2024, 5, i % 31 + 1), i, "X'cafebabe'", i));
+ }
+ }
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE test");
+ statement.execute("USE " + DATABASE_NAME);
+ statement.execute(
+ "CREATE TABLE VIEW table1(device STRING TAG, s4 DATE FIELD, s5 TIMESTAMP FIELD, s6 BLOB FIELD, s7 STRING FIELD) as root.sg1.**");
+
+ try (ResultSet resultSet = statement.executeQuery("select * from table1")) {
+ final ResultSetMetaData metaData = resultSet.getMetaData();
+ final int columnCount = metaData.getColumnCount();
+ assertEquals(6, columnCount);
+ HashMap<Integer, TSDataType> columnType = new HashMap<>();
+ for (int i = 3; i <= columnCount; i++) {
+ if (metaData.getColumnLabel(i).equals("s4")) {
+ columnType.put(i, TSDataType.DATE);
+ } else if (metaData.getColumnLabel(i).equals("s5")) {
+ columnType.put(i, TSDataType.TIMESTAMP);
+ } else if (metaData.getColumnLabel(i).equals("s6")) {
+ columnType.put(i, TSDataType.BLOB);
+ } else if (metaData.getColumnLabel(i).equals("s7")) {
+ columnType.put(i, TSDataType.TEXT);
+ }
+ }
+ byte[] byteArray = new byte[] {(byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE};
+ while (resultSet.next()) {
+ long time = resultSet.getLong(1);
+ Date date = resultSet.getDate(3);
+ long timestamp = resultSet.getLong(4);
+ byte[] blob = resultSet.getBytes(5);
+ String text = resultSet.getString(6);
+ assertEquals(2024 - 1900, date.getYear());
+ assertEquals(5 - 1, date.getMonth());
+ assertEquals(time % 31 + 1, date.getDate());
+ assertEquals(time, timestamp);
+ assertArrayEquals(byteArray, blob);
+ assertEquals(String.valueOf(time), text);
+ }
+ }
+
+ } catch (SQLException e) {
+ fail();
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceTableView2IT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceTableView2IT.java
new file mode 100644
index 00000000000..509cddd434a
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceTableView2IT.java
@@ -0,0 +1,46 @@
+/*
+ * 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.relational.it.query.view.old.alignbydevice;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBAlignByDeviceTableView2IT extends IoTDBAlignByDeviceTableViewIT {
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv().getConfig().getCommonConfig().setDegreeOfParallelism(4);
+ EnvFactory.getEnv().initClusterEnvironment();
+ insertData();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceTableView3IT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceTableView3IT.java
new file mode 100644
index 00000000000..573d27d885b
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceTableView3IT.java
@@ -0,0 +1,46 @@
+/*
+ * 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.relational.it.query.view.old.alignbydevice;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBAlignByDeviceTableView3IT extends IoTDBAlignByDeviceTableViewIT {
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv().getConfig().getCommonConfig().setDegreeOfParallelism(1);
+ EnvFactory.getEnv().initClusterEnvironment();
+ insertData();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceTableViewIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceTableViewIT.java
new file mode 100644
index 00000000000..aaca79b9899
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceTableViewIT.java
@@ -0,0 +1,568 @@
+/*
+ * 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.relational.it.query.view.old.alignbydevice;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+import org.apache.iotdb.itbase.env.BaseEnv;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.Statement;
+
+import static org.apache.iotdb.db.it.utils.TestUtils.tableResultSetEqualTest;
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBAlignByDeviceTableViewIT {
+
+ private static final String DATABASE_NAME = "db";
+
+ private static final String[] createTableViewSqls =
+ new String[] {
+ "CREATE DATABASE " + DATABASE_NAME,
+ "USE " + DATABASE_NAME,
+ "create table view vehicle(device_id STRING TAG, s0 INT32 FIELD, s1 INT64 FIELD, s2 FLOAT FIELD, s3 STRING FIELD, s4 BOOLEAN FIELD) as root.vehicle.**"
+ };
+
+ private static final String[] sqls =
+ new String[] {
+ "CREATE DATABASE root.vehicle",
+ "CREATE TIMESERIES root.vehicle.d0.s0 WITH DATATYPE=INT32, ENCODING=RLE",
+ "CREATE TIMESERIES root.vehicle.d0.s1 WITH DATATYPE=INT64, ENCODING=RLE",
+ "CREATE TIMESERIES root.vehicle.d0.s2 WITH DATATYPE=FLOAT, ENCODING=RLE",
+ "CREATE TIMESERIES root.vehicle.d0.s3 WITH DATATYPE=TEXT, ENCODING=PLAIN",
+ "CREATE TIMESERIES root.vehicle.d0.s4 WITH DATATYPE=BOOLEAN, ENCODING=PLAIN",
+ "CREATE TIMESERIES root.vehicle.d1.s0 WITH DATATYPE=INT32, ENCODING=RLE",
+ "insert into root.vehicle.d0(timestamp,s0) values(1,101)",
+ "insert into root.vehicle.d0(timestamp,s0) values(2,198)",
+ "insert into root.vehicle.d0(timestamp,s0) values(100,99)",
+ "insert into root.vehicle.d0(timestamp,s0) values(101,99)",
+ "insert into root.vehicle.d0(timestamp,s0) values(102,80)",
+ "insert into root.vehicle.d0(timestamp,s0) values(103,99)",
+ "insert into root.vehicle.d0(timestamp,s0) values(104,90)",
+ "insert into root.vehicle.d0(timestamp,s0) values(105,99)",
+ "insert into root.vehicle.d0(timestamp,s0) values(106,99)",
+ "insert into root.vehicle.d0(timestamp,s0) values(2,10000)",
+ "insert into root.vehicle.d0(timestamp,s0) values(50,10000)",
+ "insert into root.vehicle.d0(timestamp,s0) values(1000,22222)",
+ "insert into root.vehicle.d0(timestamp,s1) values(1,1101)",
+ "insert into root.vehicle.d0(timestamp,s1) values(2,198)",
+ "insert into root.vehicle.d0(timestamp,s1) values(100,199)",
+ "insert into root.vehicle.d0(timestamp,s1) values(101,199)",
+ "insert into root.vehicle.d0(timestamp,s1) values(102,180)",
+ "insert into root.vehicle.d0(timestamp,s1) values(103,199)",
+ "insert into root.vehicle.d0(timestamp,s1) values(104,190)",
+ "insert into root.vehicle.d0(timestamp,s1) values(105,199)",
+ "insert into root.vehicle.d0(timestamp,s1) values(2,40000)",
+ "insert into root.vehicle.d0(timestamp,s1) values(50,50000)",
+ "insert into root.vehicle.d0(timestamp,s1) values(1000,55555)",
+ "insert into root.vehicle.d0(timestamp,s1) values(2000-01-01T00:00:00+08:00, 100)",
+ "insert into root.vehicle.d0(timestamp,s2) values(1000,55555)",
+ "insert into root.vehicle.d0(timestamp,s2) values(2,2.22)",
+ "insert into root.vehicle.d0(timestamp,s2) values(3,3.33)",
+ "insert into root.vehicle.d0(timestamp,s2) values(4,4.44)",
+ "insert into root.vehicle.d0(timestamp,s2) values(102,10.00)",
+ "insert into root.vehicle.d0(timestamp,s2) values(105,11.11)",
+ "insert into root.vehicle.d0(timestamp,s2) values(1000,1000.11)",
+ "insert into root.vehicle.d0(timestamp,s3) values(60,'aaaaa')",
+ "insert into root.vehicle.d0(timestamp,s3) values(70,'bbbbb')",
+ "insert into root.vehicle.d0(timestamp,s3) values(80,'ccccc')",
+ "insert into root.vehicle.d0(timestamp,s3) values(101,'ddddd')",
+ "insert into root.vehicle.d0(timestamp,s3) values(102,'fffff')",
+ "insert into root.vehicle.d0(timestamp,s3) values(2000-01-01T00:00:00+08:00, 'good')",
+ "insert into root.vehicle.d0(timestamp,s4) values(100, false)",
+ "insert into root.vehicle.d0(timestamp,s4) values(100, true)",
+ "insert into root.vehicle.d1(timestamp,s0) values(1,999)",
+ "insert into root.vehicle.d1(timestamp,s0) values(1000,888)",
+ };
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv().initClusterEnvironment();
+ insertData();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+
+ protected static void insertData() {
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TREE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+
+ for (String sql : sqls) {
+ statement.execute(sql);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+
+ for (String sql : createTableViewSqls) {
+ statement.execute(sql);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectTest() {
+ String[] expectedHeader = new String[] {"time", "device_id", "s0", "s1", "s2", "s3", "s4"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d0,101,1101,null,null,null,",
+ "1970-01-01T00:00:00.002Z,d0,10000,40000,2.22,null,null,",
+ "1970-01-01T00:00:00.003Z,d0,null,null,3.33,null,null,",
+ "1970-01-01T00:00:00.004Z,d0,null,null,4.44,null,null,",
+ "1970-01-01T00:00:00.050Z,d0,10000,50000,null,null,null,",
+ "1970-01-01T00:00:00.060Z,d0,null,null,null,aaaaa,null,",
+ "1970-01-01T00:00:00.070Z,d0,null,null,null,bbbbb,null,",
+ "1970-01-01T00:00:00.080Z,d0,null,null,null,ccccc,null,",
+ "1970-01-01T00:00:00.100Z,d0,99,199,null,null,true,",
+ "1970-01-01T00:00:00.101Z,d0,99,199,null,ddddd,null,",
+ "1970-01-01T00:00:00.102Z,d0,80,180,10.0,fffff,null,",
+ "1970-01-01T00:00:00.103Z,d0,99,199,null,null,null,",
+ "1970-01-01T00:00:00.104Z,d0,90,190,null,null,null,",
+ "1970-01-01T00:00:00.105Z,d0,99,199,11.11,null,null,",
+ "1970-01-01T00:00:00.106Z,d0,99,null,null,null,null,",
+ "1970-01-01T00:00:01.000Z,d0,22222,55555,1000.11,null,null,",
+ "1999-12-31T16:00:00.000Z,d0,null,100,null,good,null,",
+ "1970-01-01T00:00:00.001Z,d1,999,null,null,null,null,",
+ "1970-01-01T00:00:01.000Z,d1,888,null,null,null,null,",
+ };
+ tableResultSetEqualTest(
+ "select * from vehicle order by device_id", expectedHeader, retArray, DATABASE_NAME);
+ }
+
+ @Test
+ public void selectTestWithLimitOffset1() {
+
+ String[] expectedHeader = new String[] {"time", "device_id", "s0", "s1", "s2", "s3", "s4"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d1,999,null,null,null,null,",
+ "1970-01-01T00:00:00.002Z,d0,10000,40000,2.22,null,null,",
+ "1970-01-01T00:00:00.003Z,d0,null,null,3.33,null,null,",
+ "1970-01-01T00:00:00.004Z,d0,null,null,4.44,null,null,",
+ "1970-01-01T00:00:00.050Z,d0,10000,50000,null,null,null,",
+ };
+ tableResultSetEqualTest(
+ "select * from vehicle order by time asc, device_id offset 1 limit 5",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void selectTestWithLimitOffset2() {
+
+ String[] expectedHeader = new String[] {"time", "device_id", "s0", "s1", "s2", "s3", "s4"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d1,999,null,null,null,null,",
+ "1999-12-31T16:00:00.000Z,d0,null,100,null,good,null,",
+ "1970-01-01T00:00:01.000Z,d0,22222,55555,1000.11,null,null,",
+ "1970-01-01T00:00:00.106Z,d0,99,null,null,null,null,",
+ "1970-01-01T00:00:00.105Z,d0,99,199,11.11,null,null,",
+ };
+ tableResultSetEqualTest(
+ "select * from vehicle order by device_id desc, time desc offset 1 limit 5",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void selectWithDuplicatedPathsTest() {
+ String[] expectedHeader = new String[] {"time", "device_id", "s0", "s0", "s1"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d0,101,101,1101,",
+ "1970-01-01T00:00:00.002Z,d0,10000,10000,40000,",
+ "1970-01-01T00:00:00.050Z,d0,10000,10000,50000,",
+ "1970-01-01T00:00:00.100Z,d0,99,99,199,",
+ "1970-01-01T00:00:00.101Z,d0,99,99,199,",
+ "1970-01-01T00:00:00.102Z,d0,80,80,180,",
+ "1970-01-01T00:00:00.103Z,d0,99,99,199,",
+ "1970-01-01T00:00:00.104Z,d0,90,90,190,",
+ "1970-01-01T00:00:00.105Z,d0,99,99,199,",
+ "1970-01-01T00:00:00.106Z,d0,99,99,null,",
+ "1970-01-01T00:00:01.000Z,d0,22222,22222,55555,",
+ "1999-12-31T16:00:00.000Z,d0,null,null,100,",
+ "1970-01-01T00:00:00.001Z,d1,999,999,null,",
+ "1970-01-01T00:00:01.000Z,d1,888,888,null,",
+ };
+ tableResultSetEqualTest(
+ "select time, device_id, s0,s0,s1 from vehicle where device_id = 'd0' or device_id = 'd1' order by device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void selectLimitTest() {
+ String[] expectedHeader = new String[] {"time", "device_id", "s0", "s0", "s1"};
+
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.002Z,d0,10000,10000,40000,",
+ "1970-01-01T00:00:00.050Z,d0,10000,10000,50000,",
+ "1970-01-01T00:00:00.100Z,d0,99,99,199,",
+ "1970-01-01T00:00:00.101Z,d0,99,99,199,",
+ "1970-01-01T00:00:00.102Z,d0,80,80,180,",
+ "1970-01-01T00:00:00.103Z,d0,99,99,199,",
+ "1970-01-01T00:00:00.104Z,d0,90,90,190,",
+ "1970-01-01T00:00:00.105Z,d0,99,99,199,",
+ "1970-01-01T00:00:00.106Z,d0,99,99,null,",
+ "1970-01-01T00:00:01.000Z,d0,22222,22222,55555,",
+ };
+ tableResultSetEqualTest(
+ "select time, device_id, s0,s0,s1 from vehicle order by device_id,time offset 1 limit 10",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void selectWithValueFilterTest() {
+
+ String[] expectedHeader = new String[] {"time", "device_id", "s0", "s1", "s2", "s3", "s4"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.100Z,d0,99,199,null,null,true,",
+ "1970-01-01T00:00:00.101Z,d0,99,199,null,ddddd,null,",
+ "1970-01-01T00:00:00.102Z,d0,80,180,10.0,fffff,null,",
+ "1970-01-01T00:00:00.103Z,d0,99,199,null,null,null,",
+ "1970-01-01T00:00:00.104Z,d0,90,190,null,null,null,",
+ "1970-01-01T00:00:00.105Z,d0,99,199,11.11,null,null,",
+ };
+ tableResultSetEqualTest(
+ "select * from vehicle where s0 > 0 AND s1 < 200 order by device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void selectDifferentSeriesWithValueFilterWithoutCacheTest() {
+
+ String[] expectedHeader = new String[] {"time", "device_id", "s0"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.100Z,d0,99,",
+ "1970-01-01T00:00:00.101Z,d0,99,",
+ "1970-01-01T00:00:00.102Z,d0,80,",
+ "1970-01-01T00:00:00.103Z,d0,99,",
+ "1970-01-01T00:00:00.104Z,d0,90,",
+ "1970-01-01T00:00:00.105Z,d0,99,",
+ "1999-12-31T16:00:00.000Z,d0,null,",
+ };
+ tableResultSetEqualTest(
+ "select time, device_id, s0 from vehicle where s1 < 200 order by device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void selectDifferentSeriesWithBinaryValueFilterWithoutCacheTest() {
+
+ String[] expectedHeader = new String[] {"time", "device_id", "s0"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.105Z,d0,99,",
+ };
+ tableResultSetEqualTest(
+ "select time, device_id, s0 from vehicle where s1 < 200 and s2 > 10 order by device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void predicateCannotNormalizedTest() {
+ String[] expectedHeader = new String[] {"time", "device_id", "s0", "s1", "s2"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d0,101,1101,null,",
+ "1970-01-01T00:00:00.002Z,d0,10000,40000,2.22,",
+ "1970-01-01T00:00:00.050Z,d0,10000,50000,null,",
+ "1970-01-01T00:00:00.100Z,d0,99,199,null,",
+ "1970-01-01T00:00:00.101Z,d0,99,199,null,",
+ "1970-01-01T00:00:00.103Z,d0,99,199,null,",
+ "1970-01-01T00:00:00.105Z,d0,99,199,11.11,",
+ "1970-01-01T00:00:01.000Z,d0,22222,55555,1000.11,",
+ };
+ tableResultSetEqualTest(
+ "select time, device_id, s0,s1,s2 from vehicle where (((\"time\" > 10) AND (\"s1\" > 190)) OR (\"s2\" > 190.0) OR ((\"time\" < 4) AND (\"s1\" > 100))) order by device_id, time",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void duplicateProjectionsTest() {
+ String[] expectedHeader = new String[] {"Time", "device_id", "_col2", "_col3", "alias"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d0,1102,1102,1102,",
+ "1970-01-01T00:00:00.002Z,d0,40001,40001,40001,",
+ "1970-01-01T00:00:00.050Z,d0,50001,50001,50001,",
+ "1970-01-01T00:00:00.100Z,d0,200,200,200,",
+ "1970-01-01T00:00:00.101Z,d0,200,200,200,",
+ "1970-01-01T00:00:00.103Z,d0,200,200,200,",
+ "1970-01-01T00:00:00.105Z,d0,200,200,200,",
+ "1970-01-01T00:00:01.000Z,d0,55556,55556,55556,",
+ };
+ tableResultSetEqualTest(
+ "select Time, device_id, s1+1, s1+1, s1+1 as alias from vehicle where (((\"time\" > 10) AND (\"s1\" > 190)) OR (\"s2\" > 190.0) OR ((\"time\" < 4) AND (\"s1\" > 100))) order by device_id, time",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ //
+ // @Test
+ // public void aggregateTest() {
+ // String[] retArray =
+ // new String[] {"root.vehicle.d0,11,11,6,6,1,", "root.vehicle.d1,2,null,null,null,null,"};
+ //
+ // try (Connection connection = EnvFactory.getEnv().getConnection();
+ // Statement statement = connection.createStatement()) {
+ //
+ // try (ResultSet resultSet =
+ // statement.executeQuery(
+ // "select count(s0),count(s1),count(s2),count(s3),count(s4) "
+ // + "from root.vehicle.d1,root.vehicle.d0 align by device")) {
+ // ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ // List<Integer> actualIndexToExpectedIndexList =
+ // checkHeader(
+ // resultSetMetaData,
+ // "Device,count(s0),count(s1),count(s2),count(s3),count(s4)",
+ // new int[] {
+ // Types.VARCHAR,
+ // Types.BIGINT,
+ // Types.BIGINT,
+ // Types.BIGINT,
+ // Types.BIGINT,
+ // Types.BIGINT,
+ // });
+ //
+ // 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 groupBytimeTest() {
+ // String[] retArray =
+ // new String[] {
+ // "2,root.vehicle.d0,1,1,3,0,0,",
+ // "22,root.vehicle.d0,0,0,0,0,0,",
+ // "42,root.vehicle.d0,0,0,0,0,0,",
+ // "2,root.vehicle.d1,0,null,null,null,null,",
+ // "22,root.vehicle.d1,0,null,null,null,null,",
+ // "42,root.vehicle.d1,0,null,null,null,null,"
+ // };
+ //
+ // try (Connection connection = EnvFactory.getEnv().getConnection();
+ // Statement statement = connection.createStatement()) {
+ //
+ // try (ResultSet resultSet =
+ // statement.executeQuery(
+ // "select count(*) from root.vehicle.** GROUP BY ([2,50),20ms) align by device")) {
+ // ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ // List<Integer> actualIndexToExpectedIndexList =
+ // checkHeader(
+ // resultSetMetaData,
+ // "time,Device,count(s0),count(s1),count(s2),count(s3),count(s4)",
+ // new int[] {
+ // Types.tIMESTAMP,
+ // Types.VARCHAR,
+ // Types.BIGINT,
+ // Types.BIGINT,
+ // Types.BIGINT,
+ // Types.BIGINT,
+ // Types.BIGINT,
+ // });
+ //
+ // 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 groupBytimeWithValueFilterTest() {
+ // String[] retArray =
+ // new String[] {
+ // "2,root.vehicle.d0,2,", "102,root.vehicle.d0,1",
+ // };
+ //
+ // try (Connection connection = EnvFactory.getEnv().getConnection();
+ // Statement statement = connection.createStatement()) {
+ //
+ // try (ResultSet resultSet =
+ // statement.executeQuery(
+ // "select count(s2) from root.vehicle.d0 where s2 > 3 and s2 <= 10 GROUP BY
+ // ([2,200),100ms) align by device")) {
+ // ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ // List<Integer> actualIndexToExpectedIndexList =
+ // checkHeader(
+ // resultSetMetaData,
+ // "time,Device,count(s2)",
+ // new int[] {
+ // Types.tIMESTAMP, Types.VARCHAR, Types.BIGINT,
+ // });
+ //
+ // 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 unusualCaseTest2() {
+
+ String[] expectedHeader =
+ new String[] {"s0", "s0", "s1", "time", "device_id", "s0", "s1", "s2", "s3", "s4"};
+ String[] retArray =
+ new String[] {
+ "101,101,1101,1970-01-01T00:00:00.001Z,d0,101,1101,null,null,null,",
+ "10000,10000,40000,1970-01-01T00:00:00.002Z,d0,10000,40000,2.22,null,null,",
+ "null,null,null,1970-01-01T00:00:00.003Z,d0,null,null,3.33,null,null,",
+ "null,null,null,1970-01-01T00:00:00.004Z,d0,null,null,4.44,null,null,",
+ "999,999,null,1970-01-01T00:00:00.001Z,d1,999,null,null,null,null,",
+ };
+ tableResultSetEqualTest(
+ "select s0,s0,s1,* from vehicle where time < 20 and (device_id='d0' or device_id='d1') order by device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void selectWithRegularExpressionTest() {
+ String[] expectedHeader = new String[] {"time", "device_id", "s0", "s1", "s2", "s3", "s4"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d0,101,1101,null,null,null,",
+ "1970-01-01T00:00:00.002Z,d0,10000,40000,2.22,null,null,",
+ "1970-01-01T00:00:00.003Z,d0,null,null,3.33,null,null,",
+ "1970-01-01T00:00:00.004Z,d0,null,null,4.44,null,null,",
+ "1970-01-01T00:00:00.050Z,d0,10000,50000,null,null,null,",
+ "1970-01-01T00:00:00.060Z,d0,null,null,null,aaaaa,null,",
+ "1970-01-01T00:00:00.070Z,d0,null,null,null,bbbbb,null,",
+ "1970-01-01T00:00:00.080Z,d0,null,null,null,ccccc,null,",
+ "1970-01-01T00:00:00.100Z,d0,99,199,null,null,true,",
+ "1970-01-01T00:00:00.101Z,d0,99,199,null,ddddd,null,",
+ "1970-01-01T00:00:00.102Z,d0,80,180,10.0,fffff,null,",
+ "1970-01-01T00:00:00.103Z,d0,99,199,null,null,null,",
+ "1970-01-01T00:00:00.104Z,d0,90,190,null,null,null,",
+ "1970-01-01T00:00:00.105Z,d0,99,199,11.11,null,null,",
+ "1970-01-01T00:00:00.106Z,d0,99,null,null,null,null,",
+ "1970-01-01T00:00:01.000Z,d0,22222,55555,1000.11,null,null,",
+ "1999-12-31T16:00:00.000Z,d0,null,100,null,good,null,",
+ "1970-01-01T00:00:00.001Z,d1,999,null,null,null,null,",
+ "1970-01-01T00:00:01.000Z,d1,888,null,null,null,null,",
+ };
+ tableResultSetEqualTest(
+ "select * from vehicle where device_id like 'd%' order by device_id",
+ expectedHeader, retArray, DATABASE_NAME);
+ }
+
+ @Test
+ public void selectWithNonExistMeasurementInWhereClause() {
+
+ String[] expectedHeader = new String[] {"time", "device_id", "s0", "s1", "s2", "s3", "s4"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d0,101,1101,null,null,null,",
+ };
+ tableResultSetEqualTest(
+ "select * from vehicle where s1=1101 order by device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceWithTemplateTableView2IT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceWithTemplateTableView2IT.java
new file mode 100644
index 00000000000..b422a552b80
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceWithTemplateTableView2IT.java
@@ -0,0 +1,48 @@
+/*
+ * 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.relational.it.query.view.old.alignbydevice;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBAlignByDeviceWithTemplateTableView2IT
+ extends IoTDBAlignByDeviceWithTemplateTableViewIT {
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv().getConfig().getCommonConfig().setSeriesSlotNum(1);
+ EnvFactory.getEnv().initClusterEnvironment();
+ insertData();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceWithTemplateTableViewIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceWithTemplateTableViewIT.java
new file mode 100644
index 00000000000..f089b92e863
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBAlignByDeviceWithTemplateTableViewIT.java
@@ -0,0 +1,543 @@
+/*
+ * 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.relational.it.query.view.old.alignbydevice;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+import org.apache.iotdb.itbase.env.BaseEnv;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import static org.apache.iotdb.db.it.utils.TestUtils.tableAssertTestFail;
+import static org.apache.iotdb.db.it.utils.TestUtils.tableResultSetEqualTest;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBAlignByDeviceWithTemplateTableViewIT {
+
+ private static final String DATABASE_NAME = "db";
+ private static final String[] sqls =
+ new String[] {
+ // non-aligned template
+ "CREATE database root.sg1;",
+ "CREATE schema template t1 (s1 FLOAT encoding=RLE, s2 BOOLEAN encoding=PLAIN compression=SNAPPY, s3 INT32);",
+ "SET SCHEMA TEMPLATE t1 to root.sg1;",
+ "INSERT INTO root.sg1.d1(timestamp,s1,s2,s3) values(1,1.1,false,1), (2,2.2,false,2);",
+ "INSERT INTO root.sg1.d2(timestamp,s1,s2,s3) values(1,11.1,false,11), (2,22.2,false,22);",
+ "INSERT INTO root.sg1.d3(timestamp,s1,s2,s3) values(1,111.1,true,null), (4,444.4,true,44);",
+ "INSERT INTO root.sg1.d4(timestamp,s1,s2,s3) values(1,1111.1,true,1111), (5,5555.5,false,5555);",
+
+ // aligned template
+ "CREATE database root.sg2;",
+ "CREATE schema template t2 aligned (s1 FLOAT encoding=RLE, s2 BOOLEAN encoding=PLAIN compression=SNAPPY, s3 INT32);",
+ "SET SCHEMA TEMPLATE t2 to root.sg2;",
+ "INSERT INTO root.sg2.d1(timestamp,s1,s2,s3) values(1,1.1,false,1), (2,2.2,false,2);",
+ "INSERT INTO root.sg2.d2(timestamp,s1,s2,s3) values(1,11.1,false,11), (2,22.2,false,22);",
+ "INSERT INTO root.sg2.d3(timestamp,s1,s2,s3) values(1,111.1,true,null), (4,444.4,true,44);",
+ "INSERT INTO root.sg2.d4(timestamp,s1,s2,s3) values(1,1111.1,true,1111), (5,5555.5,false,5555);",
+ };
+
+ private static final String[] createTableViewSqls =
+ new String[] {
+ "CREATE database " + DATABASE_NAME,
+ "use " + DATABASE_NAME,
+ "create table view table1(device_id STRING TAG, s1 FLOAT FIELD, s2 BOOLEAN FIELD, s3 INT32 FIELD) as root.sg2.**",
+ };
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv().initClusterEnvironment();
+ insertData();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+
+ @Test
+ public void selectWildcardNoFilterTest() {
+ // 1. order by device_id
+ String[] expectedHeader = new String[] {"time", "device_id", "s3", "s1", "s2"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d1,1,1.1,false,",
+ "1970-01-01T00:00:00.002Z,d1,2,2.2,false,",
+ "1970-01-01T00:00:00.001Z,d2,11,11.1,false,",
+ "1970-01-01T00:00:00.002Z,d2,22,22.2,false,",
+ "1970-01-01T00:00:00.001Z,d3,null,111.1,true,",
+ "1970-01-01T00:00:00.004Z,d3,44,444.4,true,",
+ "1970-01-01T00:00:00.001Z,d4,1111,1111.1,true,",
+ "1970-01-01T00:00:00.005Z,d4,5555,5555.5,false,",
+ };
+ tableResultSetEqualTest(
+ "SELECT time, device_id, s3, s1, s2 FROM table1 order by device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ expectedHeader = new String[] {"time", "device_id", "s1", "s2", "s3", "s1"};
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d1,1.1,false,1,1.1,",
+ "1970-01-01T00:00:00.002Z,d1,2.2,false,2,2.2,",
+ "1970-01-01T00:00:00.001Z,d2,11.1,false,11,11.1,",
+ "1970-01-01T00:00:00.002Z,d2,22.2,false,22,22.2,",
+ "1970-01-01T00:00:00.001Z,d3,111.1,true,null,111.1,",
+ "1970-01-01T00:00:00.004Z,d3,444.4,true,44,444.4,",
+ "1970-01-01T00:00:00.001Z,d4,1111.1,true,1111,1111.1,",
+ "1970-01-01T00:00:00.005Z,d4,5555.5,false,5555,5555.5,",
+ };
+ tableResultSetEqualTest(
+ "SELECT *, s1 FROM table1 order by device_id", expectedHeader, retArray, DATABASE_NAME);
+
+ expectedHeader = new String[] {"time", "device_id", "s1", "s2", "s3"};
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d1,1.1,false,1,",
+ "1970-01-01T00:00:00.002Z,d1,2.2,false,2,",
+ "1970-01-01T00:00:00.001Z,d2,11.1,false,11,",
+ "1970-01-01T00:00:00.002Z,d2,22.2,false,22,",
+ };
+ tableResultSetEqualTest(
+ "SELECT * FROM table1 where device_id = 'd1' or device_id = 'd2' or device_id = 'd6' order by device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ // 2. order by device_id + limit/offset
+ expectedHeader = new String[] {"time", "device_id", "s1", "s2", "s3"};
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.002Z,d1,2.2,false,2,", "1970-01-01T00:00:00.001Z,d2,11.1,false,11,",
+ };
+ tableResultSetEqualTest(
+ "SELECT * FROM table1 order by device_id, time OFFSET 1 LIMIT 2",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ // 3. order by time
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.005Z,d4,5555.5,false,5555,",
+ "1970-01-01T00:00:00.004Z,d3,444.4,true,44,",
+ "1970-01-01T00:00:00.002Z,d1,2.2,false,2,",
+ "1970-01-01T00:00:00.002Z,d2,22.2,false,22,",
+ "1970-01-01T00:00:00.001Z,d1,1.1,false,1,",
+ "1970-01-01T00:00:00.001Z,d2,11.1,false,11,",
+ "1970-01-01T00:00:00.001Z,d3,111.1,true,null,",
+ "1970-01-01T00:00:00.001Z,d4,1111.1,true,1111,",
+ };
+ tableResultSetEqualTest(
+ "SELECT * FROM table1 ORDER BY time DESC, device_id ASC",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ // 4. order by time + limit/offset
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.005Z,d4,5555.5,false,5555,",
+ "1970-01-01T00:00:00.004Z,d3,444.4,true,44,",
+ "1970-01-01T00:00:00.002Z,d1,2.2,false,2,",
+ "1970-01-01T00:00:00.002Z,d2,22.2,false,22,",
+ };
+ tableResultSetEqualTest(
+ "SELECT * FROM table1 ORDER BY time DESC, device_id LIMIT 4",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void selectMeasurementNoFilterTest() {
+ // 1. order by device_id
+ String[] expectedHeader = new String[] {"time", "device_id", "s3", "s1"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d1,1,1.1,",
+ "1970-01-01T00:00:00.002Z,d1,2,2.2,",
+ "1970-01-01T00:00:00.001Z,d2,11,11.1,",
+ "1970-01-01T00:00:00.002Z,d2,22,22.2,",
+ "1970-01-01T00:00:00.001Z,d3,null,111.1,",
+ "1970-01-01T00:00:00.004Z,d3,44,444.4,",
+ "1970-01-01T00:00:00.001Z,d4,1111,1111.1,",
+ "1970-01-01T00:00:00.005Z,d4,5555,5555.5,",
+ };
+ tableResultSetEqualTest(
+ "SELECT time, device_id, s3, s1 FROM table1 order by device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT)) {
+ try (Statement statement = connection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ try (ResultSet resultSet =
+ statement.executeQuery("SELECT s3,s1,s_null FROM table1 order by device_id")) {
+ fail("should throw exception to indicate that s_null doesn't exist");
+ } catch (SQLException e) {
+ assertEquals("616: Column 's_null' cannot be resolved", e.getMessage());
+ }
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+
+ // 2. order by device + limit/offset
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.002Z,d1,2,2.2,", "1970-01-01T00:00:00.001Z,d2,11,11.1,",
+ };
+ tableResultSetEqualTest(
+ "SELECT time, device_id, s3,s1 FROM table1 order by device_id,time OFFSET 1 LIMIT 2",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ // 3. order by time
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.005Z,d4,5555,5555.5,",
+ "1970-01-01T00:00:00.004Z,d3,44,444.4,",
+ "1970-01-01T00:00:00.002Z,d1,2,2.2,",
+ "1970-01-01T00:00:00.002Z,d2,22,22.2,",
+ "1970-01-01T00:00:00.001Z,d1,1,1.1,",
+ "1970-01-01T00:00:00.001Z,d2,11,11.1,",
+ "1970-01-01T00:00:00.001Z,d3,null,111.1,",
+ "1970-01-01T00:00:00.001Z,d4,1111,1111.1,",
+ };
+ tableResultSetEqualTest(
+ "SELECT time, device_id, s3,s1 FROM table1 ORDER BY TIME DESC, device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ // 4. order by time + limit/offset
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.005Z,d4,5555,5555.5,",
+ "1970-01-01T00:00:00.004Z,d3,44,444.4,",
+ "1970-01-01T00:00:00.002Z,d1,2,2.2,",
+ "1970-01-01T00:00:00.002Z,d2,22,22.2,",
+ };
+ tableResultSetEqualTest(
+ "SELECT time, device_id, s3,s1 FROM table1 ORDER BY time DESC, device_id LIMIT 4",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void selectWildcardWithFilterOrderByTimeTest() {
+ // 1. order by time + time filter
+ String[] expectedHeader = new String[] {"time", "device_id", "s1", "s2", "s3"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.004Z,d3,444.4,true,44,",
+ "1970-01-01T00:00:00.002Z,d1,2.2,false,2,",
+ "1970-01-01T00:00:00.002Z,d2,22.2,false,22,",
+ "1970-01-01T00:00:00.001Z,d1,1.1,false,1,",
+ };
+ tableResultSetEqualTest(
+ "SELECT * FROM table1 WHERE time < 5 ORDER BY TIME desc, device_id LIMIT 4",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ // 2. order by time + time filter + value filter
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.004Z,d3,444.4,true,44,",
+ "1970-01-01T00:00:00.002Z,d2,22.2,false,22,",
+ };
+ tableResultSetEqualTest(
+ "SELECT * FROM table1 where time > 1 and time < 5 and s3>=11 and s3<=1111 and s1 != 11.1 "
+ + "ORDER BY time DESC, device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ // 3. order by time + value filter: s_null > 1
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT)) {
+ try (Statement statement = connection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ try (ResultSet resultSet =
+ statement.executeQuery("SELECT * FROM table1 WHERE s_null > 1 order by device_id")) {
+ fail("should throw exception to indicate that s_null doesn't exist");
+ } catch (SQLException e) {
+ assertEquals("616: Column 's_null' cannot be resolved", e.getMessage());
+ }
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectWildcardWithFilterOrderByDeviceTest() {
+ // 1. order by device + time filter
+ String[] expectedHeader = new String[] {"time", "device_id", "s1", "s2", "s3"};
+
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d4,1111.1,true,1111,",
+ "1970-01-01T00:00:00.001Z,d3,111.1,true,null,",
+ "1970-01-01T00:00:00.004Z,d3,444.4,true,44,",
+ "1970-01-01T00:00:00.001Z,d2,11.1,false,11,",
+ };
+ tableResultSetEqualTest(
+ "SELECT * FROM table1 WHERE time < 5 ORDER BY device_id DESC, time LIMIT 4",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ // 2. order by device + time filter + value filter
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.004Z,d3,444.4,true,44,",
+ "1970-01-01T00:00:00.002Z,d2,22.2,false,22,",
+ };
+ tableResultSetEqualTest(
+ "SELECT * FROM table1 where time > 1 and time < 5 and s3>=11 and s3<=1111 and s1 != 11.1 "
+ + "ORDER BY device_id DESC",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void selectMeasurementWithFilterOrderByTimeTest() {
+ // 1. order by time + time filter
+ String[] expectedHeader = new String[] {"time", "device_id", "s3", "s2"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.004Z,d3,44,true,",
+ "1970-01-01T00:00:00.002Z,d1,2,false,",
+ "1970-01-01T00:00:00.002Z,d2,22,false,",
+ "1970-01-01T00:00:00.001Z,d1,1,false,",
+ };
+ tableResultSetEqualTest(
+ "SELECT time, device_id, s3, s2 FROM table1 WHERE time < 5 ORDER BY time DESC, device_id LIMIT 4",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ // 2. order by time + time filter + value filter
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.004Z,d3,44,true,", "1970-01-01T00:00:00.002Z,d2,22,false,",
+ };
+ tableResultSetEqualTest(
+ "SELECT time, device_id, s3,s2 FROM table1 where time > 1 and time < 5 and s3>=11 and s3<=1111 and s1 != 11.1 "
+ + "ORDER BY time DESC, device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void selectMeasurementWithFilterOrderByDeviceTest() {
+ // 1. order by device + time filter
+ String[] expectedHeader = new String[] {"time", "device_id", "s3", "s2"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d4,1111,true,",
+ "1970-01-01T00:00:00.001Z,d3,null,true,",
+ "1970-01-01T00:00:00.004Z,d3,44,true,",
+ "1970-01-01T00:00:00.001Z,d2,11,false,",
+ };
+ tableResultSetEqualTest(
+ "SELECT time, device_id, s3,s2 FROM table1 WHERE time < 5 ORDER BY device_id DESC, time LIMIT 4",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ // 2. order by device + time filter + value filter
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.004Z,d3,44,true,", "1970-01-01T00:00:00.002Z,d2,22,false,",
+ };
+ tableResultSetEqualTest(
+ "SELECT time, device_id, s3,s2 FROM table1 where time > 1 and time < 5 and s3>=11 and s3<=1111 and s1 != 11.1 "
+ + "ORDER BY device_id DESC, time asc",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void aliasTest() {
+ String[] expectedHeader = new String[] {"aa", "bb", "s3", "s2", "time", "device_id"};
+
+ String[] retArray =
+ new String[] {
+ "1.1,false,1,false,1970-01-01T00:00:00.001Z,d1,",
+ "2.2,false,2,false,1970-01-01T00:00:00.002Z,d1,",
+ "11.1,false,11,false,1970-01-01T00:00:00.001Z,d2,",
+ "22.2,false,22,false,1970-01-01T00:00:00.002Z,d2,",
+ "111.1,true,null,true,1970-01-01T00:00:00.001Z,d3,",
+ "444.4,true,44,true,1970-01-01T00:00:00.004Z,d3,",
+ "1111.1,true,1111,true,1970-01-01T00:00:00.001Z,d4,",
+ "5555.5,false,5555,false,1970-01-01T00:00:00.005Z,d4,",
+ };
+ tableResultSetEqualTest(
+ "SELECT s1 as aa, s2 as bb, s3, s2, time, device_id FROM table1 order by device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ expectedHeader = new String[] {"time", "device_id", "a", "b"};
+
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.001Z,d1,1.1,1.1,",
+ "1970-01-01T00:00:00.002Z,d1,2.2,2.2,",
+ "1970-01-01T00:00:00.001Z,d2,11.1,11.1,",
+ "1970-01-01T00:00:00.002Z,d2,22.2,22.2,",
+ "1970-01-01T00:00:00.001Z,d3,111.1,111.1,",
+ "1970-01-01T00:00:00.004Z,d3,444.4,444.4,",
+ "1970-01-01T00:00:00.001Z,d4,1111.1,1111.1,",
+ "1970-01-01T00:00:00.005Z,d4,5555.5,5555.5,",
+ };
+ tableResultSetEqualTest(
+ "SELECT time, device_id, s1 as a, s1 as b FROM table1 order by device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void orderByExpressionTest() {
+ // 1. order by basic measurement
+ String[] expectedHeader = new String[] {"time", "device_id", "s3", "s1", "s2"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.005Z,d4,5555,5555.5,false,",
+ "1970-01-01T00:00:00.002Z,d2,22,22.2,false,",
+ "1970-01-01T00:00:00.001Z,d2,11,11.1,false,",
+ "1970-01-01T00:00:00.002Z,d1,2,2.2,false,",
+ "1970-01-01T00:00:00.001Z,d1,1,1.1,false,",
+ "1970-01-01T00:00:00.001Z,d4,1111,1111.1,true,",
+ "1970-01-01T00:00:00.004Z,d3,44,444.4,true,",
+ "1970-01-01T00:00:00.001Z,d3,null,111.1,true,",
+ };
+ tableResultSetEqualTest(
+ "SELECT time, device_id, s3, s1, s2 FROM table1 order by s2 asc, s1 desc, device_id",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ // 2. select measurement is different with order by measurement
+ expectedHeader = new String[] {"time", "device_id", "s3"};
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.005Z,d4,5555,",
+ "1970-01-01T00:00:00.002Z,d2,22,",
+ "1970-01-01T00:00:00.001Z,d2,11,",
+ "1970-01-01T00:00:00.002Z,d1,2,",
+ "1970-01-01T00:00:00.001Z,d1,1,",
+ "1970-01-01T00:00:00.001Z,d4,1111,",
+ "1970-01-01T00:00:00.004Z,d3,44,",
+ "1970-01-01T00:00:00.001Z,d3,null,",
+ };
+ tableResultSetEqualTest(
+ "SELECT time, device_id, s3 FROM table1 order by s2 asc, s1 desc",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ // 3. order by expression
+ retArray =
+ new String[] {
+ "1970-01-01T00:00:00.005Z,d4,5555,",
+ "1970-01-01T00:00:00.001Z,d4,1111,",
+ "1970-01-01T00:00:00.004Z,d3,44,",
+ "1970-01-01T00:00:00.002Z,d2,22,",
+ "1970-01-01T00:00:00.001Z,d2,11,",
+ "1970-01-01T00:00:00.002Z,d1,2,",
+ "1970-01-01T00:00:00.001Z,d1,1,",
+ "1970-01-01T00:00:00.001Z,d3,null,",
+ };
+ tableResultSetEqualTest(
+ "SELECT time, device_id, s3 FROM table1 order by s1+s3 desc",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void templateInvalidTest() {
+
+ tableAssertTestFail(
+ "select s1 from table1 where s1",
+ "701: WHERE clause must evaluate to a boolean: actual type FLOAT",
+ DATABASE_NAME);
+ }
+
+ @Test
+ public void emptyResultTest() {
+ String[] expectedHeader = new String[] {"time", "device_id", "s1", "s2", "s3"};
+
+ String[] retArray = new String[] {};
+ tableResultSetEqualTest(
+ "SELECT * FROM table1 where time>=now()-1d and time<=now() " + "ORDER BY time DESC",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ protected static void insertData() {
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TREE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+
+ for (String sql : sqls) {
+ statement.execute(sql);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+
+ for (String sql : createTableViewSqls) {
+ statement.execute(sql);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByLimitOffsetAlignByDeviceTableView2IT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByLimitOffsetAlignByDeviceTableView2IT.java
new file mode 100644
index 00000000000..dcecb8918ec
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByLimitOffsetAlignByDeviceTableView2IT.java
@@ -0,0 +1,48 @@
+/*
+ * 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.relational.it.query.view.old.alignbydevice;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBOrderByLimitOffsetAlignByDeviceTableView2IT
+ extends IoTDBOrderByLimitOffsetAlignByDeviceTableViewIT {
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv().getConfig().getCommonConfig().setSeriesSlotNum(1);
+ EnvFactory.getEnv().initClusterEnvironment();
+ insertData3();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByLimitOffsetAlignByDeviceTableViewIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByLimitOffsetAlignByDeviceTableViewIT.java
new file mode 100644
index 00000000000..bdbacb63be7
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByLimitOffsetAlignByDeviceTableViewIT.java
@@ -0,0 +1,170 @@
+/*
+ * 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.relational.it.query.view.old.alignbydevice;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+import org.apache.iotdb.itbase.env.BaseEnv;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.Statement;
+
+import static org.apache.iotdb.db.it.utils.TestUtils.tableResultSetEqualTest;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBOrderByLimitOffsetAlignByDeviceTableViewIT {
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv().initClusterEnvironment();
+ insertData3();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+
+ @Test
+ public void orderByCanNotPushLimitTest() {
+ // 1. value filter, can not push down LIMIT
+ String[] expectedHeader = new String[] {"time", "device_id", "s1"};
+ String[] retArray = new String[] {"1970-01-01T00:00:00.003Z,d1,111,"};
+ tableResultSetEqualTest(
+ "SELECT * FROM table1 WHERE s1>40 ORDER BY Time, device_id LIMIT 1",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ // 2. order by expression, can not push down LIMIT
+ retArray = new String[] {"1970-01-01T00:00:00.003Z,d3,333,"};
+ tableResultSetEqualTest(
+ "SELECT * FROM table1 ORDER BY s1 DESC LIMIT 1", expectedHeader, retArray, DATABASE_NAME);
+
+ // 3. time filter, can push down LIMIT
+ retArray = new String[] {"1970-01-01T00:00:00.002Z,d3,33,", "1970-01-01T00:00:00.002Z,d2,22,"};
+ tableResultSetEqualTest(
+ "SELECT * FROM table1 WHERE time>1 and time<3 ORDER BY device_id DESC,time LIMIT 2",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+
+ // 4. both exist OFFSET and LIMIT, can push down LIMIT as OFFSET+LIMIT
+ retArray = new String[] {"1970-01-01T00:00:00.003Z,d2,222,"};
+ tableResultSetEqualTest(
+ "SELECT * FROM table1 ORDER BY Time DESC, device_id OFFSET 1 LIMIT 1",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+
+ //
+ // @Test
+ // public void aggregationWithHavingTest() {
+ // // when aggregation with having, can only use MergeSortNode but not use TopKNode
+ // String[] expectedHeader = new String[] {"Time,Device,sum(s1)"};
+ // String[] retArray = new String[] {"3,root.db.d2,222.0,", "3,root.db.d3,333.0,"};
+ // resultSetEqualTest(
+ // "select sum(s1) from root.db.** group by ((1,5],1ms) having(sum(s1)>111) order by time
+ // limit 2 align by device",
+ // expectedHeader,
+ // retArray);
+ // }
+ //
+ // @Test
+ // public void fillTest() {
+ // // linear fill can not use TopKNode
+ // String[] expectedHeader = new String[] {"Time,Device,s1,s2"};
+ // String[] retArray =
+ // new String[] {
+ // "1,root.fill.d1,1,null,",
+ // "1,root.fill.d2,2,null,",
+ // "1,root.fill.d3,3,null,",
+ // "2,root.fill.d1,22,11.0,",
+ // };
+ // resultSetEqualTest(
+ // "select * from root.fill.** order by time fill(linear) limit 4 align by device",
+ // expectedHeader,
+ // retArray);
+ // }
+
+ private static final String DATABASE_NAME = "db";
+
+ private static final String DATABASE_FILL_NAME = "fill1";
+
+ private static final String[] SQL_LIST =
+ new String[] {
+ "CREATE DATABASE root.db;",
+ "CREATE TIMESERIES root.db.d1.s1 WITH DATATYPE=INT32, ENCODING=RLE;",
+ "CREATE TIMESERIES root.db.d2.s1 WITH DATATYPE=INT32, ENCODING=RLE;",
+ "CREATE TIMESERIES root.db.d3.s1 WITH DATATYPE=INT32, ENCODING=RLE;",
+ "INSERT INTO root.db.d1(timestamp,s1) VALUES(1, 1), (2, 11), (3, 111);",
+ "INSERT INTO root.db.d2(timestamp,s1) VALUES(1, 2), (2, 22), (3, 222);",
+ "INSERT INTO root.db.d3(timestamp,s1) VALUES(1, 3), (2, 33), (3, 333);",
+ "CREATE DATABASE root.fill1;",
+ "CREATE TIMESERIES root.fill1.d1.s1 WITH DATATYPE=INT32, ENCODING=RLE;",
+ "CREATE TIMESERIES root.fill1.d1.s2 WITH DATATYPE=FLOAT, ENCODING=RLE;",
+ "CREATE TIMESERIES root.fill1.d2.s1 WITH DATATYPE=INT32, ENCODING=RLE;",
+ "CREATE TIMESERIES root.fill1.d2.s2 WITH DATATYPE=FLOAT, ENCODING=RLE;",
+ "CREATE TIMESERIES root.fill1.d3.s1 WITH DATATYPE=INT32, ENCODING=RLE;",
+ "CREATE TIMESERIES root.fill1.d3.s2 WITH DATATYPE=FLOAT, ENCODING=RLE;",
+ "INSERT INTO root.fill1.d1(timestamp,s1,s2) VALUES(1, 1, null), (2, null, 11), (3, 111, 111.1);",
+ "INSERT INTO root.fill1.d2(timestamp,s1,s2) VALUES(1, 2, null), (2, 22, 22.2), (3, 222, null);",
+ "INSERT INTO root.fill1.d3(timestamp,s1,s2) VALUES(1, 3, null), (2, 33, null), (3, 333, 333.3);",
+ };
+
+ private static final String[] CREATE_TABLE_VIEW_SQL_LIST =
+ new String[] {
+ "CREATE DATABASE " + DATABASE_NAME,
+ "USE " + DATABASE_NAME,
+ "create table view table1(device_id STRING TAG, s1 INT32 FIELD) as root.db.**",
+ "CREATE DATABASE " + DATABASE_FILL_NAME,
+ "USE " + DATABASE_FILL_NAME,
+ "create table view table1(device_id STRING TAG, s1 INT32 FIELD, s2 FLOAT FIELD) as root.fill1.**",
+ };
+
+ protected static void insertData3() {
+ try (Connection iotDBConnection = EnvFactory.getEnv().getConnection(BaseEnv.TREE_SQL_DIALECT);
+ Statement statement = iotDBConnection.createStatement()) {
+ for (String sql : SQL_LIST) {
+ statement.execute(sql);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ try (Connection iotDBConnection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = iotDBConnection.createStatement()) {
+ for (String sql : CREATE_TABLE_VIEW_SQL_LIST) {
+ statement.execute(sql);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByWithAlignByDeviceTableView2IT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByWithAlignByDeviceTableView2IT.java
new file mode 100644
index 00000000000..399a7ab7b74
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByWithAlignByDeviceTableView2IT.java
@@ -0,0 +1,48 @@
+/*
+ * 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.relational.it.query.view.old.alignbydevice;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBOrderByWithAlignByDeviceTableView2IT
+ extends IoTDBOrderByWithAlignByDeviceTableViewIT {
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv().getConfig().getCommonConfig().setDegreeOfParallelism(4);
+ EnvFactory.getEnv().initClusterEnvironment();
+ insertData();
+ insertData2();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByWithAlignByDeviceTableView3IT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByWithAlignByDeviceTableView3IT.java
new file mode 100644
index 00000000000..f3c016f7d6a
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByWithAlignByDeviceTableView3IT.java
@@ -0,0 +1,48 @@
+/*
+ * 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.relational.it.query.view.old.alignbydevice;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBOrderByWithAlignByDeviceTableView3IT
+ extends IoTDBOrderByWithAlignByDeviceTableViewIT {
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv().getConfig().getCommonConfig().setSeriesSlotNum(1);
+ EnvFactory.getEnv().initClusterEnvironment();
+ insertData();
+ insertData2();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByWithAlignByDeviceTableViewIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByWithAlignByDeviceTableViewIT.java
new file mode 100644
index 00000000000..0d8df207c3f
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/alignbydevice/IoTDBOrderByWithAlignByDeviceTableViewIT.java
@@ -0,0 +1,1588 @@
+/*
+ * 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.relational.it.query.view.old.alignbydevice;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+import org.apache.iotdb.itbase.env.BaseEnv;
+import org.apache.iotdb.rpc.RpcUtils;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.apache.iotdb.db.it.utils.TestUtils.DEFAULT_ZONE_ID;
+import static org.apache.iotdb.db.it.utils.TestUtils.TIME_PRECISION_IN_MS;
+import static org.apache.iotdb.db.it.utils.TestUtils.tableResultSetEqualTest;
+import static org.apache.iotdb.rpc.RpcUtils.DEFAULT_TIME_FORMAT;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBOrderByWithAlignByDeviceTableViewIT {
+ protected static final String DATABASE_NAME = "db";
+ protected static final String[] places =
+ new String[] {
+ "London",
+ "Edinburgh",
+ "Belfast",
+ "Birmingham",
+ "Liverpool",
+ "Derby",
+ "Durham",
+ "Hereford",
+ "Manchester",
+ "Oxford"
+ };
+ protected static final long startPrecipitation = 200;
+ protected static final double startTemperature = 20.0;
+ protected static final long startTime = 1668960000000L;
+ protected static final int numOfPointsInDevice = 20;
+ protected static final long timeGap = 100L;
+ protected static final Map<String, Long> deviceToStartTimestamp = new HashMap<>();
+ public static final Map<String, double[]> deviceToMaxTemperature = new HashMap<>();
+ public static final Map<String, double[]> deviceToAvgTemperature = new HashMap<>();
+ public static final Map<String, long[]> deviceToMaxPrecipitation = new HashMap<>();
+ public static final Map<String, double[]> deviceToAvgPrecipitation = new HashMap<>();
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv().initClusterEnvironment();
+ insertData();
+ insertData2();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+
+ /**
+ * This method generate test data with crossing time.
+ *
+ * <p>The data can be viewed in online doc:
+ *
+ * <p>https://docs.google.com/spreadsheets/d/18XlOIi27ZIIdRnar2WNXVMxkZwjgwlPZmzJLVpZRpAA/edit#gid=0
+ */
+ protected static void insertData() {
+ try (Connection iotDBConnection = EnvFactory.getEnv().getConnection(BaseEnv.TREE_SQL_DIALECT);
+ Statement statement = iotDBConnection.createStatement()) {
+ // create TimeSeries
+ String prefix = "root.weather.";
+ for (String place : places) {
+ String PRE_PRECIPITATION = prefix + place + ".precipitation";
+ String PRE_TEMPERATURE = prefix + place + ".temperature";
+ String createPrecipitationSql =
+ "CREATE TIMESERIES " + PRE_PRECIPITATION + " WITH DATATYPE=INT64, ENCODING=RLE";
+ String createTemperatureSql =
+ "CREATE TIMESERIES " + PRE_TEMPERATURE + " WITH DATATYPE=DOUBLE, ENCODING=RLE";
+ statement.execute(createPrecipitationSql);
+ statement.execute(createTemperatureSql);
+ }
+ // insert data
+ long start = startTime;
+ double[][] temperatures = new double[places.length][29];
+ long[][] precipitations = new long[places.length][29];
+ for (int index = 0; index < places.length; index++) {
+ String place = places[index];
+
+ for (int i = 0; i < numOfPointsInDevice; i++) {
+ long precipitation = startPrecipitation + place.hashCode() + (start + i * timeGap);
+ double temperature = startTemperature + place.hashCode() + (start + i * timeGap);
+ precipitations[index][(int) ((start - startTime) / timeGap) + i] = precipitation;
+ temperatures[index][(int) ((start - startTime) / timeGap) + i] = temperature;
+ String insertUniqueTime =
+ "INSERT INTO "
+ + prefix
+ + place
+ + "(timestamp,precipitation,temperature) VALUES("
+ + (start + i * timeGap)
+ + ","
+ + precipitation
+ + ","
+ + temperature
+ + ")";
+ statement.execute(insertUniqueTime);
+ if (i == 0) deviceToStartTimestamp.put(place, start);
+ }
+ start += timeGap;
+ }
+
+ for (int i = 0; i < places.length; i++) {
+ double[] aT = new double[3];
+ double[] aP = new double[3];
+ double[] mT = new double[3];
+ long[] mP = new long[3];
+ double totalTemperature = 0;
+ long totalPrecipitation = 0;
+ double maxTemperature = -1;
+ long maxPrecipitation = -1;
+ int cnt = 0;
+ for (int j = 0; j < precipitations[i].length; j++) {
+ totalTemperature += temperatures[i][j];
+ totalPrecipitation += precipitations[i][j];
+ maxPrecipitation = Math.max(maxPrecipitation, precipitations[i][j]);
+ maxTemperature = Math.max(maxTemperature, temperatures[i][j]);
+ if ((j + 1) % 10 == 0 || j == precipitations[i].length - 1) {
+ aT[cnt] = totalTemperature / 10;
+ aP[cnt] = (double) totalPrecipitation / 10;
+ mP[cnt] = maxPrecipitation;
+ mT[cnt] = maxTemperature;
+ cnt++;
+ totalTemperature = 0;
+ totalPrecipitation = 0;
+ maxTemperature = -1;
+ maxPrecipitation = -1;
+ }
+ }
+ deviceToMaxTemperature.put(places[i], mT);
+ deviceToMaxPrecipitation.put(places[i], mP);
+ deviceToAvgTemperature.put(places[i], aT);
+ deviceToAvgPrecipitation.put(places[i], aP);
+ }
+
+ for (String sql : optimizedSQL) {
+ statement.execute(sql);
+ }
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ try (Connection iotDBConnection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = iotDBConnection.createStatement()) {
+ statement.execute("create database " + DATABASE_NAME);
+ statement.execute("use " + DATABASE_NAME);
+
+ statement.execute(
+ "create table view weather(city STRING TAG, precipitation INT64 FIELD, temperature DOUBLE FIELD) as root.weather.**");
+
+ statement.execute(
+ "create table view optimize(plant_id STRING TAG, device_id STRING TAG, temperature DOUBLE FIELD, status BOOLEAN FIELD, hardware STRING FIELD) as root.ln.**");
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ // use to test if the compare result of time will overflow.
+ protected static void insertData2() {
+ try (Connection iotDBConnection = EnvFactory.getEnv().getConnection(BaseEnv.TREE_SQL_DIALECT);
+ Statement statement = iotDBConnection.createStatement()) {
+ long startTime = 1;
+ String createSql = "CREATE TIMESERIES root.overflow.value WITH DATATYPE=INT32, ENCODING=RLE";
+ statement.execute(createSql);
+ for (int i = 0; i < 20; i++) {
+ String insertTime =
+ "INSERT INTO "
+ + "root.overflow"
+ + "(timestamp,value) VALUES("
+ + (startTime + 2147483648L)
+ + ","
+ + i
+ + ")";
+ statement.execute(insertTime);
+ startTime += 2147483648L;
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ try (Connection iotDBConnection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = iotDBConnection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ statement.execute(
+ "create table view overflow(device_id STRING TAG, value INT32 FIELD) as root.overflow.**");
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ @Test
+ public void overFlowTest() {
+
+ String[] expectedHeader = new String[] {"time", "value"};
+ String[] retArray = new String[20];
+
+ long startTime = 1;
+ for (int i = 0; i < 20; i++) {
+ long time = startTime + 2147483648L;
+ retArray[i] =
+ String.format(
+ "%s,%d,",
+ RpcUtils.formatDatetime(
+ DEFAULT_TIME_FORMAT, TIME_PRECISION_IN_MS, time, DEFAULT_ZONE_ID),
+ i);
+ startTime += 2147483648L;
+ }
+
+ tableResultSetEqualTest(
+ "SELECT time, value FROM overflow", expectedHeader, retArray, DATABASE_NAME);
+ }
+
+ // ORDER BY DEVICE
+ @Test
+ public void orderByDeviceTest1() {
+
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+
+ String[] expectedDevice = Arrays.stream(places.clone()).sorted().toArray(String[]::new);
+
+ int index = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+ try (ResultSet resultSet = statement.executeQuery("SELECT * FROM weather order by city")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+
+ int cnt = 0;
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ String actualDevice = resultSet.getString(2);
+ assertEquals(expectedDevice[index], actualDevice);
+ assertEquals(deviceToStartTimestamp.get(actualDevice) + cnt * timeGap, actualTimeStamp);
+
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ startTemperature + actualDevice.hashCode() + actualTimeStamp - actualTemperature
+ < 0.00001);
+
+ cnt++;
+ if (cnt % numOfPointsInDevice == 0) {
+ index++;
+ cnt = 0;
+ }
+ }
+ assertEquals(10, index);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void orderByDeviceTest2() {
+
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+
+ String[] expectedDevice = Arrays.stream(places.clone()).sorted().toArray(String[]::new);
+
+ int index = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+
+ try (ResultSet resultSet =
+ statement.executeQuery("SELECT * FROM weather order by city asc")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+
+ int cnt = 0;
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ String actualDevice = resultSet.getString(2);
+ assertEquals(expectedDevice[index], actualDevice);
+ assertEquals(deviceToStartTimestamp.get(actualDevice) + cnt * timeGap, actualTimeStamp);
+
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ startTemperature + actualDevice.hashCode() + actualTimeStamp - actualTemperature
+ < 0.00001);
+
+ cnt++;
+ if (cnt % numOfPointsInDevice == 0) {
+ index++;
+ cnt = 0;
+ }
+ }
+ assertEquals(10, index);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void orderByDeviceTest3() {
+
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+
+ String[] expectedDevice =
+ Arrays.stream(places.clone()).sorted(Comparator.reverseOrder()).toArray(String[]::new);
+
+ int index = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("USE " + DATABASE_NAME);
+
+ try (ResultSet resultSet =
+ statement.executeQuery("SELECT * FROM weather order by city desc")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+
+ int cnt = 0;
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ String actualDevice = resultSet.getString(2);
+ assertEquals(expectedDevice[index], actualDevice);
+ assertEquals(deviceToStartTimestamp.get(actualDevice) + cnt * timeGap, actualTimeStamp);
+
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ startTemperature + actualDevice.hashCode() + actualTimeStamp - actualTemperature
+ < 0.00001);
+
+ cnt++;
+ if (cnt % numOfPointsInDevice == 0) {
+ index++;
+ cnt = 0;
+ }
+ }
+ assertEquals(10, index);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ // ORDER BY TIME
+
+ @Test
+ public void orderByTimeTest1() {
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+
+ orderByTimeTest1(
+ "SELECT * FROM weather ORDER BY time, city",
+ numOfPointsInDevice * places.length,
+ expectedHeader);
+
+ orderByTimeTest1("SELECT * FROM weather ORDER BY time, city LIMIT 100", 100, expectedHeader);
+ }
+
+ @Test
+ public void orderByTimeTest2() {
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+ orderByTimeTest1(
+ "SELECT * FROM weather ORDER BY TIME ASC, city",
+ numOfPointsInDevice * places.length,
+ expectedHeader);
+
+ orderByTimeTest1(
+ "SELECT * FROM weather ORDER BY time ASC, city ASC LIMIT 100", 100, expectedHeader);
+ }
+
+ @Test
+ public void orderByTimeTest3() {
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+ orderByTimeTest3(
+ "SELECT * FROM weather ORDER BY time DESC, city ASC",
+ numOfPointsInDevice * places.length,
+ expectedHeader);
+
+ orderByTimeTest3(
+ "SELECT * FROM weather ORDER BY time DESC, city LIMIT 100", 100, expectedHeader);
+ }
+
+ @Test
+ public void orderByTimeExpressionTest1() {
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+
+ orderByTimeExpressionTest1(
+ "SELECT * FROM weather ORDER BY time DESC, precipitation DESC, city",
+ numOfPointsInDevice * places.length,
+ expectedHeader);
+
+ orderByTimeExpressionTest1(
+ "SELECT * FROM weather ORDER BY time DESC, precipitation DESC, city asc LIMIT 100",
+ 100,
+ expectedHeader);
+ }
+
+ @Test
+ public void orderExpressionTest1() {
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+
+ orderByExpressionTest1(
+ "SELECT * FROM weather ORDER BY precipitation DESC, time DESC, city asc",
+ numOfPointsInDevice * places.length,
+ expectedHeader);
+
+ orderByExpressionTest1(
+ "SELECT * FROM weather ORDER BY precipitation DESC, time DESC, city limit 100",
+ 100,
+ expectedHeader);
+ }
+
+ @Test
+ public void orderByDeviceTimeTest1() {
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+
+ orderByDeviceTimeTest1("SELECT * FROM weather ORDER BY city ASC,time DESC", 10, expectedHeader);
+
+ orderByDeviceTimeTest1(
+ "SELECT * FROM weather ORDER BY city ASC,time DESC LIMIT 100", 5, expectedHeader);
+ }
+
+ @Test
+ public void orderByDeviceTimeTest2() {
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+
+ orderByDeviceTimeTest2("SELECT * FROM weather ORDER BY city ASC,time ASC", 10, expectedHeader);
+
+ orderByDeviceTimeTest2(
+ "SELECT * FROM weather ORDER BY city ASC,Time ASC LIMIT 100", 5, expectedHeader);
+ }
+
+ @Test
+ public void orderByDeviceTimeTest3() {
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+
+ orderByDeviceTimeTest3(
+ "SELECT * FROM weather ORDER BY city DESC,time DESC", 10, expectedHeader);
+
+ orderByDeviceTimeTest3(
+ "SELECT * FROM weather ORDER BY city DESC,time DESC LIMIT 100", 5, expectedHeader);
+ }
+
+ @Test
+ public void orderByDeviceTimeTest4() {
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+
+ orderByDeviceTimeTest4("SELECT * FROM weather ORDER BY city DESC,time ASC", 10, expectedHeader);
+
+ orderByDeviceTimeTest4(
+ "SELECT * FROM weather ORDER BY city DESC,time ASC LIMIT 100", 5, expectedHeader);
+ }
+
+ @Test
+ public void orderByTimeDeviceTest1() {
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+
+ orderByTimeDeviceTest1(
+ "SELECT * FROM weather ORDER BY time ASC,city DESC",
+ numOfPointsInDevice * places.length,
+ expectedHeader);
+
+ orderByTimeDeviceTest1(
+ "SELECT * FROM weather ORDER BY time ASC,city DESC LIMIT 100", 100, expectedHeader);
+ }
+
+ @Test
+ public void orderByTimeDeviceTest2() {
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+
+ orderByTimeDeviceTest2(
+ "SELECT * FROM weather ORDER BY time ASC,city ASC",
+ numOfPointsInDevice * places.length,
+ expectedHeader);
+
+ orderByTimeDeviceTest2(
+ "SELECT * FROM weather ORDER BY time ASC,city ASC LIMIT 100", 100, expectedHeader);
+ }
+
+ @Test
+ public void orderByTimeDeviceTest3() {
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+
+ orderByTimeDeviceTest3(
+ "SELECT * FROM weather ORDER BY time DESC,city DESC",
+ numOfPointsInDevice * places.length,
+ expectedHeader);
+
+ orderByTimeDeviceTest3(
+ "SELECT * FROM weather ORDER BY time DESC,city DESC LIMIT 100", 100, expectedHeader);
+ }
+
+ @Test
+ public void orderByTimeDeviceTest4() {
+ String[] expectedHeader = new String[] {"time", "city", "precipitation", "temperature"};
+
+ orderByTimeDeviceTest4(
+ "SELECT * FROM weather ORDER BY time DESC,city ASC",
+ numOfPointsInDevice * places.length,
+ expectedHeader);
+
+ orderByTimeDeviceTest4(
+ "SELECT * FROM weather ORDER BY time DESC,city ASC LIMIT 100", 100, expectedHeader);
+ }
+
+ public static void orderByTimeTest1(String sql, int count, String[] expectedHeader) {
+ int total = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ try (ResultSet resultSet = statement.executeQuery(sql)) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+
+ long lastTimeStamp = -1;
+ String lastDevice = "";
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ assertTrue(actualTimeStamp >= lastTimeStamp);
+ String actualDevice = resultSet.getString(2);
+ if (!lastDevice.isEmpty() && actualTimeStamp == lastTimeStamp) {
+ assertTrue(actualDevice.compareTo(lastDevice) >= 0);
+ }
+ lastDevice = actualDevice;
+ lastTimeStamp = actualTimeStamp;
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ startTemperature + actualDevice.hashCode() + actualTimeStamp - actualTemperature
+ < 0.00001);
+ total++;
+ }
+ assertEquals(count, total);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ public static void orderByTimeTest3(String sql, int count, String[] expectedHeader) {
+
+ int total = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ try (ResultSet resultSet = statement.executeQuery(sql)) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+
+ long lastTimeStamp = Long.MAX_VALUE;
+ String lastDevice = "";
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ assertTrue(actualTimeStamp <= lastTimeStamp);
+ String actualDevice = resultSet.getString(2);
+ if (!lastDevice.equals("") && actualTimeStamp == lastTimeStamp) {
+ assertTrue(actualDevice.compareTo(lastDevice) >= 0);
+ }
+ lastDevice = actualDevice;
+ lastTimeStamp = actualTimeStamp;
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ startTemperature + actualDevice.hashCode() + actualTimeStamp - actualTemperature
+ < 0.00001);
+ total++;
+ }
+ assertEquals(count, total);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ public static void orderByTimeExpressionTest1(String sql, int count, String[] expectedHeader) {
+ int total = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ try (ResultSet resultSet = statement.executeQuery(sql)) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+
+ long lastTimeStamp = Long.MAX_VALUE;
+ long lastPrecipitation = Long.MAX_VALUE;
+ String lastDevice = "";
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ assertTrue(actualTimeStamp <= lastTimeStamp);
+ String actualDevice = resultSet.getString(2);
+
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ startTemperature + actualDevice.hashCode() + actualTimeStamp - actualTemperature
+ < 0.00001);
+ if (actualDevice.equals(lastDevice) && actualTimeStamp == lastTimeStamp) {
+ assertTrue(actualPrecipitation <= lastPrecipitation);
+ lastPrecipitation = actualPrecipitation;
+ }
+ lastDevice = actualDevice;
+ lastTimeStamp = actualTimeStamp;
+ total++;
+ }
+ assertEquals(count, total);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ public static void orderByExpressionTest1(String sql, int count, String[] expectedHeader) {
+
+ int total = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ try (ResultSet resultSet = statement.executeQuery(sql)) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+
+ long lastTimeStamp = Long.MAX_VALUE;
+ long lastPrecipitation = Long.MAX_VALUE;
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ String actualDevice = resultSet.getString(2);
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ startTemperature + actualDevice.hashCode() + actualTimeStamp - actualTemperature
+ < 0.00001);
+ assertTrue(actualPrecipitation <= lastPrecipitation);
+ if (actualPrecipitation == lastPrecipitation) {
+ assertTrue(actualTimeStamp <= lastTimeStamp);
+ }
+ lastPrecipitation = actualPrecipitation;
+ lastTimeStamp = actualTimeStamp;
+ total++;
+ }
+ assertEquals(count, total);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ // ORDER BY DEVICE,TIME
+ public static void orderByDeviceTimeTest1(String sql, int count, String[] expectedHeader) {
+ String[] expectedDevice = Arrays.stream(places.clone()).sorted().toArray(String[]::new);
+ int index = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ try (ResultSet resultSet = statement.executeQuery(sql)) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+
+ int cnt = 0;
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ String actualDevice = resultSet.getString(2);
+ assertEquals(expectedDevice[index], actualDevice);
+ assertEquals(
+ deviceToStartTimestamp.get(actualDevice) + timeGap * (numOfPointsInDevice - cnt - 1),
+ actualTimeStamp);
+
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ (startTemperature + actualDevice.hashCode() + actualTimeStamp) - actualTemperature
+ < 0.00001);
+
+ cnt++;
+ if (cnt % numOfPointsInDevice == 0) {
+ index++;
+ cnt = 0;
+ }
+ }
+ assertEquals(count, index);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ public static void orderByDeviceTimeTest2(String sql, int count, String[] expectedHeader) {
+ String[] expectedDevice = Arrays.stream(places.clone()).sorted().toArray(String[]::new);
+ int index = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ try (ResultSet resultSet = statement.executeQuery(sql)) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+
+ int cnt = 0;
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ String actualDevice = resultSet.getString(2);
+ assertEquals(expectedDevice[index], actualDevice);
+ assertEquals(deviceToStartTimestamp.get(actualDevice) + cnt * timeGap, actualTimeStamp);
+
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ (startTemperature + actualDevice.hashCode() + actualTimeStamp) - actualTemperature
+ < 0.00001);
+
+ cnt++;
+ if (cnt % numOfPointsInDevice == 0) {
+ index++;
+ cnt = 0;
+ }
+ }
+ assertEquals(count, index);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ public static void orderByDeviceTimeTest3(String sql, int count, String[] expectedHeader) {
+ String[] expectedDevice =
+ Arrays.stream(places.clone()).sorted(Comparator.reverseOrder()).toArray(String[]::new);
+ int index = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ try (ResultSet resultSet = statement.executeQuery(sql)) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+
+ int cnt = 0;
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ String actualDevice = resultSet.getString(2);
+ assertEquals(expectedDevice[index], actualDevice);
+ assertEquals(
+ deviceToStartTimestamp.get(actualDevice) + timeGap * (numOfPointsInDevice - cnt - 1),
+ actualTimeStamp);
+
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ (startTemperature + actualDevice.hashCode() + actualTimeStamp) - actualTemperature
+ < 0.00001);
+
+ cnt++;
+ if (cnt % numOfPointsInDevice == 0) {
+ index++;
+ cnt = 0;
+ }
+ }
+ assertEquals(count, index);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ public static void orderByDeviceTimeTest4(String sql, int count, String[] expectedHeader) {
+ String[] expectedDevice =
+ Arrays.stream(places.clone()).sorted(Comparator.reverseOrder()).toArray(String[]::new);
+ int index = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ try (ResultSet resultSet = statement.executeQuery(sql)) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+
+ int cnt = 0;
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ String actualDevice = resultSet.getString(2);
+ assertEquals(expectedDevice[index], actualDevice);
+ assertEquals(deviceToStartTimestamp.get(actualDevice) + cnt * timeGap, actualTimeStamp);
+
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ (startTemperature + actualDevice.hashCode() + actualTimeStamp) - actualTemperature
+ < 0.00001);
+
+ cnt++;
+ if (cnt % numOfPointsInDevice == 0) {
+ index++;
+ cnt = 0;
+ }
+ }
+ assertEquals(count, index);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ // ORDER BY TIME,DEVICE
+ public static void orderByTimeDeviceTest1(String sql, int count, String[] expectedHeader) {
+ int total = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ try (ResultSet resultSet = statement.executeQuery(sql)) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+
+ long lastTimeStamp = -1;
+ String lastDevice = "";
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ assertTrue(actualTimeStamp >= lastTimeStamp);
+ String actualDevice = resultSet.getString(2);
+ if (!lastDevice.equals("") && actualTimeStamp == lastTimeStamp) {
+ assertTrue(actualDevice.compareTo(lastDevice) <= 0);
+ }
+ lastDevice = actualDevice;
+ lastTimeStamp = actualTimeStamp;
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ startTemperature + actualDevice.hashCode() + actualTimeStamp - actualTemperature
+ < 0.00001);
+ total++;
+ }
+ assertEquals(count, total);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ public static void orderByTimeDeviceTest2(String sql, int count, String[] expectedHeader) {
+ int total = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ try (ResultSet resultSet = statement.executeQuery(sql)) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+ long lastTimeStamp = -1;
+ String lastDevice = "";
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ assertTrue(actualTimeStamp >= lastTimeStamp);
+ String actualDevice = resultSet.getString(2);
+ if (!lastDevice.equals("") && actualTimeStamp == lastTimeStamp) {
+ assertTrue(actualDevice.compareTo(lastDevice) >= 0);
+ }
+ lastDevice = actualDevice;
+ lastTimeStamp = actualTimeStamp;
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ startTemperature + actualDevice.hashCode() + actualTimeStamp - actualTemperature
+ < 0.00001);
+ total++;
+ }
+ assertEquals(count, total);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ public static void orderByTimeDeviceTest3(String sql, int count, String[] expectedHeader) {
+ int total = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ try (ResultSet resultSet = statement.executeQuery(sql)) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+ long lastTimeStamp = Long.MAX_VALUE;
+ String lastDevice = "";
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ assertTrue(actualTimeStamp <= lastTimeStamp);
+ String actualDevice = resultSet.getString(2);
+ if (!lastDevice.equals("") && actualTimeStamp == lastTimeStamp) {
+ assertTrue(actualDevice.compareTo(lastDevice) <= 0);
+ }
+ lastDevice = actualDevice;
+ lastTimeStamp = actualTimeStamp;
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ startTemperature + actualDevice.hashCode() + actualTimeStamp - actualTemperature
+ < 0.00001);
+ total++;
+ }
+ assertEquals(count, total);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ public static void orderByTimeDeviceTest4(String sql, int count, String[] expectedHeader) {
+ int total = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+ statement.execute("use " + DATABASE_NAME);
+ try (ResultSet resultSet = statement.executeQuery(sql)) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ assertEquals(expectedHeader[i - 1], resultSetMetaData.getColumnName(i));
+ }
+ assertEquals(expectedHeader.length, resultSetMetaData.getColumnCount());
+ long lastTimeStamp = Long.MAX_VALUE;
+ String lastDevice = "";
+ while (resultSet.next()) {
+ long actualTimeStamp = resultSet.getLong(1);
+ assertTrue(actualTimeStamp <= lastTimeStamp);
+ String actualDevice = resultSet.getString(2);
+ if (!lastDevice.equals("") && actualTimeStamp == lastTimeStamp) {
+ assertTrue(actualDevice.compareTo(lastDevice) >= 0);
+ }
+ lastDevice = actualDevice;
+ lastTimeStamp = actualTimeStamp;
+ long actualPrecipitation = resultSet.getLong(3);
+ double actualTemperature = resultSet.getDouble(4);
+ assertEquals(
+ startPrecipitation + actualDevice.hashCode() + actualTimeStamp, actualPrecipitation);
+ assertTrue(
+ startTemperature + actualDevice.hashCode() + actualTimeStamp - actualTemperature
+ < 0.00001);
+ total++;
+ }
+ assertEquals(count, total);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ //
+ // // aggregation query
+ // private static final int[][] countIn1000MSFiledWith100MSTimeGap =
+ // new int[][] {
+ // {10, 10, 0},
+ // {9, 10, 1},
+ // {8, 10, 2},
+ // {7, 10, 3},
+ // {6, 10, 4},
+ // {5, 10, 5},
+ // {4, 10, 6},
+ // {3, 10, 7},
+ // {2, 10, 8},
+ // {1, 10, 9}
+ // };
+ //
+ // private static int getCountNum(String device, int cnt) {
+ // int index = 0;
+ // for (int i = 0; i < places.length; i++) {
+ // if (places[i].equals(device)) {
+ // index = i;
+ // break;
+ // }
+ // }
+ //
+ // return countIn1000MSFiledWith100MSTimeGap[index][cnt];
+ // }
+ //
+ // @Test
+ // public void groupByTimeOrderByDeviceTest1() {
+ // String sql =
+ // "SELECT AVG(*),COUNT(*),MAX_VALUE(*) FROM weather GROUP
+ // BY([2022-11-21T00:00:00.000+08:00,2022-11-21T00:00:02.801+08:00),1000msC";
+ // try (Connection connection = EnvFactory.getEnv().getConnection();
+ // Statement statement = connection.createStatement()) {
+ // long lastTime = -1;
+ // String lastDevice = "";
+ // long[] expectedTime = new long[] {startTime, startTime + 1000, startTime + 1000 * 2};
+ // try (ResultSet resultSet = statement.executeQuery(sql)) {
+ // ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ // checkHeader(
+ // resultSetMetaData,
+ //
+ // "Time,Device,AVG(precipitation),AVG(temperature),COUNT(precipitation),COUNT(temperature),MAX_VALUE(precipitation),MAX_VALUE(temperature)");
+ // int cnt = 0;
+ // while (resultSet.next()) {
+ //
+ // long actualTime = resultSet.getLong(1);
+ // String actualDevice = resultSet.getString(2);
+ // assertEquals(expectedTime[cnt], actualTime);
+ // if (!Objects.equals(lastDevice, "") && Objects.equals(actualDevice, lastDevice)) {
+ // assertTrue(actualTime >= lastTime);
+ // }
+ // if (!Objects.equals(lastDevice, "")) {
+ // assertTrue(actualDevice.compareTo(lastDevice) >= 0);
+ // }
+ // lastTime = actualTime;
+ // lastDevice = actualDevice;
+ //
+ // double avgPrecipitation = resultSet.getDouble(3);
+ // assertTrue(deviceToAvgPrecipitation.get(actualDevice)[cnt] - avgPrecipitation <
+ // 0.00001);
+ //
+ // double avgTemperature = resultSet.getDouble(4);
+ // assertTrue(deviceToAvgTemperature.get(actualDevice)[cnt] - avgTemperature < 0.00001);
+ //
+ // int countPrecipitation = resultSet.getInt(5);
+ // assertEquals(getCountNum(actualDevice, cnt), countPrecipitation);
+ // int countTemperature = resultSet.getInt(6);
+ // assertEquals(getCountNum(actualDevice, cnt), countTemperature);
+ //
+ // long maxPrecipitation = resultSet.getLong(7);
+ // assertEquals(deviceToMaxPrecipitation.get(actualDevice)[cnt], maxPrecipitation);
+ //
+ // double maxTemperature = resultSet.getDouble(8);
+ // assertTrue(deviceToMaxTemperature.get(actualDevice)[cnt] - maxTemperature < 0.00001);
+ // cnt++;
+ // if (cnt % 3 == 0) {
+ // cnt = 0;
+ // }
+ // }
+ // }
+ // } catch (Exception e) {
+ // e.printStackTrace();
+ // fail(e.getMessage());
+ // }
+ // }
+ //
+ // @Test
+ // public void groupByTimeOrderByDeviceTest2() {
+ // String sql =
+ // "SELECT AVG(*),COUNT(*),MAX_VALUE(*) FROM weather GROUP
+ // BY([2022-11-21T00:00:00.000+08:00,2022-11-21T00:00:02.801+08:00),1000ms) ORDER BY DEVICE DESC";
+ // try (Connection connection = EnvFactory.getEnv().getConnection();
+ // Statement statement = connection.createStatement()) {
+ // long lastTime = -1;
+ // String lastDevice = "";
+ // long[] expectedTime = new long[] {startTime, startTime + 1000, startTime + 1000 * 2};
+ // try (ResultSet resultSet = statement.executeQuery(sql)) {
+ // ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ // checkHeader(
+ // resultSetMetaData,
+ //
+ // "Time,Device,AVG(precipitation),AVG(temperature),COUNT(precipitation),COUNT(temperature),MAX_VALUE(precipitation),MAX_VALUE(temperature)");
+ // int cnt = 0;
+ // while (resultSet.next()) {
+ //
+ // long actualTime = resultSet.getLong(1);
+ // String actualDevice = resultSet.getString(2);
+ // assertEquals(expectedTime[cnt], actualTime);
+ // if (!Objects.equals(lastDevice, "") && Objects.equals(actualDevice, lastDevice)) {
+ // assertTrue(actualTime >= lastTime);
+ // }
+ // if (!Objects.equals(lastDevice, "")) {
+ // assertTrue(actualDevice.compareTo(lastDevice) <= 0);
+ // }
+ // lastTime = actualTime;
+ // lastDevice = actualDevice;
+ //
+ // double avgPrecipitation = resultSet.getDouble(3);
+ // assertTrue(deviceToAvgPrecipitation.get(actualDevice)[cnt] - avgPrecipitation <
+ // 0.00001);
+ //
+ // double avgTemperature = resultSet.getDouble(4);
+ // assertTrue(deviceToAvgTemperature.get(actualDevice)[cnt] - avgTemperature < 0.00001);
+ //
+ // int countPrecipitation = resultSet.getInt(5);
+ // assertEquals(getCountNum(actualDevice, cnt), countPrecipitation);
+ // int countTemperature = resultSet.getInt(6);
+ // assertEquals(getCountNum(actualDevice, cnt), countTemperature);
+ //
+ // long maxPrecipitation = resultSet.getLong(7);
+ // assertEquals(deviceToMaxPrecipitation.get(actualDevice)[cnt], maxPrecipitation);
+ //
+ // double maxTemperature = resultSet.getDouble(8);
+ // assertTrue(deviceToMaxTemperature.get(actualDevice)[cnt] - maxTemperature < 0.00001);
+ // cnt++;
+ // if (cnt % 3 == 0) {
+ // cnt = 0;
+ // }
+ // }
+ // }
+ // } catch (Exception e) {
+ // e.printStackTrace();
+ // fail(e.getMessage());
+ // }
+ // }
+ //
+ // @Test
+ // public void groupByTimeOrderByDeviceTest3() {
+ // String sql =
+ // "SELECT AVG(*),COUNT(*),MAX_VALUE(*) FROM weather GROUP
+ // BY([2022-11-21T00:00:00.000+08:00,2022-11-21T00:00:02.801+08:00),1000ms) ORDER BY DEVICE
+ // DESC,TIME DESC";
+ // try (Connection connection = EnvFactory.getEnv().getConnection();
+ // Statement statement = connection.createStatement()) {
+ // long lastTime = -1;
+ // String lastDevice = "";
+ // long[] expectedTime = new long[] {startTime, startTime + 1000, startTime + 1000 * 2};
+ // try (ResultSet resultSet = statement.executeQuery(sql)) {
+ // ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ // checkHeader(
+ // resultSetMetaData,
+ //
+ // "Time,Device,AVG(precipitation),AVG(temperature),COUNT(precipitation),COUNT(temperature),MAX_VALUE(precipitation),MAX_VALUE(temperature)");
+ // int cnt = 2;
+ // while (resultSet.next()) {
+ // long actualTime = resultSet.getLong(1);
+ // String actualDevice = resultSet.getString(2);
+ // assertEquals(expectedTime[cnt], actualTime);
+ // if (!Objects.equals(lastDevice, "") && Objects.equals(actualDevice, lastDevice)) {
+ // assertTrue(actualTime <= lastTime);
+ // }
+ // if (!Objects.equals(lastDevice, "")) {
+ // assertTrue(actualDevice.compareTo(lastDevice) <= 0);
+ // }
+ // lastTime = actualTime;
+ // lastDevice = actualDevice;
+ //
+ // double avgPrecipitation = resultSet.getDouble(3);
+ // assertTrue(deviceToAvgPrecipitation.get(actualDevice)[cnt] - avgPrecipitation <
+ // 0.00001);
+ //
+ // double avgTemperature = resultSet.getDouble(4);
+ // assertTrue(deviceToAvgTemperature.get(actualDevice)[cnt] - avgTemperature < 0.00001);
+ //
+ // int countPrecipitation = resultSet.getInt(5);
+ // assertEquals(getCountNum(actualDevice, cnt), countPrecipitation);
+ // int countTemperature = resultSet.getInt(6);
+ // assertEquals(getCountNum(actualDevice, cnt), countTemperature);
+ //
+ // long maxPrecipitation = resultSet.getLong(7);
+ // assertEquals(deviceToMaxPrecipitation.get(actualDevice)[cnt], maxPrecipitation);
+ //
+ // double maxTemperature = resultSet.getDouble(8);
+ // assertTrue(deviceToMaxTemperature.get(actualDevice)[cnt] - maxTemperature < 0.00001);
+ // cnt--;
+ // if (cnt < 0) {
+ // cnt = 2;
+ // }
+ // }
+ // }
+ // } catch (Exception e) {
+ // e.printStackTrace();
+ // fail(e.getMessage());
+ // }
+ // }
+ //
+ // @Test
+ // public void groupByTimeOrderByDeviceTest4() {
+ // String sql =
+ // "SELECT AVG(*),COUNT(*),MAX_VALUE(*) FROM weather GROUP
+ // BY([2022-11-21T00:00:00.000+08:00,2022-11-21T00:00:02.801+08:00),1000ms) ORDER BY DEVICE
+ // ASC,TIME DESC";
+ // try (Connection connection = EnvFactory.getEnv().getConnection();
+ // Statement statement = connection.createStatement()) {
+ // long lastTime = -1;
+ // String lastDevice = "";
+ // long[] expectedTime = new long[] {startTime, startTime + 1000, startTime + 1000 * 2};
+ // try (ResultSet resultSet = statement.executeQuery(sql)) {
+ // ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ // checkHeader(
+ // resultSetMetaData,
+ //
+ // "Time,Device,AVG(precipitation),AVG(temperature),COUNT(precipitation),COUNT(temperature),MAX_VALUE(precipitation),MAX_VALUE(temperature)");
+ // int cnt = 2;
+ // while (resultSet.next()) {
+ //
+ // long actualTime = resultSet.getLong(1);
+ // String actualDevice = resultSet.getString(2);
+ // assertEquals(expectedTime[cnt], actualTime);
+ // if (!Objects.equals(lastDevice, "") && Objects.equals(actualDevice, lastDevice)) {
+ // assertTrue(actualTime <= lastTime);
+ // }
+ // if (!Objects.equals(lastDevice, "")) {
+ // assertTrue(actualDevice.compareTo(lastDevice) >= 0);
+ // }
+ // lastTime = actualTime;
+ // lastDevice = actualDevice;
+ //
+ // double avgPrecipitation = resultSet.getDouble(3);
+ // assertTrue(deviceToAvgPrecipitation.get(actualDevice)[cnt] - avgPrecipitation <
+ // 0.00001);
+ //
+ // double avgTemperature = resultSet.getDouble(4);
+ // assertTrue(deviceToAvgTemperature.get(actualDevice)[cnt] - avgTemperature < 0.00001);
+ //
+ // int countPrecipitation = resultSet.getInt(5);
+ // assertEquals(getCountNum(actualDevice, cnt), countPrecipitation);
+ // int countTemperature = resultSet.getInt(6);
+ // assertEquals(getCountNum(actualDevice, cnt), countTemperature);
+ //
+ // long maxPrecipitation = resultSet.getLong(7);
+ // assertEquals(deviceToMaxPrecipitation.get(actualDevice)[cnt], maxPrecipitation);
+ //
+ // double maxTemperature = resultSet.getDouble(8);
+ // assertTrue(deviceToMaxTemperature.get(actualDevice)[cnt] - maxTemperature < 0.00001);
+ // cnt--;
+ // if (cnt < 0) {
+ // cnt = 2;
+ // }
+ // }
+ // }
+ // } catch (Exception e) {
+ // e.printStackTrace();
+ // fail(e.getMessage());
+ // }
+ // }
+ //
+ // @Test
+ // public void groupByTimeOrderByTimeTest1() {
+ // String sql =
+ // "SELECT AVG(*),COUNT(*),MAX_VALUE(*) FROM weather GROUP
+ // BY([2022-11-21T00:00:00.000+08:00,2022-11-21T00:00:02.801+08:00),1000ms) ORDER BY TIME";
+ // try (Connection connection = EnvFactory.getEnv().getConnection();
+ // Statement statement = connection.createStatement()) {
+ // long lastTime = -1;
+ // String lastDevice = "";
+ // int index = 0;
+ // try (ResultSet resultSet = statement.executeQuery(sql)) {
+ // ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ // checkHeader(
+ // resultSetMetaData,
+ //
+ // "Time,Device,AVG(precipitation),AVG(temperature),COUNT(precipitation),COUNT(temperature),MAX_VALUE(precipitation),MAX_VALUE(temperature)");
+ // int cnt = 0;
+ // while (resultSet.next()) {
+ // long actualTime = resultSet.getLong(1);
+ // String actualDevice = resultSet.getString(2);
+ // assertTrue(actualTime >= lastTime);
+ // if (!Objects.equals(lastDevice, "") && actualTime == lastTime) {
+ // assertTrue(actualDevice.compareTo(lastDevice) >= 0);
+ // }
+ // lastTime = actualTime;
+ // lastDevice = actualDevice;
+ // double avgPrecipitation = resultSet.getDouble(3);
+ // assertTrue(deviceToAvgPrecipitation.get(actualDevice)[cnt] - avgPrecipitation <
+ // 0.00001);
+ //
+ // double avgTemperature = resultSet.getDouble(4);
+ // assertTrue(deviceToAvgTemperature.get(actualDevice)[cnt] - avgTemperature < 0.00001);
+ //
+ // int countPrecipitation = resultSet.getInt(5);
+ // assertEquals(getCountNum(actualDevice, cnt), countPrecipitation);
+ // int countTemperature = resultSet.getInt(6);
+ // assertEquals(getCountNum(actualDevice, cnt), countTemperature);
+ //
+ // long maxPrecipitation = resultSet.getLong(7);
+ // assertEquals(deviceToMaxPrecipitation.get(actualDevice)[cnt], maxPrecipitation);
+ //
+ // double maxTemperature = resultSet.getDouble(8);
+ // assertTrue(deviceToMaxTemperature.get(actualDevice)[cnt] - maxTemperature < 0.00001);
+ // index++;
+ // if (index % 10 == 0) {
+ // cnt++;
+ // }
+ // }
+ // assertEquals(30, index);
+ // }
+ // } catch (Exception e) {
+ // e.printStackTrace();
+ // fail(e.getMessage());
+ // }
+ // }
+ //
+ // @Test
+ // public void groupByTimeOrderByTimeTest2() {
+ // String sql =
+ // "SELECT AVG(*),COUNT(*),MAX_VALUE(*) FROM weather GROUP
+ // BY([2022-11-21T00:00:00.000+08:00,2022-11-21T00:00:02.801+08:00),1000ms) ORDER BY TIME DESC";
+ // try (Connection connection = EnvFactory.getEnv().getConnection();
+ // Statement statement = connection.createStatement()) {
+ // long lastTime = Long.MAX_VALUE;
+ // String lastDevice = "";
+ // int index = 0;
+ // try (ResultSet resultSet = statement.executeQuery(sql)) {
+ // ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ // checkHeader(
+ // resultSetMetaData,
+ //
+ // "Time,Device,AVG(precipitation),AVG(temperature),COUNT(precipitation),COUNT(temperature),MAX_VALUE(precipitation),MAX_VALUE(temperature)");
+ // int cnt = 2;
+ // while (resultSet.next()) {
+ // long actualTime = resultSet.getLong(1);
+ // String actualDevice = resultSet.getString(2);
+ // assertTrue(actualTime <= lastTime);
+ // if (!Objects.equals(lastDevice, "") && actualTime == lastTime) {
+ // assertTrue(actualDevice.compareTo(lastDevice) >= 0);
+ // }
+ // lastTime = actualTime;
+ // lastDevice = actualDevice;
+ // double avgPrecipitation = resultSet.getDouble(3);
+ // assertTrue(deviceToAvgPrecipitation.get(actualDevice)[cnt] - avgPrecipitation <
+ // 0.00001);
+ //
+ // double avgTemperature = resultSet.getDouble(4);
+ // assertTrue(deviceToAvgTemperature.get(actualDevice)[cnt] - avgTemperature < 0.00001);
+ //
+ // int countPrecipitation = resultSet.getInt(5);
+ // assertEquals(getCountNum(actualDevice, cnt), countPrecipitation);
+ // int countTemperature = resultSet.getInt(6);
+ // assertEquals(getCountNum(actualDevice, cnt), countTemperature);
+ //
+ // long maxPrecipitation = resultSet.getLong(7);
+ // assertEquals(deviceToMaxPrecipitation.get(actualDevice)[cnt], maxPrecipitation);
+ //
+ // double maxTemperature = resultSet.getDouble(8);
+ // assertTrue(deviceToMaxTemperature.get(actualDevice)[cnt] - maxTemperature < 0.00001);
+ // index++;
+ // if (index % 10 == 0) {
+ // cnt--;
+ // }
+ // }
+ // assertEquals(30, index);
+ // }
+ // } catch (Exception e) {
+ // e.printStackTrace();
+ // fail(e.getMessage());
+ // }
+ // }
+ //
+ // @Test
+ // public void groupByTimeOrderByTimeTest3() {
+ // String sql =
+ // "SELECT AVG(*),COUNT(*),MAX_VALUE(*) FROM weather GROUP
+ // BY([2022-11-21T00:00:00.000+08:00,2022-11-21T00:00:02.801+08:00),1000ms) ORDER BY TIME
+ // ASC,DEVICE DESC";
+ // try (Connection connection = EnvFactory.getEnv().getConnection();
+ // Statement statement = connection.createStatement()) {
+ // long lastTime = -1;
+ // String lastDevice = "";
+ // int index = 0;
+ // try (ResultSet resultSet = statement.executeQuery(sql)) {
+ // ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ // checkHeader(
+ // resultSetMetaData,
+ //
+ // "Time,Device,AVG(precipitation),AVG(temperature),COUNT(precipitation),COUNT(temperature),MAX_VALUE(precipitation),MAX_VALUE(temperature)");
+ // int cnt = 0;
+ // while (resultSet.next()) {
+ // long actualTime = resultSet.getLong(1);
+ // String actualDevice = resultSet.getString(2);
+ // assertTrue(actualTime >= lastTime);
+ // if (!Objects.equals(lastDevice, "") && actualTime == lastTime) {
+ // assertTrue(actualDevice.compareTo(lastDevice) <= 0);
+ // }
+ // lastTime = actualTime;
+ // lastDevice = actualDevice;
+ // double avgPrecipitation = resultSet.getDouble(3);
+ // assertTrue(deviceToAvgPrecipitation.get(actualDevice)[cnt] - avgPrecipitation <
+ // 0.00001);
+ //
+ // double avgTemperature = resultSet.getDouble(4);
+ // assertTrue(deviceToAvgTemperature.get(actualDevice)[cnt] - avgTemperature < 0.00001);
+ //
+ // int countPrecipitation = resultSet.getInt(5);
+ // assertEquals(getCountNum(actualDevice, cnt), countPrecipitation);
+ // int countTemperature = resultSet.getInt(6);
+ // assertEquals(getCountNum(actualDevice, cnt), countTemperature);
+ //
+ // long maxPrecipitation = resultSet.getLong(7);
+ // assertEquals(deviceToMaxPrecipitation.get(actualDevice)[cnt], maxPrecipitation);
+ //
+ // double maxTemperature = resultSet.getDouble(8);
+ // assertTrue(deviceToMaxTemperature.get(actualDevice)[cnt] - maxTemperature < 0.00001);
+ // index++;
+ // if (index % 10 == 0) {
+ // cnt++;
+ // }
+ // }
+ // assertEquals(30, index);
+ // }
+ // } catch (Exception e) {
+ // e.printStackTrace();
+ // fail(e.getMessage());
+ // }
+ // }
+ //
+ // @Test
+ // public void groupByTimeOrderByTimeTest4() {
+ // String sql =
+ // "SELECT AVG(*),COUNT(*),MAX_VALUE(*) FROM weather GROUP
+ // BY([2022-11-21T00:00:00.000+08:00,2022-11-21T00:00:02.801+08:00),1000ms) ORDER BY TIME
+ // DESC,DEVICE DESC";
+ // try (Connection connection = EnvFactory.getEnv().getConnection();
+ // Statement statement = connection.createStatement()) {
+ // long lastTime = Long.MAX_VALUE;
+ // String lastDevice = "";
+ // int index = 0;
+ // try (ResultSet resultSet = statement.executeQuery(sql)) {
+ // ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ // checkHeader(
+ // resultSetMetaData,
+ //
+ // "Time,Device,AVG(precipitation),AVG(temperature),COUNT(precipitation),COUNT(temperature),MAX_VALUE(precipitation),MAX_VALUE(temperature)");
+ // int cnt = 2;
+ // while (resultSet.next()) {
+ // long actualTime = resultSet.getLong(1);
+ // String actualDevice = resultSet.getString(2);
+ // assertTrue(actualTime <= lastTime);
+ // if (!Objects.equals(lastDevice, "") && actualTime == lastTime) {
+ // assertTrue(actualDevice.compareTo(lastDevice) <= 0);
+ // }
+ // lastTime = actualTime;
+ // lastDevice = actualDevice;
+ // double avgPrecipitation = resultSet.getDouble(3);
+ // assertTrue(deviceToAvgPrecipitation.get(actualDevice)[cnt] - avgPrecipitation <
+ // 0.00001);
+ //
+ // double avgTemperature = resultSet.getDouble(4);
+ // assertTrue(deviceToAvgTemperature.get(actualDevice)[cnt] - avgTemperature < 0.00001);
+ //
+ // int countPrecipitation = resultSet.getInt(5);
+ // assertEquals(getCountNum(actualDevice, cnt), countPrecipitation);
+ // int countTemperature = resultSet.getInt(6);
+ // assertEquals(getCountNum(actualDevice, cnt), countTemperature);
+ //
+ // long maxPrecipitation = resultSet.getLong(7);
+ // assertEquals(deviceToMaxPrecipitation.get(actualDevice)[cnt], maxPrecipitation);
+ //
+ // double maxTemperature = resultSet.getDouble(8);
+ // assertTrue(deviceToMaxTemperature.get(actualDevice)[cnt] - maxTemperature < 0.00001);
+ // index++;
+ // if (index % 10 == 0) {
+ // cnt--;
+ // }
+ // }
+ // assertEquals(30, index);
+ // }
+ // } catch (Exception e) {
+ // e.printStackTrace();
+ // fail(e.getMessage());
+ // }
+ // }
+
+ // test the optimized plan
+ public static String[] optimizedSQL =
+ new String[] {
+ "insert into root.ln.wf01.wt01(timestamp,temperature,status) values(2017-11-01T00:00:00.000+08:00,25.96,true)",
+ "insert into root.ln.wf01.wt01(timestamp,temperature,status) values(2017-11-01T00:01:00.000+08:00,24.36,true)",
+ "insert into root.ln.wf02.wt02(timestamp,status,hardware) values(1970-01-01T08:00:00.001+08:00,true,'v1')",
+ "insert into root.ln.wf02.wt02(timestamp,status,hardware) values(1970-01-01T08:00:00.002+08:00,false,'v2')",
+ "insert into root.ln.wf02.wt02(timestamp,status,hardware) values(2017-11-01T00:00:00.000+08:00,false,'v2')",
+ "insert into root.ln.wf02.wt02(timestamp,status,hardware) values(2017-11-01T00:01:00.000+08:00,true,'v2')"
+ };
+
+ @Test
+ public void optimizedPlanTest() {
+
+ String[] expectedHeader =
+ new String[] {"time", "plant_id", "device_id", "temperature", "status", "hardware"};
+ String[] retArray =
+ new String[] {
+ "2017-10-31T16:01:00.000Z,wf02,wt02,null,true,v2,",
+ "2017-10-31T16:01:00.000Z,wf01,wt01,24.36,true,null,",
+ "2017-10-31T16:00:00.000Z,wf02,wt02,null,false,v2,",
+ "2017-10-31T16:00:00.000Z,wf01,wt01,25.96,true,null,",
+ "1970-01-01T00:00:00.002Z,wf02,wt02,null,false,v2,",
+ "1970-01-01T00:00:00.001Z,wf02,wt02,null,true,v1,",
+ };
+
+ tableResultSetEqualTest(
+ "SELECT * FROM optimize ORDER BY Time DESC,plant_id DESC,device_id desc",
+ expectedHeader,
+ retArray,
+ DATABASE_NAME);
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedOffsetLimitPushDownTableViewIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedOffsetLimitPushDownTableViewIT.java
new file mode 100644
index 00000000000..5b84eaf3dfb
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedOffsetLimitPushDownTableViewIT.java
@@ -0,0 +1,166 @@
+/*
+ * 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.relational.it.query.view.old.aligned;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+import org.apache.iotdb.itbase.env.BaseEnv;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.apache.iotdb.relational.it.query.view.old.aligned.TableViewUtils.USE_DB;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBAlignedOffsetLimitPushDownTableViewIT {
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv().initClusterEnvironment();
+ try (Connection connection = EnvFactory.getEnv().getConnection(BaseEnv.TREE_SQL_DIALECT);
+ Statement statement = connection.createStatement()) {
+
+ statement.addBatch("insert into root.db.d1(time,s1,s2) aligned values(1,1,1)");
+ statement.addBatch("insert into root.db.d1(time,s1,s2) aligned values(2,2,2)");
+ statement.addBatch("insert into root.db.d1(time,s1,s2) aligned values(3,3,3)");
+ statement.addBatch("insert into root.db.d1(time,s1,s2) aligned values(4,4,4)");
+ statement.addBatch("insert into root.db.d1(time,s1,s2) aligned values(5,5,null)");
+ statement.addBatch("insert into root.db.d1(time,s1,s2) aligned values(6,6,null)");
+ statement.addBatch("insert into root.db.d1(time,s1,s2) aligned values(7,7,7)");
+
+ statement.addBatch("flush");
+
+ statement.executeBatch();
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute("CREATE DATABASE IF NOT EXISTS db");
+ statement.execute(USE_DB);
+ statement.execute(
+ "CREATE TABLE VIEW table0 (device string tag, s1 double field, s2 double field) as root.db.**");
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+
+ @Test
+ public void selectWithLimitPushDownTest1() {
+
+ String[] retArray = new String[] {"3,3.0", "4,4.0"};
+
+ String[] columnNames = {"s1"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,s1 from table0 where device='d1' and time >= 3 limit 2")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectWithLimitPushDownTest2() {
+
+ String[] retArray = new String[] {"6,6.0,null", "7,7.0,7.0"};
+
+ String[] columnNames = {"s1", "s2"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,s1,s2 from table0 where device='d1' and time >= 1 offset 5")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableView2IT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableView2IT.java
new file mode 100644
index 00000000000..3cc32d2c689
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableView2IT.java
@@ -0,0 +1,53 @@
+/*
+ * 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.relational.it.query.view.old.aligned;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBAlignedSeriesQueryTableView2IT extends IoTDBAlignedSeriesQueryTableViewIT {
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv()
+ .getConfig()
+ .getCommonConfig()
+ .setEnableSeqSpaceCompaction(false)
+ .setEnableUnseqSpaceCompaction(false)
+ .setEnableCrossSpaceCompaction(false)
+ .setMaxTsBlockLineNumber(3)
+ .setMaxNumberOfPointsInPage(2);
+ EnvFactory.getEnv().initClusterEnvironment();
+ TableViewUtils.insertData();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableView3IT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableView3IT.java
new file mode 100644
index 00000000000..61279a2adc1
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableView3IT.java
@@ -0,0 +1,53 @@
+/*
+ * 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.relational.it.query.view.old.aligned;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBAlignedSeriesQueryTableView3IT extends IoTDBAlignedSeriesQueryTableViewIT {
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv()
+ .getConfig()
+ .getCommonConfig()
+ .setEnableSeqSpaceCompaction(false)
+ .setEnableUnseqSpaceCompaction(false)
+ .setEnableCrossSpaceCompaction(false)
+ .setMaxTsBlockLineNumber(3)
+ .setMaxNumberOfPointsInPage(3);
+ EnvFactory.getEnv().initClusterEnvironment();
+ TableViewUtils.insertData();
+ }
+
+ @AfterClass
+ public static void tearDown() {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableView4IT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableView4IT.java
new file mode 100644
index 00000000000..da0dcc9d1ec
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableView4IT.java
@@ -0,0 +1,54 @@
+/*
+ * 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.relational.it.query.view.old.aligned;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBAlignedSeriesQueryTableView4IT extends IoTDBAlignedSeriesQueryTableViewIT {
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv()
+ .getConfig()
+ .getCommonConfig()
+ .setEnableSeqSpaceCompaction(false)
+ .setEnableUnseqSpaceCompaction(false)
+ .setEnableCrossSpaceCompaction(false)
+ .setMaxTsBlockLineNumber(3)
+ .setDegreeOfParallelism(4);
+ EnvFactory.getEnv().initClusterEnvironment();
+ TableViewUtils.insertData();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableView5IT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableView5IT.java
new file mode 100644
index 00000000000..8cdd3c4cfb9
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableView5IT.java
@@ -0,0 +1,55 @@
+/*
+ * 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.relational.it.query.view.old.aligned;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBAlignedSeriesQueryTableView5IT extends IoTDBAlignedSeriesQueryTableViewIT {
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv()
+ .getConfig()
+ .getCommonConfig()
+ .setEnableSeqSpaceCompaction(false)
+ .setEnableUnseqSpaceCompaction(false)
+ .setEnableCrossSpaceCompaction(false)
+ .setMaxTsBlockLineNumber(1)
+ .setMaxNumberOfPointsInPage(1)
+ .setDriverTaskExecutionTimeSliceInMs(20);
+
+ EnvFactory.getEnv().initClusterEnvironment();
+ TableViewUtils.insertData();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableViewIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableViewIT.java
new file mode 100644
index 00000000000..34051a1d262
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBAlignedSeriesQueryTableViewIT.java
@@ -0,0 +1,3698 @@
+/*
+ * 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.relational.it.query.view.old.aligned;
+
+import org.apache.iotdb.commons.schema.column.ColumnHeaderConstant;
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.apache.iotdb.db.utils.constant.TestConstant.avg;
+import static org.apache.iotdb.db.utils.constant.TestConstant.count;
+import static org.apache.iotdb.db.utils.constant.TestConstant.firstValue;
+import static org.apache.iotdb.db.utils.constant.TestConstant.lastValue;
+import static org.apache.iotdb.db.utils.constant.TestConstant.maxTime;
+import static org.apache.iotdb.db.utils.constant.TestConstant.maxValue;
+import static org.apache.iotdb.db.utils.constant.TestConstant.minTime;
+import static org.apache.iotdb.db.utils.constant.TestConstant.minValue;
+import static org.apache.iotdb.db.utils.constant.TestConstant.sum;
+import static org.apache.iotdb.itbase.constant.TestConstant.TIMESTAMP_STR;
+import static org.apache.iotdb.relational.it.query.view.old.aligned.TableViewUtils.USE_DB;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBAlignedSeriesQueryTableViewIT {
+
+ private static final double DELTA = 1e-6;
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv()
+ .getConfig()
+ .getCommonConfig()
+ .setEnableSeqSpaceCompaction(false)
+ .setEnableUnseqSpaceCompaction(false)
+ .setEnableCrossSpaceCompaction(false)
+ .setMaxTsBlockLineNumber(3);
+ EnvFactory.getEnv().initClusterEnvironment();
+ TableViewUtils.insertData();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+
+ // ------------------------------Raw Query Without Value Filter----------------------------------
+ @Test
+ public void selectAllAlignedWithoutValueFilterTest() {
+
+ String[] retArray =
+ new String[] {
+ "1,1.0,1,1,true,aligned_test1",
+ "2,2.0,2,2,null,aligned_test2",
+ "3,30000.0,null,30000,true,aligned_unseq_test3",
+ "4,4.0,4,null,true,aligned_test4",
+ "5,5.0,5,null,true,aligned_test5",
+ "6,6.0,6,6,true,null",
+ "7,7.0,7,7,false,aligned_test7",
+ "8,8.0,8,8,null,aligned_test8",
+ "9,9.0,9,9,false,aligned_test9",
+ "10,null,10,10,true,aligned_test10",
+ "11,11.0,11,11,null,null",
+ "12,12.0,12,12,null,null",
+ "13,130000.0,130000,130000,true,aligned_unseq_test13",
+ "14,14.0,14,14,null,null",
+ "15,15.0,15,15,null,null",
+ "16,16.0,16,16,null,null",
+ "17,17.0,17,17,null,null",
+ "18,18.0,18,18,null,null",
+ "19,19.0,19,19,null,null",
+ "20,20.0,20,20,null,null",
+ "21,null,null,21,true,null",
+ "22,null,null,22,true,null",
+ "23,230000.0,null,230000,false,null",
+ "24,null,null,24,true,null",
+ "25,null,null,25,true,null",
+ "26,null,null,26,false,null",
+ "27,null,null,27,false,null",
+ "28,null,null,28,false,null",
+ "29,null,null,29,false,null",
+ "30,null,null,30,false,null",
+ "31,null,31,null,null,aligned_test31",
+ "32,null,32,null,null,aligned_test32",
+ "33,null,33,null,null,aligned_test33",
+ "34,null,34,null,null,aligned_test34",
+ "35,null,35,null,null,aligned_test35",
+ "36,null,36,null,null,aligned_test36",
+ "37,null,37,null,null,aligned_test37",
+ "38,null,38,null,null,aligned_test38",
+ "39,null,39,null,null,aligned_test39",
+ "40,null,40,null,null,aligned_test40",
+ };
+
+ String[] columnNames = {"s1", "s2", "s3", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,s1,s2,s3,s4,s5 from table0 where device='d1' order by time")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectAllAlignedWithTimeFilterTest() {
+
+ String[] retArray =
+ new String[] {
+ "9,9.0,9,9,false,aligned_test9",
+ "10,null,10,10,true,aligned_test10",
+ "11,11.0,11,11,null,null",
+ "12,12.0,12,12,null,null",
+ "13,130000.0,130000,130000,true,aligned_unseq_test13",
+ "14,14.0,14,14,null,null",
+ "15,15.0,15,15,null,null",
+ "16,16.0,16,16,null,null",
+ "17,17.0,17,17,null,null",
+ "18,18.0,18,18,null,null",
+ "19,19.0,19,19,null,null",
+ "20,20.0,20,20,null,null",
+ "21,null,null,21,true,null",
+ "22,null,null,22,true,null",
+ "23,230000.0,null,230000,false,null",
+ "24,null,null,24,true,null",
+ "25,null,null,25,true,null",
+ "26,null,null,26,false,null",
+ "27,null,null,27,false,null",
+ "28,null,null,28,false,null",
+ "29,null,null,29,false,null",
+ "30,null,null,30,false,null",
+ "31,null,31,null,null,aligned_test31",
+ "32,null,32,null,null,aligned_test32",
+ "33,null,33,null,null,aligned_test33",
+ };
+
+ String[] columnNames = {"s1", "s2", "s3", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,s1,s2,s3,s4,s5 from table0 where device='d1' and time >= 9 and time <= 33 order by time")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectSomeAlignedWithoutValueFilterTest1() {
+
+ String[] retArray =
+ new String[] {
+ "1,1.0,true,aligned_test1",
+ "2,2.0,null,aligned_test2",
+ "3,30000.0,true,aligned_unseq_test3",
+ "4,4.0,true,aligned_test4",
+ "5,5.0,true,aligned_test5",
+ "6,6.0,true,null",
+ "7,7.0,false,aligned_test7",
+ "8,8.0,null,aligned_test8",
+ "9,9.0,false,aligned_test9",
+ "10,null,true,aligned_test10",
+ "11,11.0,null,null",
+ "12,12.0,null,null",
+ "13,130000.0,true,aligned_unseq_test13",
+ "14,14.0,null,null",
+ "15,15.0,null,null",
+ "16,16.0,null,null",
+ "17,17.0,null,null",
+ "18,18.0,null,null",
+ "19,19.0,null,null",
+ "20,20.0,null,null",
+ "21,null,true,null",
+ "22,null,true,null",
+ "23,230000.0,false,null",
+ "24,null,true,null",
+ "25,null,true,null",
+ "26,null,false,null",
+ "27,null,false,null",
+ "28,null,false,null",
+ "29,null,false,null",
+ "30,null,false,null",
+ "31,null,null,aligned_test31",
+ "32,null,null,aligned_test32",
+ "33,null,null,aligned_test33",
+ "34,null,null,aligned_test34",
+ "35,null,null,aligned_test35",
+ "36,null,null,aligned_test36",
+ "37,null,null,aligned_test37",
+ "38,null,null,aligned_test38",
+ "39,null,null,aligned_test39",
+ "40,null,null,aligned_test40",
+ };
+
+ String[] columnNames = {"s1", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery("select Time,s1,s4,s5 from table0 where device='d1'")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectSomeAlignedWithoutValueFilterTest2() {
+
+ String[] retArray =
+ new String[] {
+ "1,1.0,true",
+ "2,2.0,null",
+ "3,30000.0,true",
+ "4,4.0,true",
+ "5,5.0,true",
+ "6,6.0,true",
+ "7,7.0,false",
+ "8,8.0,null",
+ "9,9.0,false",
+ "10,null,true",
+ "11,11.0,null",
+ "12,12.0,null",
+ "13,130000.0,true",
+ "14,14.0,null",
+ "15,15.0,null",
+ "16,16.0,null",
+ "17,17.0,null",
+ "18,18.0,null",
+ "19,19.0,null",
+ "20,20.0,null",
+ "21,null,true",
+ "22,null,true",
+ "23,230000.0,false",
+ "24,null,true",
+ "25,null,true",
+ "26,null,false",
+ "27,null,false",
+ "28,null,false",
+ "29,null,false",
+ "30,null,false",
+ "31,null,null",
+ "32,null,null",
+ "33,null,null",
+ "34,null,null",
+ "35,null,null",
+ "36,null,null",
+ "37,null,null",
+ "38,null,null",
+ "39,null,null",
+ "40,null,null",
+ };
+
+ String[] columnNames = {"s1", "s4"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery("select Time,s1,s4 from table0 where device='d1'")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectSomeAlignedWithTimeFilterTest() {
+
+ String[] retArray =
+ new String[] {
+ "16,16.0,null,null",
+ "17,17.0,null,null",
+ "18,18.0,null,null",
+ "19,19.0,null,null",
+ "20,20.0,null,null",
+ "21,null,true,null",
+ "22,null,true,null",
+ "23,230000.0,false,null",
+ "24,null,true,null",
+ "25,null,true,null",
+ "26,null,false,null",
+ "27,null,false,null",
+ "28,null,false,null",
+ "29,null,false,null",
+ "30,null,false,null",
+ "31,null,null,aligned_test31",
+ "32,null,null,aligned_test32",
+ "33,null,null,aligned_test33",
+ "34,null,null,aligned_test34",
+ };
+
+ String[] columnNames = {"s1", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,s1,s4,s5 from table0 where device='d1' and time >= 16 and time <= 34")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ // ------------------------------Raw Query With Value Filter-------------------------------------
+ @Test
+ public void selectAllAlignedWithValueFilterTest1() {
+
+ String[] retArray =
+ new String[] {
+ "1,1.0,1,1,true,aligned_test1",
+ "3,30000.0,null,30000,true,aligned_unseq_test3",
+ "4,4.0,4,null,true,aligned_test4",
+ "5,5.0,5,null,true,aligned_test5",
+ "6,6.0,6,6,true,null",
+ "10,null,10,10,true,aligned_test10",
+ "13,130000.0,130000,130000,true,aligned_unseq_test13",
+ "21,null,null,21,true,null",
+ "22,null,null,22,true,null",
+ "24,null,null,24,true,null",
+ "25,null,null,25,true,null",
+ };
+
+ String[] columnNames = {"s1", "s2", "s3", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,s1,s2,s3,s4,s5 from table0 where device='d1' and s4 = true")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectAllAlignedWithValueFilterTest2() {
+
+ String[] retArray =
+ new String[] {
+ "12,12.0,12,12,null,null",
+ "14,14.0,14,14,null,null",
+ "15,15.0,15,15,null,null",
+ "16,16.0,16,16,null,null",
+ "17,17.0,17,17,null,null",
+ "18,18.0,18,18,null,null",
+ "19,19.0,19,19,null,null",
+ "20,20.0,20,20,null,null",
+ };
+
+ String[] columnNames = {"s1", "s2", "s3", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,s1,s2,s3,s4,s5 from table0 where device='d1' and s1 > 11.0 and s2 <= 33 order by time asc")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectAllAlignedWithValueFilterTest3() {
+
+ String[] retArray =
+ new String[] {
+ "1,1.0,1,1,true,aligned_test1",
+ "2,2.0,2,2,null,aligned_test2",
+ "3,30000.0,null,30000,true,aligned_unseq_test3",
+ "4,4.0,4,null,true,aligned_test4",
+ "5,5.0,5,null,true,aligned_test5",
+ "6,6.0,6,6,true,null",
+ "7,7.0,7,7,false,aligned_test7",
+ "8,8.0,8,8,null,aligned_test8",
+ "9,9.0,9,9,false,aligned_test9",
+ "10,null,10,10,true,aligned_test10",
+ "11,11.0,11,11,null,null",
+ "12,12.0,12,12,null,null",
+ "13,130000.0,130000,130000,true,aligned_unseq_test13",
+ "14,14.0,14,14,null,null",
+ "15,15.0,15,15,null,null",
+ "16,16.0,16,16,null,null",
+ "17,17.0,17,17,null,null",
+ "18,18.0,18,18,null,null",
+ "19,19.0,19,19,null,null",
+ "20,20.0,20,20,null,null",
+ "23,230000.0,null,230000,false,null",
+ "31,null,31,null,null,aligned_test31",
+ "32,null,32,null,null,aligned_test32",
+ };
+
+ String[] columnNames = {"s1", "s2", "s3", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,s1,s2,s3,s4,s5 from table0 where device='d1' and (s1 >= 13.0 or s2 < 33) order by time asc")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectAllAlignedWithTimeAndValueFilterTest1() {
+
+ String[] retArray =
+ new String[] {
+ "9,9.0,9,9,false,aligned_test9",
+ "11,11.0,11,11,null,null",
+ "12,12.0,12,12,null,null",
+ "14,14.0,14,14,null,null",
+ "15,15.0,15,15,null,null",
+ "16,16.0,16,16,null,null",
+ "17,17.0,17,17,null,null",
+ "18,18.0,18,18,null,null",
+ };
+
+ String[] columnNames = {"s1", "s2", "s3", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,s1,s2,s3,s4,s5 from table0 where device='d1' and time >= 9 and time <= 33 and s1 < 19.0")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectAllAlignedWithLimitOffsetTest() {
+
+ String[] retArray =
+ new String[] {
+ "14,14.0,14,14,null,null",
+ "15,15.0,15,15,null,null",
+ "16,16.0,16,16,null,null",
+ "17,17.0,17,17,null,null",
+ "18,18.0,18,18,null,null",
+ };
+
+ String[] columnNames = {"s1", "s2", "s3", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,s1,s2,s3,s4,s5 from table0 where device='d1' and time >= 9 and time <= 33 offset 5 limit 5")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectSomeAlignedWithValueFilterTest1() {
+
+ String[] retArray =
+ new String[] {
+ "1,1.0,true,aligned_test1",
+ "2,2.0,null,aligned_test2",
+ "4,4.0,true,aligned_test4",
+ "5,5.0,true,aligned_test5",
+ "6,6.0,true,null",
+ "7,7.0,false,aligned_test7",
+ "8,8.0,null,aligned_test8",
+ "9,9.0,false,aligned_test9",
+ "11,11.0,null,null",
+ "12,12.0,null,null",
+ "14,14.0,null,null",
+ "15,15.0,null,null",
+ "16,16.0,null,null",
+ "34,null,null,aligned_test34",
+ };
+
+ String[] columnNames = {"s1", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,s1,s4,s5 from table0 where device='d1' and s1 < 17.0 or s5 = 'aligned_test34'")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectSomeAlignedWithValueFilterTest2() {
+
+ String[] retArray =
+ new String[] {
+ "7,7.0,false", "9,9.0,false",
+ };
+
+ String[] columnNames = {"s1", "s4"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,s1,s4 from table0 where device='d1' and s1 < 19.0 and s4 = false")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectSomeAlignedWithTimeAndValueFilterTest() {
+
+ String[] retArray =
+ new String[] {
+ "23,230000.0,false,null",
+ "26,null,false,null",
+ "27,null,false,null",
+ "28,null,false,null",
+ "29,null,false,null",
+ "30,null,false,null",
+ };
+
+ String[] columnNames = {"s1", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,s1,s4,s5 from table0 where device='d1' and time >= 16 and time <= 34 and s4=false")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ // --------------------------Aggregation Query Without Value Filter---------------------------
+ @Ignore
+ @Test
+ public void countAllAlignedWithoutTimeFilterTest() {
+ String[] retArray = new String[] {"20", "29", "28", "19", "20"};
+ String[] columnNames = {
+ "count(d1.s1)", "count(d1.s2)", "count(d1.s3)", "count(d1.s4)", "count(d1.s5)"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet = statement.executeQuery("select count(*) from d1")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>(); // used to adjust result sequence
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ String[] ans = new String[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = resultSet.getString(index);
+ }
+ assertArrayEquals(retArray, ans);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countAllAlignedAndNonAlignedWithoutTimeFilterTest() {
+ String[] retArray = new String[] {"20", "29", "28", "19", "20", "19", "29", "28", "18", "19"};
+ String[] columnNames = {
+ "count(d1.s1)",
+ "count(d1.s2)",
+ "count(d1.s3)",
+ "count(d1.s4)",
+ "count(d1.s5)",
+ "count(d2.s1)",
+ "count(d2.s2)",
+ "count(d2.s3)",
+ "count(d2.s4)",
+ "count(d2.s5)"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet = statement.executeQuery("select count(*) from root.sg1.*")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ String[] ans = new String[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = resultSet.getString(index);
+ }
+ assertArrayEquals(retArray, ans);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countAllAlignedWithTimeFilterTest() {
+ String[] retArray = new String[] {"12", "15", "22", "13", "6"};
+ String[] columnNames = {
+ "count(d1.s1)", "count(d1.s2)", "count(d1.s3)", "count(d1.s4)", "count(d1.s5)"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery("select count(*) from d1 where time >= 9 and time <= 33")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ String[] ans = new String[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = resultSet.getString(index);
+ }
+ assertArrayEquals(retArray, ans);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ /** aggregate multi columns of aligned timeseries in one SQL */
+ @Ignore
+ @Test
+ public void aggregateSomeAlignedWithoutTimeFilterTest() {
+ double[] retArray =
+ new double[] {
+ 20, 29, 28, 390184, 130549, 390417, 19509.2, 4501.689655172413, 13943.464285714286
+ };
+ String[] columnNames = {
+ "count(d1.s1)",
+ "count(d1.s2)",
+ "count(d1.s3)",
+ "sum(d1.s1)",
+ "sum(d1.s2)",
+ "sum(d1.s3)",
+ "avg(d1.s1)",
+ "avg(d1.s2)",
+ "avg(d1.s3)",
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1),count(s2),count(s3),sum(s1),sum(s2),sum(s3),avg(s1),avg(s2),avg(s3) from d1")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ double[] ans = new double[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = Double.parseDouble(resultSet.getString(index));
+ }
+ assertArrayEquals(retArray, ans, DELTA);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ /** aggregate multi columns of aligned timeseries in one SQL */
+ @Ignore
+ @Test
+ public void aggregateSomeAlignedWithTimeFilterTest() {
+ double[] retArray =
+ new double[] {
+ 6, 9, 15, 230090, 220, 230322, 38348.333333333336, 24.444444444444443, 15354.8
+ };
+ String[] columnNames = {
+ "count(d1.s1)",
+ "count(d1.s2)",
+ "count(d1.s3)",
+ "sum(d1.s1)",
+ "sum(d1.s2)",
+ "sum(d1.s3)",
+ "avg(d1.s1)",
+ "avg(d1.s2)",
+ "avg(d1.s3)",
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1),count (s2),count (s3),sum(s1),sum(s2),sum(s3),avg(s1),avg(s2),avg(s3) from d1 where time>=16 and time<=34")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ double[] ans = new double[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = Double.parseDouble(resultSet.getString(index));
+ }
+ assertArrayEquals(retArray, ans, DELTA);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countSingleAlignedWithTimeFilterTest() {
+ String[] retArray = new String[] {"9"};
+ String[] columnNames = {"count(d1.s2)"};
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery("select count(s2) from d1 where time>=16 and time<=34")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ // No need to add time column for aggregation query
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ if (builder.length() != 0) {
+ builder.append(",");
+ }
+ builder.append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void sumSingleAlignedWithTimeFilterTest() {
+ String[] retArray = new String[] {"230322.0"};
+ String[] columnNames = {"sum(d1.s3)"};
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery("select sum(s3) from d1 where time>=16 and time<=34")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ // No need to add time column for aggregation query
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ if (builder.length() != 0) {
+ builder.append(",");
+ }
+ builder.append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void avgSingleAlignedWithTimeFilterTest() {
+ double[][] retArray = {{24.444444444444443}};
+ String[] columnNames = {"avg(d1.s2)"};
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery("select avg(s2) from d1 where time>=16 and time<=34")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ double[] ans = new double[columnNames.length];
+ StringBuilder builder = new StringBuilder();
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = Double.parseDouble(resultSet.getString(index));
+ }
+ assertArrayEquals(retArray[cnt], ans, DELTA);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ // --------------------------------Aggregation with value filter------------------------------
+ @Ignore
+ @Test
+ public void countAlignedWithValueFilterTest() {
+ String[] retArray = new String[] {"11"};
+ String[] columnNames = {"count(d1.s4)"};
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery("select count(s4) from d1 where s4 = true")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>(); // used to adjust result sequence
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ String[] ans = new String[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = resultSet.getString(index);
+ }
+ assertArrayEquals(retArray, ans);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void aggregationFuncAlignedWithValueFilterTest() throws ClassNotFoundException {
+ String[] retArray = new String[] {"8", "42.0", "5.25", "1.0", "9.0", "1", "9", "1.0", "9.0"};
+ String[] columnNames = {
+ "count(d1.s1)",
+ "sum(d1.s1)",
+ "avg(d1.s1)",
+ "first_value(d1.s1)",
+ "last_value(d1.s1)",
+ "min_time(d1.s1)",
+ "max_time(d1.s1)",
+ "min_value(d1.s1)",
+ "max_value(d1.s1)",
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1), sum(s1), avg(s1), "
+ + "first_value(s1), last_value(s1), "
+ + "min_time(s1), max_time(s1),"
+ + "max_value(s1), min_value(s1) from d1 where s1 < 10")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>(); // used to adjust result sequence
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ String[] ans = new String[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = resultSet.getString(index);
+ }
+ assertArrayEquals(retArray, ans);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countAllAlignedWithValueFilterTest() throws ClassNotFoundException {
+ String[] retArray = new String[] {"6", "6", "9", "11", "6"};
+ String[] columnNames = {
+ "count(d1.s1)", "count(d1.s2)", "count(d1.s3)", "count(d1.s4)", "count(d1.s5)"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery("select count(*) from d1 where s4 = true")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>(); // used to adjust result sequence
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ String[] ans = new String[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = resultSet.getString(index);
+ }
+ assertArrayEquals(retArray, ans);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void aggregationAllAlignedWithValueFilterTest() throws ClassNotFoundException {
+ String[] retArray = new String[] {"160016.0", "11", "1", "13"};
+ String[] columnNames = {
+ "sum(d1.s1)", "count(d1.s4)", "min_value(d1.s3)", "max_time(d1.s2)",
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select sum(s1), count(s4), min_value(s3), max_time(s2) from d1 where s4 = true")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>(); // used to adjust result sequence
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ String[] ans = new String[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = resultSet.getString(index);
+ }
+ assertArrayEquals(retArray, ans);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ // ---------------------------------Align by device query ------------------------------------
+ @Test
+ public void selectAllAlignedWithoutValueFilterAlignByDeviceTest() {
+ String[] retArray =
+ new String[] {
+ "1,d1,1.0,1,1,true,aligned_test1",
+ "2,d1,2.0,2,2,null,aligned_test2",
+ "3,d1,30000.0,null,30000,true,aligned_unseq_test3",
+ "4,d1,4.0,4,null,true,aligned_test4",
+ "5,d1,5.0,5,null,true,aligned_test5",
+ "6,d1,6.0,6,6,true,null",
+ "7,d1,7.0,7,7,false,aligned_test7",
+ "8,d1,8.0,8,8,null,aligned_test8",
+ "9,d1,9.0,9,9,false,aligned_test9",
+ "10,d1,null,10,10,true,aligned_test10",
+ "11,d1,11.0,11,11,null,null",
+ "12,d1,12.0,12,12,null,null",
+ "13,d1,130000.0,130000,130000,true,aligned_unseq_test13",
+ "14,d1,14.0,14,14,null,null",
+ "15,d1,15.0,15,15,null,null",
+ "16,d1,16.0,16,16,null,null",
+ "17,d1,17.0,17,17,null,null",
+ "18,d1,18.0,18,18,null,null",
+ "19,d1,19.0,19,19,null,null",
+ "20,d1,20.0,20,20,null,null",
+ "21,d1,null,null,21,true,null",
+ "22,d1,null,null,22,true,null",
+ "23,d1,230000.0,null,230000,false,null",
+ "24,d1,null,null,24,true,null",
+ "25,d1,null,null,25,true,null",
+ "26,d1,null,null,26,false,null",
+ "27,d1,null,null,27,false,null",
+ "28,d1,null,null,28,false,null",
+ "29,d1,null,null,29,false,null",
+ "30,d1,null,null,30,false,null",
+ "31,d1,null,31,null,null,aligned_test31",
+ "32,d1,null,32,null,null,aligned_test32",
+ "33,d1,null,33,null,null,aligned_test33",
+ "34,d1,null,34,null,null,aligned_test34",
+ "35,d1,null,35,null,null,aligned_test35",
+ "36,d1,null,36,null,null,aligned_test36",
+ "37,d1,null,37,null,null,aligned_test37",
+ "38,d1,null,38,null,null,aligned_test38",
+ "39,d1,null,39,null,null,aligned_test39",
+ "40,d1,null,40,null,null,aligned_test40",
+ };
+
+ String[] columnNames = {"device", "s1", "s2", "s3", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,device,s1,s2,s3,s4,s5 from table0 where device='d1' order by time")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectAllAlignedAndNonAlignedAlignByDeviceTest() {
+ String[] retArray =
+ new String[] {
+ "1,d1,1.0,1,1,true,aligned_test1",
+ "2,d1,2.0,2,2,null,aligned_test2",
+ "3,d1,30000.0,null,30000,true,aligned_unseq_test3",
+ "4,d1,4.0,4,null,true,aligned_test4",
+ "5,d1,5.0,5,null,true,aligned_test5",
+ "6,d1,6.0,6,6,true,null",
+ "7,d1,7.0,7,7,false,aligned_test7",
+ "8,d1,8.0,8,8,null,aligned_test8",
+ "9,d1,9.0,9,9,false,aligned_test9",
+ "10,d1,null,10,10,true,aligned_test10",
+ "11,d1,11.0,11,11,null,null",
+ "12,d1,12.0,12,12,null,null",
+ "13,d1,130000.0,130000,130000,true,aligned_unseq_test13",
+ "14,d1,14.0,14,14,null,null",
+ "15,d1,15.0,15,15,null,null",
+ "16,d1,16.0,16,16,null,null",
+ "17,d1,17.0,17,17,null,null",
+ "18,d1,18.0,18,18,null,null",
+ "19,d1,19.0,19,19,null,null",
+ "20,d1,20.0,20,20,null,null",
+ "21,d1,null,null,21,true,null",
+ "22,d1,null,null,22,true,null",
+ "23,d1,230000.0,null,230000,false,null",
+ "24,d1,null,null,24,true,null",
+ "25,d1,null,null,25,true,null",
+ "26,d1,null,null,26,false,null",
+ "27,d1,null,null,27,false,null",
+ "28,d1,null,null,28,false,null",
+ "29,d1,null,null,29,false,null",
+ "30,d1,null,null,30,false,null",
+ "31,d1,null,31,null,null,aligned_test31",
+ "32,d1,null,32,null,null,aligned_test32",
+ "33,d1,null,33,null,null,aligned_test33",
+ "34,d1,null,34,null,null,aligned_test34",
+ "35,d1,null,35,null,null,aligned_test35",
+ "36,d1,null,36,null,null,aligned_test36",
+ "37,d1,null,37,null,null,aligned_test37",
+ "38,d1,null,38,null,null,aligned_test38",
+ "39,d1,null,39,null,null,aligned_test39",
+ "40,d1,null,40,null,null,aligned_test40",
+ "1,d2,1.0,1,1,true,non_aligned_test1",
+ "2,d2,2.0,2,2,null,non_aligned_test2",
+ "3,d2,3.0,null,3,false,non_aligned_test3",
+ "4,d2,4.0,4,null,true,non_aligned_test4",
+ "5,d2,5.0,5,null,true,non_aligned_test5",
+ "6,d2,6.0,6,6,true,null",
+ "7,d2,7.0,7,7,false,non_aligned_test7",
+ "8,d2,8.0,8,8,null,non_aligned_test8",
+ "9,d2,9.0,9,9,false,non_aligned_test9",
+ "10,d2,null,10,10,true,non_aligned_test10",
+ "11,d2,11.0,11,11,null,null",
+ "12,d2,12.0,12,12,null,null",
+ "13,d2,13.0,13,13,null,null",
+ "14,d2,14.0,14,14,null,null",
+ "15,d2,15.0,15,15,null,null",
+ "16,d2,16.0,16,16,null,null",
+ "17,d2,17.0,17,17,null,null",
+ "18,d2,18.0,18,18,null,null",
+ "19,d2,19.0,19,19,null,null",
+ "20,d2,20.0,20,20,null,null",
+ "21,d2,null,null,21,true,null",
+ "22,d2,null,null,22,true,null",
+ "23,d2,null,null,23,true,null",
+ "24,d2,null,null,24,true,null",
+ "25,d2,null,null,25,true,null",
+ "26,d2,null,null,26,false,null",
+ "27,d2,null,null,27,false,null",
+ "28,d2,null,null,28,false,null",
+ "29,d2,null,null,29,false,null",
+ "30,d2,null,null,30,false,null",
+ "31,d2,null,31,null,null,non_aligned_test31",
+ "32,d2,null,32,null,null,non_aligned_test32",
+ "33,d2,null,33,null,null,non_aligned_test33",
+ "34,d2,null,34,null,null,non_aligned_test34",
+ "35,d2,null,35,null,null,non_aligned_test35",
+ "36,d2,null,36,null,null,non_aligned_test36",
+ "37,d2,null,37,null,null,non_aligned_test37",
+ "38,d2,null,38,null,null,non_aligned_test38",
+ "39,d2,null,39,null,null,non_aligned_test39",
+ "40,d2,null,40,null,null,non_aligned_test40",
+ };
+
+ String[] columnNames = {"device", "s1", "s2", "s3", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,device,s1,s2,s3,s4,s5 from table0 order by device, time")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectAllAlignedWithTimeFilterAlignByDeviceTest() {
+ String[] retArray =
+ new String[] {
+ "9,d1,9.0,9,9,false,aligned_test9",
+ "10,d1,null,10,10,true,aligned_test10",
+ "11,d1,11.0,11,11,null,null",
+ "12,d1,12.0,12,12,null,null",
+ "13,d1,130000.0,130000,130000,true,aligned_unseq_test13",
+ "14,d1,14.0,14,14,null,null",
+ "15,d1,15.0,15,15,null,null",
+ "16,d1,16.0,16,16,null,null",
+ "17,d1,17.0,17,17,null,null",
+ "18,d1,18.0,18,18,null,null",
+ "19,d1,19.0,19,19,null,null",
+ "20,d1,20.0,20,20,null,null",
+ "21,d1,null,null,21,true,null",
+ "22,d1,null,null,22,true,null",
+ "23,d1,230000.0,null,230000,false,null",
+ "24,d1,null,null,24,true,null",
+ "25,d1,null,null,25,true,null",
+ "26,d1,null,null,26,false,null",
+ "27,d1,null,null,27,false,null",
+ "28,d1,null,null,28,false,null",
+ "29,d1,null,null,29,false,null",
+ "30,d1,null,null,30,false,null",
+ "31,d1,null,31,null,null,aligned_test31",
+ "32,d1,null,32,null,null,aligned_test32",
+ "33,d1,null,33,null,null,aligned_test33",
+ };
+
+ String[] columnNames = {"device", "s1", "s2", "s3", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,device,s1,s2,s3,s4,s5 from table0 where device='d1' and time >= 9 and time <= 33 order by time")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectSomeAlignedWithoutValueFilterAlignByDeviceTest1() {
+ String[] retArray =
+ new String[] {
+ "1,d1,1.0,true,aligned_test1",
+ "2,d1,2.0,null,aligned_test2",
+ "3,d1,30000.0,true,aligned_unseq_test3",
+ "4,d1,4.0,true,aligned_test4",
+ "5,d1,5.0,true,aligned_test5",
+ "6,d1,6.0,true,null",
+ "7,d1,7.0,false,aligned_test7",
+ "8,d1,8.0,null,aligned_test8",
+ "9,d1,9.0,false,aligned_test9",
+ "10,d1,null,true,aligned_test10",
+ "11,d1,11.0,null,null",
+ "12,d1,12.0,null,null",
+ "13,d1,130000.0,true,aligned_unseq_test13",
+ "14,d1,14.0,null,null",
+ "15,d1,15.0,null,null",
+ "16,d1,16.0,null,null",
+ "17,d1,17.0,null,null",
+ "18,d1,18.0,null,null",
+ "19,d1,19.0,null,null",
+ "20,d1,20.0,null,null",
+ "21,d1,null,true,null",
+ "22,d1,null,true,null",
+ "23,d1,230000.0,false,null",
+ "24,d1,null,true,null",
+ "25,d1,null,true,null",
+ "26,d1,null,false,null",
+ "27,d1,null,false,null",
+ "28,d1,null,false,null",
+ "29,d1,null,false,null",
+ "30,d1,null,false,null",
+ "31,d1,null,null,aligned_test31",
+ "32,d1,null,null,aligned_test32",
+ "33,d1,null,null,aligned_test33",
+ "34,d1,null,null,aligned_test34",
+ "35,d1,null,null,aligned_test35",
+ "36,d1,null,null,aligned_test36",
+ "37,d1,null,null,aligned_test37",
+ "38,d1,null,null,aligned_test38",
+ "39,d1,null,null,aligned_test39",
+ "40,d1,null,null,aligned_test40",
+ };
+
+ String[] columnNames = {"device", "s1", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+
+ try (ResultSet resultSet =
+ statement.executeQuery("select Time,device,s1,s4,s5 from table0 where device='d1'")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectSomeAlignedWithoutValueFilterAlignByDeviceTest2() {
+ String[] retArray =
+ new String[] {
+ "1,d1,1.0,true",
+ "2,d1,2.0,null",
+ "3,d1,30000.0,true",
+ "4,d1,4.0,true",
+ "5,d1,5.0,true",
+ "6,d1,6.0,true",
+ "7,d1,7.0,false",
+ "8,d1,8.0,null",
+ "9,d1,9.0,false",
+ "10,d1,null,true",
+ "11,d1,11.0,null",
+ "12,d1,12.0,null",
+ "13,d1,130000.0,true",
+ "14,d1,14.0,null",
+ "15,d1,15.0,null",
+ "16,d1,16.0,null",
+ "17,d1,17.0,null",
+ "18,d1,18.0,null",
+ "19,d1,19.0,null",
+ "20,d1,20.0,null",
+ "21,d1,null,true",
+ "22,d1,null,true",
+ "23,d1,230000.0,false",
+ "24,d1,null,true",
+ "25,d1,null,true",
+ "26,d1,null,false",
+ "27,d1,null,false",
+ "28,d1,null,false",
+ "29,d1,null,false",
+ "30,d1,null,false",
+ "31,d1,null,null",
+ "32,d1,null,null",
+ "33,d1,null,null",
+ "34,d1,null,null",
+ "35,d1,null,null",
+ "36,d1,null,null",
+ "37,d1,null,null",
+ "38,d1,null,null",
+ "39,d1,null,null",
+ "40,d1,null,null",
+ };
+
+ String[] columnNames = {"Device", "s1", "s4"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery("select Time,Device,s1,s4 from table0 where device='d1'")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectSomeAlignedWithTimeFilterAlignByDeviceTest() {
+ String[] retArray =
+ new String[] {
+ "16,d1,16.0,null,null",
+ "17,d1,17.0,null,null",
+ "18,d1,18.0,null,null",
+ "19,d1,19.0,null,null",
+ "20,d1,20.0,null,null",
+ "21,d1,null,true,null",
+ "22,d1,null,true,null",
+ "23,d1,230000.0,false,null",
+ "24,d1,null,true,null",
+ "25,d1,null,true,null",
+ "26,d1,null,false,null",
+ "27,d1,null,false,null",
+ "28,d1,null,false,null",
+ "29,d1,null,false,null",
+ "30,d1,null,false,null",
+ "31,d1,null,null,aligned_test31",
+ "32,d1,null,null,aligned_test32",
+ "33,d1,null,null,aligned_test33",
+ "34,d1,null,null,aligned_test34",
+ };
+
+ String[] columnNames = {"Device", "s1", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,Device,s1,s4,s5 from table0 where device='d1' and time >= 16 and time <= 34 order by time")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectAllAlignedWithValueFilterAlignByDeviceTest1() {
+ String[] retArray =
+ new String[] {
+ "1,d1,1.0,1,1,true,aligned_test1",
+ "3,d1,30000.0,null,30000,true,aligned_unseq_test3",
+ "4,d1,4.0,4,null,true,aligned_test4",
+ "5,d1,5.0,5,null,true,aligned_test5",
+ "6,d1,6.0,6,6,true,null",
+ "10,d1,null,10,10,true,aligned_test10",
+ "13,d1,130000.0,130000,130000,true,aligned_unseq_test13",
+ "21,d1,null,null,21,true,null",
+ "22,d1,null,null,22,true,null",
+ "24,d1,null,null,24,true,null",
+ "25,d1,null,null,25,true,null",
+ };
+
+ String[] columnNames = {"Device", "s1", "s2", "s3", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,Device,s1,s2,s3,s4,s5 from table0 where device='d1' and s4 = true order by time")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectAllAlignedWithValueFilterAlignByDeviceTest2() {
+ String[] retArray =
+ new String[] {
+ "12,d1,12.0,12,12,null,null",
+ "14,d1,14.0,14,14,null,null",
+ "15,d1,15.0,15,15,null,null",
+ "16,d1,16.0,16,16,null,null",
+ "17,d1,17.0,17,17,null,null",
+ "18,d1,18.0,18,18,null,null",
+ "19,d1,19.0,19,19,null,null",
+ "20,d1,20.0,20,20,null,null",
+ };
+
+ String[] columnNames = {"Device", "s1", "s2", "s3", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,Device,s1,s2,s3,s4,s5 from table0 where device='d1' and s1 > 11.0 and s2 <= 33 order by time")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectAllAlignedWithTimeAndValueFilterAlignByDeviceTest1() {
+ String[] retArray =
+ new String[] {
+ "9,d1,9.0,9,9,false,aligned_test9",
+ "11,d1,11.0,11,11,null,null",
+ "12,d1,12.0,12,12,null,null",
+ "14,d1,14.0,14,14,null,null",
+ "15,d1,15.0,15,15,null,null",
+ "16,d1,16.0,16,16,null,null",
+ "17,d1,17.0,17,17,null,null",
+ "18,d1,18.0,18,18,null,null",
+ };
+
+ String[] columnNames = {"Device", "s1", "s2", "s3", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,Device,s1,s2,s3,s4,s5 from table0 where device='d1' and time >= 9 and time <= 33 and s1 < 19.0 order by time")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectSomeAlignedWithValueFilterAlignByDeviceTest1() {
+ String[] retArray =
+ new String[] {
+ "1,d1,1.0,true,aligned_test1",
+ "2,d1,2.0,null,aligned_test2",
+ "4,d1,4.0,true,aligned_test4",
+ "5,d1,5.0,true,aligned_test5",
+ "6,d1,6.0,true,null",
+ "7,d1,7.0,false,aligned_test7",
+ "8,d1,8.0,null,aligned_test8",
+ "9,d1,9.0,false,aligned_test9",
+ "11,d1,11.0,null,null",
+ "12,d1,12.0,null,null",
+ "14,d1,14.0,null,null",
+ "15,d1,15.0,null,null",
+ "16,d1,16.0,null,null",
+ "34,d1,null,null,aligned_test34",
+ };
+
+ String[] columnNames = {"Device", "s1", "s4", "s5"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,Device,s1,s4,s5 from table0 where device='d1' and s1 < 17.0 or s5 = 'aligned_test34' order by time")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void selectSomeAlignedWithValueFilterAlignByDeviceTest2() {
+ String[] retArray =
+ new String[] {
+ "7,d1,7.0,false", "9,d1,9.0,false",
+ };
+
+ String[] columnNames = {"Device", "s1", "s4"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(USE_DB);
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select Time,Device,s1,s4 from table0 where device='d1' and s1 < 19.0 and s4 = false order by time")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length + 1, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(resultSet.getLong(1));
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(",").append(resultSet.getString(index));
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countAllAlignedWithoutTimeFilterAlignByDeviceTest() {
+ String[] retArray = new String[] {"d1", "20", "29", "28", "19", "20"};
+ String[] columnNames = {
+ "Device", "count(s1)", "count(s2)", "count(s3)", "count(s4)", "count(s5)"
+ };
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery("select count(*) from d1 align by device")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>(); // used to adjust result sequence
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ String[] ans = new String[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = resultSet.getString(index);
+ }
+ assertArrayEquals(retArray, ans);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countAllAlignedAndNonAlignedWithoutTimeFilterAlignByDeviceTest() {
+ String[] retArray = new String[] {"d1,20,29,28,19,20,", "d2,19,29,28,18,19,"};
+ String[] columnNames = {
+ "Device", "count(s1)", "count(s2)", "count(s3)", "count(s4)", "count(s5)"
+ };
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery("select count(*) from root.sg1.* align by device")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ StringBuilder builder = new StringBuilder();
+ for (String columnName : columnNames) {
+ int index = map.get(columnName);
+ builder.append(resultSet.getString(index)).append(",");
+ }
+ assertEquals(retArray[cnt], builder.toString());
+ cnt++;
+ }
+ assertEquals(retArray.length, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countAllAlignedWithTimeFilterAlignByDeviceTest() {
+ String[] retArray = new String[] {"d1", "12", "15", "22", "13", "6"};
+ String[] columnNames = {
+ "Device", "count(s1)", "count(s2)", "count(s3)", "count(s4)", "count(s5)"
+ };
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(*) from d1 where time >= 9 and time <= 33 align by device")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ String[] ans = new String[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = resultSet.getString(index);
+ }
+ assertArrayEquals(retArray, ans);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ /** aggregate multi columns of aligned timeseries in one SQL */
+ @Ignore
+ @Test
+ public void aggregateSomeAlignedWithoutTimeFilterAlignByDeviceTest() {
+ double[] retArray =
+ new double[] {
+ 20, 29, 28, 390184, 130549, 390417, 19509.2, 4501.689655172413, 13943.464285714286
+ };
+ String[] columnNames = {
+ "Device",
+ "count(s1)",
+ "count(s2)",
+ "count(s3)",
+ "sum(s1)",
+ "sum(s2)",
+ "sum(s3)",
+ "avg(s1)",
+ "avg(s2)",
+ "avg(s3)",
+ };
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1),count(s2),count(s3),sum(s1),sum(s2),sum(s3),avg(s1),avg(s2),avg(s3) from d1 align by device")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>();
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ double[] ans = new double[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 1; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i - 1] = Double.parseDouble(resultSet.getString(index));
+ assertEquals(retArray[i - 1], ans[i - 1], DELTA);
+ }
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countAlignedWithValueFilterAlignByDeviceTest() {
+ String[] retArray = new String[] {"d1", "11"};
+ String[] columnNames = {"Device", "count(s4)"};
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery("select count(s4) from d1 where s4 = true align by device")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>(); // used to adjust result sequence
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ String[] ans = new String[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = resultSet.getString(index);
+ }
+ assertArrayEquals(retArray, ans);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void aggregationFuncAlignedWithValueFilterAlignByDeviceTest() {
+ String[] retArray =
+ new String[] {"d1", "8", "42.0", "5.25", "1.0", "9.0", "1", "9", "1.0", "9.0"};
+ String[] columnNames = {
+ "Device",
+ "count(s1)",
+ "sum(s1)",
+ "avg(s1)",
+ "first_value(s1)",
+ "last_value(s1)",
+ "min_time(s1)",
+ "max_time(s1)",
+ "min_value(s1)",
+ "max_value(s1)",
+ };
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1), sum(s1), avg(s1), "
+ + "first_value(s1), last_value(s1), "
+ + "min_time(s1), max_time(s1),"
+ + "max_value(s1), min_value(s1) from d1 where s1 < 10 "
+ + "align by device")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>(); // used to adjust result sequence
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ String[] ans = new String[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = resultSet.getString(index);
+ }
+ assertArrayEquals(retArray, ans);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countAllAlignedWithValueFilterAlignByDeviceTest() {
+ String[] retArray = new String[] {"d1", "6", "6", "9", "11", "6"};
+ String[] columnNames = {
+ "Device", "count(s1)", "count(s2)", "count(s3)", "count(s4)", "count(s5)"
+ };
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery("select count(*) from d1 where s4 = true " + "align by device")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>(); // used to adjust result sequence
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ String[] ans = new String[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = resultSet.getString(index);
+ }
+ assertArrayEquals(retArray, ans);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void aggregationAllAlignedWithValueFilterAlignByDeviceTest() {
+ String[] retArray = new String[] {"d1", "160016.0", "11", "1", "13"};
+ String[] columnNames = {
+ "Device", "sum(s1)", "count(s4)", "min_value(s3)", "max_time(s2)",
+ };
+
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select sum(s1), count(s4), min_value(s3), max_time(s2) from d1 where s4 = true "
+ + "align by device")) {
+ ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
+ Map<String, Integer> map = new HashMap<>(); // used to adjust result sequence
+ for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
+ map.put(resultSetMetaData.getColumnName(i), i);
+ }
+ assertEquals(columnNames.length, resultSetMetaData.getColumnCount());
+ int cnt = 0;
+ while (resultSet.next()) {
+ String[] ans = new String[columnNames.length];
+ // No need to add time column for aggregation query
+ for (int i = 0; i < columnNames.length; i++) {
+ String columnName = columnNames[i];
+ int index = map.get(columnName);
+ ans[i] = resultSet.getString(index);
+ }
+ assertArrayEquals(retArray, ans);
+ cnt++;
+ }
+ assertEquals(1, cnt);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countSumAvgGroupByTimeAlignByDeviceTest() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,d1,4,40.0,7.5",
+ "11,d1,10,130142.0,13014.2",
+ "21,d1,1,null,230000.0",
+ "31,d1,0,355.0,null"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1), sum(s2), avg(s1) from d1 "
+ + "where time > 5 GROUP BY ([1, 41), 10ms) align by device")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(ColumnHeaderConstant.DEVICE)
+ + ","
+ + resultSet.getString(count("s1"))
+ + ","
+ + resultSet.getString(sum("s2"))
+ + ","
+ + resultSet.getString(avg("s1"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void maxMinValueGroupByTimeAlignByDeviceTest() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,d1,10,6.0,10,6",
+ "11,d1,130000,11.0,20,11",
+ "21,d1,230000,230000.0,null,21",
+ "31,d1,null,null,40,null"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select max_value(s3), min_value(s1), max_time(s2), min_time(s3) from d1 "
+ + "where time > 5 GROUP BY ([1, 41), 10ms) align by device")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(ColumnHeaderConstant.DEVICE)
+ + ","
+ + resultSet.getString(maxValue("s3"))
+ + ","
+ + resultSet.getString(minValue("s1"))
+ + ","
+ + resultSet.getString(maxTime("s2"))
+ + ","
+ + resultSet.getString(minTime("s3"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void firstLastGroupByTimeAlignByDeviceTest() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,d1,null,null", "6,d1,true,aligned_test7",
+ "11,d1,true,aligned_unseq_test13", "16,d1,null,null",
+ "21,d1,true,null", "26,d1,false,null",
+ "31,d1,null,aligned_test31", "36,d1,null,aligned_test36"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select last_value(s4), first_value(s5) from d1 "
+ + "where time > 5 and time < 38 GROUP BY ([1, 41), 5ms) align by device")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(ColumnHeaderConstant.DEVICE)
+ + ","
+ + resultSet.getString(lastValue("s4"))
+ + ","
+ + resultSet.getString(firstValue("s5"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void groupByWithWildcardAlignByDeviceTest() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,d1,9,9,8,8,9,9.0,10,10,true,aligned_test10",
+ "11,d1,10,10,10,1,1,20.0,20,20,true,aligned_unseq_test13",
+ "21,d1,1,0,10,10,0,230000.0,null,30,false,null",
+ "31,d1,0,10,0,0,10,null,40,null,null,aligned_test40"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(*), last_value(*) from d1 GROUP BY ([1, 41), 10ms) align by device")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(ColumnHeaderConstant.DEVICE)
+ + ","
+ + resultSet.getString(count("s1"))
+ + ","
+ + resultSet.getString(count("s2"))
+ + ","
+ + resultSet.getString(count("s3"))
+ + ","
+ + resultSet.getString(count("s4"))
+ + ","
+ + resultSet.getString(count("s5"))
+ + ","
+ + resultSet.getString(lastValue("s1"))
+ + ","
+ + resultSet.getString(lastValue("s2"))
+ + ","
+ + resultSet.getString(lastValue("s3"))
+ + ","
+ + resultSet.getString(lastValue("s4"))
+ + ","
+ + resultSet.getString(lastValue("s5"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void groupByWithNonAlignedTimeseriesAlignByDeviceTest() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,d1,0,null,null",
+ "7,d1,3,34.0,8.0",
+ "13,d1,4,130045.0,32511.25",
+ "19,d1,2,39.0,19.5",
+ "25,d1,0,null,null",
+ "31,d1,0,130.0,null",
+ "37,d1,0,154.0,null",
+ "1,d2,0,null,null",
+ "7,d2,3,34.0,8.0",
+ "13,d2,4,58.0,14.5",
+ "19,d2,2,39.0,19.5",
+ "25,d2,0,null,null",
+ "31,d2,0,130.0,null",
+ "37,d2,0,154.0,null"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1), sum(s2), avg(s1) from root.sg1.* "
+ + "where time > 5 GROUP BY ([1, 41), 4ms, 6ms) align by device")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(ColumnHeaderConstant.DEVICE)
+ + ","
+ + resultSet.getString(count("s1"))
+ + ","
+ + resultSet.getString(sum("s2"))
+ + ","
+ + resultSet.getString(avg("s1"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countSumAvgPreviousFillAlignByDeviceTest() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,d1,4,40.0,7.5",
+ "11,d1,10,130142.0,13014.2",
+ "21,d1,1,130142.0,230000.0",
+ "31,d1,0,355.0,230000.0"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1), sum(s2), avg(s1) from d1 "
+ + "where time > 5 GROUP BY ([1, 41), 10ms) FILL (previous) align by device")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(ColumnHeaderConstant.DEVICE)
+ + ","
+ + resultSet.getString(count("s1"))
+ + ","
+ + resultSet.getString(sum("s2"))
+ + ","
+ + resultSet.getString(avg("s1"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countSumAvgValueFillAlignByDeviceTest() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,d1,1,3.0,30000.0",
+ "6,d1,4,40.0,7.5",
+ "11,d1,5,130052.0,26010.4",
+ "16,d1,5,90.0,18.0",
+ "21,d1,1,3.0,230000.0",
+ "26,d1,0,3.0,3.0",
+ "31,d1,0,3.0,3.0"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1), sum(s2), avg(s1) from d1 "
+ + "where s3 > 5 and time < 30 GROUP BY ([1, 36), 5ms) FILL (3) align by device")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(ColumnHeaderConstant.DEVICE)
+ + ","
+ + resultSet.getString(count("s1"))
+ + ","
+ + resultSet.getString(sum("s2"))
+ + ","
+ + resultSet.getString(avg("s1"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+ }
+ }
+
+ // --------------------------GroupByWithoutValueFilter--------------------------
+ @Ignore
+ @Test
+ public void countSumAvgGroupByTest1() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,4,40.0,7.5", "11,10,130142.0,13014.2", "21,1,null,230000.0", "31,0,355.0,null"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1), sum(s2), avg(s1) from d1 "
+ + "where time > 5 GROUP BY ([1, 41), 10ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count("d1.s1"))
+ + ","
+ + resultSet.getString(sum("d1.s2"))
+ + ","
+ + resultSet.getString(avg("d1.s1"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1), sum(s2), avg(s1) from d1 "
+ + " where time > 5 GROUP BY ([1, 41), 10ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count("d1.s1"))
+ + ","
+ + resultSet.getString(sum("d1.s2"))
+ + ","
+ + resultSet.getString(avg("d1.s1"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countSumAvgGroupByTest2() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,0,null,null", "6,4,40.0,7.5", "11,5,130052.0,26010.4", "16,5,90.0,18.0",
+ "21,1,null,230000.0", "26,0,null,null", "31,0,165.0,null", "36,0,73.0,null"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1), sum(s2), avg(s1) from d1 "
+ + "where time > 5 and time < 38 GROUP BY ([1, 41), 5ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count("d1.s1"))
+ + ","
+ + resultSet.getString(sum("d1.s2"))
+ + ","
+ + resultSet.getString(avg("d1.s1"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1), sum(s2), avg(s1) from d1 "
+ + " where time > 5 and time < 38 GROUP BY ([1, 41), 5ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count("d1.s1"))
+ + ","
+ + resultSet.getString(sum("d1.s2"))
+ + ","
+ + resultSet.getString(avg("d1.s1"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countSumAvgGroupByWithSlidingStepTest() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,0,null,null",
+ "7,3,34.0,8.0",
+ "13,4,130045.0,32511.25",
+ "19,2,39.0,19.5",
+ "25,0,null,null",
+ "31,0,130.0,null",
+ "37,0,154.0,null"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1), sum(s2), avg(s1) from d1 "
+ + "where time > 5 GROUP BY ([1, 41), 4ms, 6ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count("d1.s1"))
+ + ","
+ + resultSet.getString(sum("d1.s2"))
+ + ","
+ + resultSet.getString(avg("d1.s1"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(s1), sum(s2), avg(s1) from d1 "
+ + " where time > 5 GROUP BY ([1, 41), 4ms, 6ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count("d1.s1"))
+ + ","
+ + resultSet.getString(sum("d1.s2"))
+ + ","
+ + resultSet.getString(avg("d1.s1"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void countSumAvgGroupByWithNonAlignedTimeseriesTest() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,0,null,null,0,null,null",
+ "7,3,34.0,8.0,4,34.0,8.5",
+ "13,4,58.0,14.5,4,130045.0,14.5",
+ "19,2,39.0,19.5,4,39.0,20.5",
+ "25,0,null,null,4,null,26.5",
+ "31,0,130.0,null,0,130.0,null",
+ "37,0,154.0,null,0,154.0,null"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(d1.s1), sum(d2.s2), avg(d2.s1), count(d1.s3), sum(d1.s2), avg(d2.s3) "
+ + "from root.sg1 where time > 5 GROUP BY ([1, 41), 4ms, 6ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count("d1.s1"))
+ + ","
+ + resultSet.getString(sum("d2.s2"))
+ + ","
+ + resultSet.getString(avg("d2.s1"))
+ + ","
+ + resultSet.getString(count("d1.s3"))
+ + ","
+ + resultSet.getString(sum("d1.s2"))
+ + ","
+ + resultSet.getString(avg("d2.s3"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(d1.s1), sum(d2.s2), avg(d2.s1), count(d1.s3), sum(d1.s2), avg(d2.s3) "
+ + "from root.sg1 where time > 5 GROUP BY ([1, 41), 4ms, 6ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count("d1.s1"))
+ + ","
+ + resultSet.getString(sum("d2.s2"))
+ + ","
+ + resultSet.getString(avg("d2.s1"))
+ + ","
+ + resultSet.getString(count("d1.s3"))
+ + ","
+ + resultSet.getString(sum("d1.s2"))
+ + ","
+ + resultSet.getString(avg("d2.s3"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void maxMinValueTimeGroupByTest1() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,10,6.0,10,6",
+ "11,130000,11.0,20,11",
+ "21,230000,230000.0,null,21",
+ "31,null,null,40,null"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select max_value(s3), min_value(s1), max_time(s2), min_time(s3) from d1 "
+ + "where time > 5 GROUP BY ([1, 41), 10ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(maxValue("d1.s3"))
+ + ","
+ + resultSet.getString(minValue("d1.s1"))
+ + ","
+ + resultSet.getString(maxTime("d1.s2"))
+ + ","
+ + resultSet.getString(minTime("d1.s3"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select max_value(s3), min_value(s1), max_time(s2), min_time(s3) from d1 "
+ + " where time > 5 GROUP BY ([1, 41), 10ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(maxValue("d1.s3"))
+ + ","
+ + resultSet.getString(minValue("d1.s1"))
+ + ","
+ + resultSet.getString(maxTime("d1.s2"))
+ + ","
+ + resultSet.getString(minTime("d1.s3"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void maxMinValueTimeGroupByTest2() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,null,null,null,null",
+ "6,10,6.0,10,6",
+ "11,130000,11.0,15,11",
+ "16,20,16.0,20,16",
+ "21,230000,230000.0,null,21",
+ "26,30,null,null,26",
+ "31,null,null,35,null",
+ "36,null,null,37,null"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select max_value(s3), min_value(s1), max_time(s2), min_time(s3) from d1 "
+ + "where time > 5 and time < 38 GROUP BY ([1, 41), 5ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(maxValue("d1.s3"))
+ + ","
+ + resultSet.getString(minValue("d1.s1"))
+ + ","
+ + resultSet.getString(maxTime("d1.s2"))
+ + ","
+ + resultSet.getString(minTime("d1.s3"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select max_value(s3), min_value(s1), max_time(s2), min_time(s3) from d1 "
+ + " where time > 5 and time < 38 GROUP BY ([1, 41), 5ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(maxValue("d1.s3"))
+ + ","
+ + resultSet.getString(minValue("d1.s1"))
+ + ","
+ + resultSet.getString(maxTime("d1.s2"))
+ + ","
+ + resultSet.getString(minTime("d1.s3"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void maxMinValueTimeGroupByWithSlidingStepTest() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,null,null,null,null",
+ "7,10,7.0,10,7",
+ "13,130000,14.0,16,13",
+ "19,22,19.0,20,19",
+ "25,28,null,null,25",
+ "31,null,null,34,null",
+ "37,null,null,40,null"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select max_value(s3), min_value(s1), max_time(s2), min_time(s3) from d1 "
+ + "where time > 5 GROUP BY ([1, 41), 4ms, 6ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(maxValue("d1.s3"))
+ + ","
+ + resultSet.getString(minValue("d1.s1"))
+ + ","
+ + resultSet.getString(maxTime("d1.s2"))
+ + ","
+ + resultSet.getString(minTime("d1.s3"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select max_value(s3), min_value(s1), max_time(s2), min_time(s3) from d1 "
+ + " where time > 5 GROUP BY ([1, 41), 4ms, 6ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(maxValue("d1.s3"))
+ + ","
+ + resultSet.getString(minValue("d1.s1"))
+ + ","
+ + resultSet.getString(maxTime("d1.s2"))
+ + ","
+ + resultSet.getString(minTime("d1.s3"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void maxMinValueTimeGroupByWithNonAlignedTimeseriesTest() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,null,null,null,null,null,null,null,null",
+ "7,10,7.0,10,7,10,7.0,10,7",
+ "13,16,14.0,16,13,130000,13.0,16,13",
+ "19,22,19.0,20,19,22,19.0,20,19",
+ "25,28,null,null,25,28,null,null,25",
+ "31,null,null,34,null,null,null,34,null",
+ "37,null,null,37,null,null,null,37,null"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select max_value(d2.s3), min_value(d1.s1), max_time(d2.s2), min_time(d1.s3), "
+ + "max_value(d1.s3), min_value(d2.s1), max_time(d1.s2), min_time(d2.s3) "
+ + "from root.sg1 where time > 5 and time < 38 GROUP BY ([1, 41), 4ms, 6ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(maxValue("d2.s3"))
+ + ","
+ + resultSet.getString(minValue("d1.s1"))
+ + ","
+ + resultSet.getString(maxTime("d2.s2"))
+ + ","
+ + resultSet.getString(minTime("d1.s3"))
+ + ","
+ + resultSet.getString(maxValue("d1.s3"))
+ + ","
+ + resultSet.getString(minValue("d2.s1"))
+ + ","
+ + resultSet.getString(maxTime("d1.s2"))
+ + ","
+ + resultSet.getString(minTime("d2.s3"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select max_value(d2.s3), min_value(d1.s1), max_time(d2.s2), min_time(d1.s3), "
+ + "max_value(d1.s3), min_value(d2.s1), max_time(d1.s2), min_time(d2.s3) "
+ + "from root.sg1 where time > 5 and time < 38 GROUP BY ([1, 41), 4ms, 6ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(maxValue("d2.s3"))
+ + ","
+ + resultSet.getString(minValue("d1.s1"))
+ + ","
+ + resultSet.getString(maxTime("d2.s2"))
+ + ","
+ + resultSet.getString(minTime("d1.s3"))
+ + ","
+ + resultSet.getString(maxValue("d1.s3"))
+ + ","
+ + resultSet.getString(minValue("d2.s1"))
+ + ","
+ + resultSet.getString(maxTime("d1.s2"))
+ + ","
+ + resultSet.getString(minTime("d2.s3"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void firstLastGroupByTest1() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,true,aligned_test7",
+ "11,true,aligned_unseq_test13",
+ "21,false,null",
+ "31,null,aligned_test31"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select last_value(s4), first_value(s5) from d1 "
+ + "where time > 5 GROUP BY ([1, 41), 10ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(lastValue("d1.s4"))
+ + ","
+ + resultSet.getString(firstValue("d1.s5"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select last_value(s4), first_value(s5) from d1 "
+ + " where time > 5 GROUP BY ([1, 41), 10ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(lastValue("d1.s4"))
+ + ","
+ + resultSet.getString(firstValue("d1.s5"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void firstLastGroupByTest2() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,null,null", "6,true,aligned_test7", "11,true,aligned_unseq_test13", "16,null,null",
+ "21,true,null", "26,false,null", "31,null,aligned_test31", "36,null,aligned_test36"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select last_value(s4), first_value(s5) from d1 "
+ + "where time > 5 and time < 38 GROUP BY ([1, 41), 5ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(lastValue("d1.s4"))
+ + ","
+ + resultSet.getString(firstValue("d1.s5"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select last_value(s4), first_value(s5) from d1 "
+ + " where time > 5 and time < 38 GROUP BY ([1, 41), 5ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(lastValue("d1.s4"))
+ + ","
+ + resultSet.getString(firstValue("d1.s5"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void firstLastGroupByWithSlidingStepTest() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,null,null",
+ "7,true,aligned_test7",
+ "13,true,aligned_unseq_test13",
+ "19,true,null",
+ "25,false,null",
+ "31,null,aligned_test31",
+ "37,null,aligned_test37"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select last_value(s4), first_value(s5) from d1 "
+ + "where time > 5 and time < 38 GROUP BY ([1, 41), 4ms, 6ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(lastValue("d1.s4"))
+ + ","
+ + resultSet.getString(firstValue("d1.s5"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select last_value(s4), first_value(s5) from d1 "
+ + " where time > 5 and time < 38 GROUP BY ([1, 41), 4ms, 6ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(lastValue("d1.s4"))
+ + ","
+ + resultSet.getString(firstValue("d1.s5"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void firstLastGroupByWithNonAlignedTimeseriesTest() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,null,null,null,null",
+ "7,non_aligned_test10,false,aligned_test10,false",
+ "13,null,true,aligned_unseq_test13,null",
+ "19,null,true,null,true",
+ "25,null,true,null,true",
+ "31,non_aligned_test34,null,aligned_test34,null",
+ "37,non_aligned_test37,null,aligned_test37,null"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select last_value(d2.s5), first_value(d1.s4), last_value(d1.s5), first_value(d2.s4) "
+ + "from root.sg1 where time > 5 and time < 38 GROUP BY ([1, 41), 4ms, 6ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(lastValue("d2.s5"))
+ + ","
+ + resultSet.getString(firstValue("d1.s4"))
+ + ","
+ + resultSet.getString(lastValue("d1.s5"))
+ + ","
+ + resultSet.getString(firstValue("d2.s4"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select last_value(d2.s5), first_value(d1.s4), last_value(d1.s5), first_value(d2.s4) "
+ + "from root.sg1 where time > 5 and time < 38 "
+ + "GROUP BY ([1, 41), 4ms, 6ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(lastValue("d2.s5"))
+ + ","
+ + resultSet.getString(firstValue("d1.s4"))
+ + ","
+ + resultSet.getString(lastValue("d1.s5"))
+ + ","
+ + resultSet.getString(firstValue("d2.s4"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void groupByWithWildcardTest1() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,9,9,8,8,9,9.0,10,10,true,aligned_test10",
+ "11,10,10,10,1,1,20.0,20,20,true,aligned_unseq_test13",
+ "21,1,0,10,10,0,230000.0,null,30,false,null",
+ "31,0,10,0,0,10,null,40,null,null,aligned_test40"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(*), last_value(*) from d1 GROUP BY ([1, 41), 10ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count("d1.s1"))
+ + ","
+ + resultSet.getString(count("d1.s2"))
+ + ","
+ + resultSet.getString(count("d1.s3"))
+ + ","
+ + resultSet.getString(count("d1.s4"))
+ + ","
+ + resultSet.getString(count("d1.s5"))
+ + ","
+ + resultSet.getString(lastValue("d1.s1"))
+ + ","
+ + resultSet.getString(lastValue("d1.s2"))
+ + ","
+ + resultSet.getString(lastValue("d1.s3"))
+ + ","
+ + resultSet.getString(lastValue("d1.s4"))
+ + ","
+ + resultSet.getString(lastValue("d1.s5"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(*), last_value(*) from d1 "
+ + "GROUP BY ([1, 41), 10ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count("d1.s1"))
+ + ","
+ + resultSet.getString(count("d1.s2"))
+ + ","
+ + resultSet.getString(count("d1.s3"))
+ + ","
+ + resultSet.getString(count("d1.s4"))
+ + ","
+ + resultSet.getString(count("d1.s5"))
+ + ","
+ + resultSet.getString(lastValue("d1.s1"))
+ + ","
+ + resultSet.getString(lastValue("d1.s2"))
+ + ","
+ + resultSet.getString(lastValue("d1.s3"))
+ + ","
+ + resultSet.getString(lastValue("d1.s4"))
+ + ","
+ + resultSet.getString(lastValue("d1.s5"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void groupByWithWildcardTest2() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,0,0,0,0,0",
+ "5,2,2,2,2,1",
+ "9,2,3,3,2,2",
+ "13,3,3,3,1,1",
+ "17,3,3,3,0,0",
+ "21,1,0,3,3,0",
+ "25,0,0,3,3,0",
+ "29,0,1,2,2,1",
+ "33,0,3,0,0,3",
+ "37,0,1,0,0,1"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(*) from d1 "
+ + "where time > 5 and time < 38 GROUP BY ([1, 41), 3ms, 4ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count("d1.s1"))
+ + ","
+ + resultSet.getString(count("d1.s2"))
+ + ","
+ + resultSet.getString(count("d1.s3"))
+ + ","
+ + resultSet.getString(count("d1.s4"))
+ + ","
+ + resultSet.getString(count("d1.s5"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select count(*) from d1 "
+ + " where time > 5 and time < 38 GROUP BY ([1, 41), 3ms, 4ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count("d1.s1"))
+ + ","
+ + resultSet.getString(count("d1.s2"))
+ + ","
+ + resultSet.getString(count("d1.s3"))
+ + ","
+ + resultSet.getString(count("d1.s4"))
+ + ","
+ + resultSet.getString(count("d1.s5"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void groupByWithWildcardTest3() throws SQLException {
+ String[] retArray =
+ new String[] {
+ "1,null,null,null,null,null",
+ "5,7.0,7,7,false,aligned_test7",
+ "9,11.0,11,11,true,aligned_test10",
+ "13,15.0,15,15,true,aligned_unseq_test13",
+ "17,19.0,19,19,null,null",
+ "21,230000.0,null,230000,false,null",
+ "25,null,null,27,false,null",
+ "29,null,31,30,false,aligned_test31",
+ "33,null,35,null,null,aligned_test35",
+ "37,null,37,null,null,aligned_test37"
+ };
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ int cnt;
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select last_value(*) from d1 "
+ + "where time > 5 and time < 38 GROUP BY ([1, 41), 3ms, 4ms)")) {
+ cnt = 0;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(lastValue("d1.s1"))
+ + ","
+ + resultSet.getString(lastValue("d1.s2"))
+ + ","
+ + resultSet.getString(lastValue("d1.s3"))
+ + ","
+ + resultSet.getString(lastValue("d1.s4"))
+ + ","
+ + resultSet.getString(lastValue("d1.s5"));
+ Assert.assertEquals(retArray[cnt], ans);
+ cnt++;
+ }
+ Assert.assertEquals(retArray.length, cnt);
+ }
+
+ try (ResultSet resultSet =
+ statement.executeQuery(
+ "select last_value(*) from d1 "
+ + " where time > 5 and time < 38 GROUP BY ([1, 41), 3ms, 4ms) order by time desc")) {
+ cnt = retArray.length;
+ while (resultSet.next()) {
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(lastValue("d1.s1"))
+ + ","
+ + resultSet.getString(lastValue("d1.s2"))
+ + ","
+ + resultSet.getString(lastValue("d1.s3"))
+ + ","
+ + resultSet.getString(lastValue("d1.s4"))
+ + ","
+ + resultSet.getString(lastValue("d1.s5"));
+ Assert.assertEquals(retArray[cnt - 1], ans);
+ cnt--;
+ }
+ Assert.assertEquals(0, cnt);
+ }
+ }
+ }
+
+ @Ignore
+ @Test
+ public void groupByWithoutAggregationFuncTest() {
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ statement.executeQuery("select s1 from d1 group by ([0, 100), 5ms)");
+
+ fail("No expected exception thrown");
+ } catch (Exception e) {
+ Assert.assertTrue(
+ e.getMessage(),
+ e.getMessage()
+ .contains(
+ "Common queries and aggregated queries are not allowed to appear at the same time"));
+ }
+ }
+
+ @Ignore
+ @Test
+ public void negativeOrZeroTimeIntervalTest() {
+ try (Connection connection = EnvFactory.getEnv().getTableConnection();
+ Statement statement = connection.createStatement()) {
+
+ statement.executeQuery(
+ "select count(s1), sum(s2), avg(s1) from d1 "
+ + "where time > 5 GROUP BY ([1, 41), 0ms)");
+ fail();
+ } catch (Exception e) {
+ Assert.assertTrue(
+ e.getMessage(),
+ e.getMessage()
+ .contains("The second parameter time interval should be a positive integer."));
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBPredicatePushDownTableView2IT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBPredicatePushDownTableView2IT.java
new file mode 100644
index 00000000000..07234760680
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBPredicatePushDownTableView2IT.java
@@ -0,0 +1,54 @@
+/*
+ * 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.relational.it.query.view.old.aligned;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBPredicatePushDownTableView2IT extends IoTDBPredicatePushDownTableViewIT {
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv()
+ .getConfig()
+ .getCommonConfig()
+ .setEnableSeqSpaceCompaction(false)
+ .setEnableUnseqSpaceCompaction(false)
+ .setEnableCrossSpaceCompaction(false)
+ .setMaxTsBlockLineNumber(3)
+ .setMaxNumberOfPointsInPage(2);
+ EnvFactory.getEnv().initClusterEnvironment();
+ TableViewUtils.insertData();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBPredicatePushDownTableView3IT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBPredicatePushDownTableView3IT.java
new file mode 100644
index 00000000000..e7609acb0ed
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBPredicatePushDownTableView3IT.java
@@ -0,0 +1,54 @@
+/*
+ * 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.relational.it.query.view.old.aligned;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBPredicatePushDownTableView3IT extends IoTDBPredicatePushDownTableViewIT {
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv()
+ .getConfig()
+ .getCommonConfig()
+ .setEnableSeqSpaceCompaction(false)
+ .setEnableUnseqSpaceCompaction(false)
+ .setEnableCrossSpaceCompaction(false)
+ .setMaxTsBlockLineNumber(3)
+ .setMaxNumberOfPointsInPage(3);
+ EnvFactory.getEnv().initClusterEnvironment();
+ TableViewUtils.insertData();
+ }
+
+ @AfterClass
+ public static void tearDown() {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBPredicatePushDownTableView4IT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBPredicatePushDownTableView4IT.java
new file mode 100644
index 00000000000..3cb7dc34223
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBPredicatePushDownTableView4IT.java
@@ -0,0 +1,54 @@
+/*
+ * 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.relational.it.query.view.old.aligned;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBPredicatePushDownTableView4IT extends IoTDBPredicatePushDownTableViewIT {
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv()
+ .getConfig()
+ .getCommonConfig()
+ .setEnableSeqSpaceCompaction(false)
+ .setEnableUnseqSpaceCompaction(false)
+ .setEnableCrossSpaceCompaction(false)
+ .setMaxTsBlockLineNumber(3)
+ .setDegreeOfParallelism(4);
+ EnvFactory.getEnv().initClusterEnvironment();
+ TableViewUtils.insertData();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBPredicatePushDownTableViewIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBPredicatePushDownTableViewIT.java
new file mode 100644
index 00000000000..7a7a538c7a1
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/query/view/old/aligned/IoTDBPredicatePushDownTableViewIT.java
@@ -0,0 +1,744 @@
+/*
+ * 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.relational.it.query.view.old.aligned;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import static org.apache.iotdb.db.it.utils.TestUtils.tableResultSetEqualTest;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBPredicatePushDownTableViewIT {
+
+ private final String database = "db";
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ EnvFactory.getEnv()
+ .getConfig()
+ .getCommonConfig()
+ .setEnableSeqSpaceCompaction(false)
+ .setEnableUnseqSpaceCompaction(false)
+ .setEnableCrossSpaceCompaction(false)
+ .setMaxTsBlockLineNumber(3);
+ EnvFactory.getEnv().initClusterEnvironment();
+ TableViewUtils.insertData();
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanClusterEnvironment();
+ }
+
+ @Test
+ public void testAlignedRawDataAlignByTime1() {
+ String[] expectedHeader1 = new String[] {"Time", "s2", "s3"};
+ String[] retArray1 =
+ new String[] {
+ "1970-01-01T00:00:00.010Z,10,10,",
+ "1970-01-01T00:00:00.011Z,11,11,",
+ "1970-01-01T00:00:00.012Z,12,12,",
+ "1970-01-01T00:00:00.014Z,14,14,",
+ "1970-01-01T00:00:00.015Z,15,15,",
+ "1970-01-01T00:00:00.016Z,16,16,",
+ "1970-01-01T00:00:00.017Z,17,17,",
+ "1970-01-01T00:00:00.018Z,18,18,",
+ "1970-01-01T00:00:00.019Z,19,19,",
+ "1970-01-01T00:00:00.020Z,20,20,"
+ };
+ tableResultSetEqualTest(
+ "select Time,s2, s3 from table0 where device='d1' and s2 - 1 >= 9 and s2 < 30",
+ expectedHeader1,
+ retArray1,
+ database);
+
+ String[] expectedHeader2 = new String[] {"Time", "s3"};
+ String[] retArray2 =
+ new String[] {
+ "1970-01-01T00:00:00.010Z,10,",
+ "1970-01-01T00:00:00.011Z,11,",
+ "1970-01-01T00:00:00.012Z,12,",
+ "1970-01-01T00:00:00.014Z,14,",
+ "1970-01-01T00:00:00.015Z,15,",
+ "1970-01-01T00:00:00.016Z,16,",
+ "1970-01-01T00:00:00.017Z,17,",
+ "1970-01-01T00:00:00.018Z,18,",
+ "1970-01-01T00:00:00.019Z,19,",
+ "1970-01-01T00:00:00.020Z,20,"
+ };
+ tableResultSetEqualTest(
+ "select Time,s3 from table0 where device='d1' and s2 - 1 >= 9 and s2 < 30",
+ expectedHeader2,
+ retArray2,
+ database);
+
+ String[] expectedHeader3 = new String[] {"Time", "s2"};
+ String[] retArray3 =
+ new String[] {
+ "1970-01-01T00:00:00.010Z,10,",
+ "1970-01-01T00:00:00.011Z,11,",
+ "1970-01-01T00:00:00.012Z,12,",
+ "1970-01-01T00:00:00.014Z,14,",
+ "1970-01-01T00:00:00.015Z,15,",
+ "1970-01-01T00:00:00.016Z,16,",
+ "1970-01-01T00:00:00.017Z,17,",
+ "1970-01-01T00:00:00.018Z,18,",
+ "1970-01-01T00:00:00.019Z,19,",
+ "1970-01-01T00:00:00.020Z,20,"
+ };
+ tableResultSetEqualTest(
+ "select Time,s2 from table0 where device='d1' and s2 - 1 >= 9 and s2 < 30",
+ expectedHeader3,
+ retArray3,
+ database);
+
+ String[] expectedHeader4 = new String[] {"Time", "s2"};
+ String[] retArray4 =
+ new String[] {"1970-01-01T00:00:00.014Z,14,", "1970-01-01T00:00:00.015Z,15,"};
+ tableResultSetEqualTest(
+ "select Time,s2 from table0 where device='d1' and s2 - 1 >= 9 and s2 < 30 offset 3 limit 2",
+ expectedHeader4,
+ retArray4,
+ database);
+ }
+
+ @Test
+ public void testAlignedRawDataAlignByTime2() {
+ String[] expectedHeader1 = new String[] {"Time", "s2", "_col2"};
+ String[] retArray1 =
+ new String[] {
+ "1970-01-01T00:00:00.003Z,null,30001,",
+ "1970-01-01T00:00:00.013Z,130000,130001,",
+ "1970-01-01T00:00:00.016Z,16,17,",
+ "1970-01-01T00:00:00.017Z,17,18,",
+ "1970-01-01T00:00:00.018Z,18,19,",
+ "1970-01-01T00:00:00.019Z,19,20,",
+ "1970-01-01T00:00:00.020Z,20,21,",
+ "1970-01-01T00:00:00.021Z,null,22,",
+ "1970-01-01T00:00:00.022Z,null,23,",
+ "1970-01-01T00:00:00.023Z,null,230001,",
+ "1970-01-01T00:00:00.024Z,null,25,",
+ "1970-01-01T00:00:00.025Z,null,26,",
+ "1970-01-01T00:00:00.026Z,null,27,",
+ "1970-01-01T00:00:00.027Z,null,28,",
+ "1970-01-01T00:00:00.028Z,null,29,",
+ "1970-01-01T00:00:00.029Z,null,30,",
+ "1970-01-01T00:00:00.030Z,null,31,",
+ };
+ tableResultSetEqualTest(
+ "select Time,s2, s3 + 1 from table0 where device='d1' and s3 + 1 > 16",
+ expectedHeader1,
+ retArray1,
+ database);
+
+ String[] expectedHeader2 = new String[] {"Time", "s2"};
+ String[] retArray2 =
+ new String[] {
+ "1970-01-01T00:00:00.003Z,null,",
+ "1970-01-01T00:00:00.013Z,130000,",
+ "1970-01-01T00:00:00.016Z,16,",
+ "1970-01-01T00:00:00.017Z,17,",
+ "1970-01-01T00:00:00.018Z,18,",
+ "1970-01-01T00:00:00.019Z,19,",
+ "1970-01-01T00:00:00.020Z,20,",
+ "1970-01-01T00:00:00.021Z,null,",
+ "1970-01-01T00:00:00.022Z,null,",
+ "1970-01-01T00:00:00.023Z,null,",
+ "1970-01-01T00:00:00.024Z,null,",
+ "1970-01-01T00:00:00.025Z,null,",
+ "1970-01-01T00:00:00.026Z,null,",
+ "1970-01-01T00:00:00.027Z,null,",
+ "1970-01-01T00:00:00.028Z,null,",
+ "1970-01-01T00:00:00.029Z,null,",
+ "1970-01-01T00:00:00.030Z,null,",
+ };
+ tableResultSetEqualTest(
+ "select Time,s2 from table0 where device='d1' and s3 + 1 > 16",
+ expectedHeader2,
+ retArray2,
+ database);
+
+ String[] expectedHeader3 = new String[] {"Time", "s3"};
+ String[] retArray3 =
+ new String[] {
+ "1970-01-01T00:00:00.003Z,30000,",
+ "1970-01-01T00:00:00.013Z,130000,",
+ "1970-01-01T00:00:00.016Z,16,",
+ "1970-01-01T00:00:00.017Z,17,",
+ "1970-01-01T00:00:00.018Z,18,",
+ "1970-01-01T00:00:00.019Z,19,",
+ "1970-01-01T00:00:00.020Z,20,",
+ "1970-01-01T00:00:00.021Z,21,",
+ "1970-01-01T00:00:00.022Z,22,",
+ "1970-01-01T00:00:00.023Z,230000,",
+ "1970-01-01T00:00:00.024Z,24,",
+ "1970-01-01T00:00:00.025Z,25,",
+ "1970-01-01T00:00:00.026Z,26,",
+ "1970-01-01T00:00:00.027Z,27,",
+ "1970-01-01T00:00:00.028Z,28,",
+ "1970-01-01T00:00:00.029Z,29,",
+ "1970-01-01T00:00:00.030Z,30,",
+ };
+ tableResultSetEqualTest(
+ "select Time,s3 from table0 where device='d1' and s3 + 1 > 16",
+ expectedHeader3,
+ retArray3,
+ database);
+
+ String[] expectedHeader4 = new String[] {"Time", "s3"};
+ String[] retArray4 =
+ new String[] {
+ "1970-01-01T00:00:00.003Z,30000,",
+ "1970-01-01T00:00:00.013Z,130000,",
+ "1970-01-01T00:00:00.016Z,16,"
+ };
+ tableResultSetEqualTest(
+ "select Time,s3 from table0 where device='d1' and s3 + 1 > 16 limit 3",
+ expectedHeader4,
+ retArray4,
+ database);
+ }
+
+ @Test
+ public void testNonAlignedRawDataAlignByTime1() {
+ String[] expectedHeader1 = new String[] {"Time", "s2", "s3"};
+ String[] retArray1 =
+ new String[] {
+ "1970-01-01T00:00:00.010Z,10,10,",
+ "1970-01-01T00:00:00.011Z,11,11,",
+ "1970-01-01T00:00:00.012Z,12,12,",
+ "1970-01-01T00:00:00.013Z,13,13,",
+ "1970-01-01T00:00:00.014Z,14,14,",
+ "1970-01-01T00:00:00.015Z,15,15,",
+ "1970-01-01T00:00:00.016Z,16,16,",
+ "1970-01-01T00:00:00.017Z,17,17,",
+ "1970-01-01T00:00:00.018Z,18,18,",
+ "1970-01-01T00:00:00.019Z,19,19,",
+ "1970-01-01T00:00:00.020Z,20,20,"
+ };
+ tableResultSetEqualTest(
+ "select Time,s2, s3 from table0 where device='d2' and s2 - 1 >= 9 and s2 < 30",
+ expectedHeader1,
+ retArray1,
+ database);
+
+ String[] expectedHeader2 = new String[] {"Time", "s3"};
+ String[] retArray2 =
+ new String[] {
+ "1970-01-01T00:00:00.010Z,10,",
+ "1970-01-01T00:00:00.011Z,11,",
+ "1970-01-01T00:00:00.012Z,12,",
+ "1970-01-01T00:00:00.013Z,13,",
+ "1970-01-01T00:00:00.014Z,14,",
+ "1970-01-01T00:00:00.015Z,15,",
+ "1970-01-01T00:00:00.016Z,16,",
+ "1970-01-01T00:00:00.017Z,17,",
+ "1970-01-01T00:00:00.018Z,18,",
+ "1970-01-01T00:00:00.019Z,19,",
+ "1970-01-01T00:00:00.020Z,20,"
+ };
+ tableResultSetEqualTest(
+ "select Time,s3 from table0 where device='d2' and s2 - 1 >= 9 and s2 < 30",
+ expectedHeader2,
+ retArray2,
+ database);
+
+ String[] expectedHeader3 = new String[] {"Time", "s2"};
+ String[] retArray3 =
+ new String[] {
+ "1970-01-01T00:00:00.010Z,10,",
+ "1970-01-01T00:00:00.011Z,11,",
+ "1970-01-01T00:00:00.012Z,12,",
+ "1970-01-01T00:00:00.013Z,13,",
+ "1970-01-01T00:00:00.014Z,14,",
+ "1970-01-01T00:00:00.015Z,15,",
+ "1970-01-01T00:00:00.016Z,16,",
+ "1970-01-01T00:00:00.017Z,17,",
+ "1970-01-01T00:00:00.018Z,18,",
+ "1970-01-01T00:00:00.019Z,19,",
+ "1970-01-01T00:00:00.020Z,20,"
+ };
+ tableResultSetEqualTest(
+ "select Time,s2 from table0 where device='d2' and s2 - 1 >= 9 and s2 < 30",
+ expectedHeader3,
+ retArray3,
+ database);
+
+ String[] expectedHeader4 = new String[] {"Time", "s2"};
+ String[] retArray4 =
+ new String[] {
+ "1970-01-01T00:00:00.012Z,12,",
+ "1970-01-01T00:00:00.013Z,13,",
+ "1970-01-01T00:00:00.014Z,14,"
+ };
+ tableResultSetEqualTest(
+ "select Time,s2 from table0 where device='d2' and s2 - 1 >= 9 and s2 < 30 offset 2 limit 3",
+ expectedHeader4,
+ retArray4,
+ database);
+ }
+
+ @Test
+ public void testNonAlignedRawDataAlignByTime2() {
+ String[] expectedHeader1 = new String[] {"Time", "s2", "s3"};
+ String[] retArray1 =
+ new String[] {
+ "1970-01-01T00:00:00.016Z,16,16,",
+ "1970-01-01T00:00:00.017Z,17,17,",
+ "1970-01-01T00:00:00.018Z,18,18,",
+ "1970-01-01T00:00:00.019Z,19,19,",
+ "1970-01-01T00:00:00.020Z,20,20,",
+ "1970-01-01T00:00:00.021Z,null,21,",
+ "1970-01-01T00:00:00.022Z,null,22,",
+ "1970-01-01T00:00:00.023Z,null,23,",
+ "1970-01-01T00:00:00.024Z,null,24,",
+ "1970-01-01T00:00:00.025Z,null,25,",
+ "1970-01-01T00:00:00.026Z,null,26,",
+ "1970-01-01T00:00:00.027Z,null,27,",
+ "1970-01-01T00:00:00.028Z,null,28,",
+ "1970-01-01T00:00:00.029Z,null,29,",
+ "1970-01-01T00:00:00.030Z,null,30,",
+ };
+ tableResultSetEqualTest(
+ "select Time,s2, s3 from table0 where device='d2' and s3 + 1 > 16",
+ expectedHeader1,
+ retArray1,
+ database);
+
+ String[] expectedHeader2 = new String[] {"Time", "s2"};
+ String[] retArray2 =
+ new String[] {
+ "1970-01-01T00:00:00.016Z,16,",
+ "1970-01-01T00:00:00.017Z,17,",
+ "1970-01-01T00:00:00.018Z,18,",
+ "1970-01-01T00:00:00.019Z,19,",
+ "1970-01-01T00:00:00.020Z,20,",
+ "1970-01-01T00:00:00.021Z,null,",
+ "1970-01-01T00:00:00.022Z,null,",
+ "1970-01-01T00:00:00.023Z,null,",
+ "1970-01-01T00:00:00.024Z,null,",
+ "1970-01-01T00:00:00.025Z,null,",
+ "1970-01-01T00:00:00.026Z,null,",
+ "1970-01-01T00:00:00.027Z,null,",
+ "1970-01-01T00:00:00.028Z,null,",
+ "1970-01-01T00:00:00.029Z,null,",
+ "1970-01-01T00:00:00.030Z,null,",
+ };
+ tableResultSetEqualTest(
+ "select Time,s2 from table0 where device='d2' and s3 + 1 > 16",
+ expectedHeader2,
+ retArray2,
+ database);
+
+ String[] expectedHeader3 = new String[] {"Time", "s3"};
+ String[] retArray3 =
+ new String[] {
+ "1970-01-01T00:00:00.016Z,16,",
+ "1970-01-01T00:00:00.017Z,17,",
+ "1970-01-01T00:00:00.018Z,18,",
+ "1970-01-01T00:00:00.019Z,19,",
+ "1970-01-01T00:00:00.020Z,20,",
+ "1970-01-01T00:00:00.021Z,21,",
+ "1970-01-01T00:00:00.022Z,22,",
+ "1970-01-01T00:00:00.023Z,23,",
+ "1970-01-01T00:00:00.024Z,24,",
+ "1970-01-01T00:00:00.025Z,25,",
+ "1970-01-01T00:00:00.026Z,26,",
+ "1970-01-01T00:00:00.027Z,27,",
+ "1970-01-01T00:00:00.028Z,28,",
+ "1970-01-01T00:00:00.029Z,29,",
+ "1970-01-01T00:00:00.030Z,30,",
+ };
+ tableResultSetEqualTest(
+ "select Time,s3 from table0 where device='d2' and s3 + 1 > 16",
+ expectedHeader3,
+ retArray3,
+ database);
+
+ String[] expectedHeader4 = new String[] {"Time", "s3"};
+ String[] retArray4 =
+ new String[] {
+ "1970-01-01T00:00:00.026Z,26,",
+ "1970-01-01T00:00:00.027Z,27,",
+ "1970-01-01T00:00:00.028Z,28,",
+ "1970-01-01T00:00:00.029Z,29,",
+ "1970-01-01T00:00:00.030Z,30,",
+ };
+ tableResultSetEqualTest(
+ "select Time,s3 from table0 where device='d2' and s3 + 1 > 16 offset 10",
+ expectedHeader4,
+ retArray4,
+ database);
+ }
+
+ @Ignore
+ @Test
+ public void testAlignedAggregationAlignByTime1() {
+ String[] expectedHeader1 = new String[] {"count(d1.s2),count(d1.s3),"};
+ String[] retArray1 =
+ new String[] {
+ "10,10,",
+ };
+ tableResultSetEqualTest(
+ "select count(s2), count(s3) from d1 where s2 - 1 >= 9 and s2 < 30",
+ expectedHeader1,
+ retArray1,
+ database);
+
+ String[] expectedHeader2 = new String[] {"count(d1.s3),"};
+ String[] retArray2 = new String[] {"10,"};
+ tableResultSetEqualTest(
+ "select count(s3) from d1 where s2 - 1 >= 9 and s2 < 30",
+ expectedHeader2,
+ retArray2,
+ database);
+
+ String[] expectedHeader3 = new String[] {"count(d1.s2),"};
+ String[] retArray3 =
+ new String[] {
+ "10,",
+ };
+ tableResultSetEqualTest(
+ "select count(s2) from d1 where s2 - 1 >= 9 and s2 < 30",
+ expectedHeader3,
+ retArray3,
+ database);
+ }
+
+ // @Ignore
+ // @Test
+ // public void testAlignedAggregationAlignByTime2() {
+ // String[] expectedHeader1 = new String[]{"count(d1.s2),count(d1.s3 + 1),"};
+ // String[] retArray1 =
+ // new String[] {
+ // "6,17,",
+ // };
+ // tableResultSetEqualTest(
+ // "select count(s2), count(s3 + 1) from d1 where s3 + 1 > 16",
+ // expectedHeader1,
+ // retArray1, database);
+ //
+ // String[] expectedHeader2 = "count(d1.s2),";
+ // String[] retArray2 =
+ // new String[] {
+ // "6,",
+ // };
+ // tableResultSetEqualTest(
+ // "select count(s2) from d1 where s3 + 1 > 16", expectedHeader2, retArray2, database);
+ //
+ // String[] expectedHeader3 = "count(d1.s3),";
+ // String[] retArray3 =
+ // new String[] {
+ // "17,",
+ // };
+ // tableResultSetEqualTest(
+ // "select count(s3) from d1 where s3 + 1 > 16", expectedHeader3, retArray3, database);
+ // }
+ //
+ // @Ignore
+ // @Test
+ // public void testNonAlignedAggregationAlignByTime1() {
+ // String[] expectedHeader1 = "count(d2.s2),count(d2.s3),";
+ // String[] retArray1 = new String[] {"11,11,"};
+ // tableResultSetEqualTest(
+ // "select count(s2), count(s3) from d2 where s2 - 1 >= 9 and s2 < 30",
+ // expectedHeader1,
+ // retArray1, database);
+ //
+ // String[] expectedHeader2 = "count(d2.s3),";
+ // String[] retArray2 = new String[] {"11,"};
+ // tableResultSetEqualTest(
+ // "select count(s3) from d2 where s2 - 1 >= 9 and s2 < 30",
+ // expectedHeader2,
+ // retArray2, database);
+ //
+ // String[] expectedHeader3 = "count(d2.s2),";
+ // String[] retArray3 = new String[] {"11,"};
+ // tableResultSetEqualTest(
+ // "select count(s2) from d2 where s2 - 1 >= 9 and s2 < 30",
+ // expectedHeader3,
+ // retArray3, database);
+ // }
+ //
+ // @Ignore
+ // @Test
+ // public void testNonAlignedAggregationAlignByTime2() {
+ // String[] expectedHeader1 = "count(d2.s2),count(d2.s3),";
+ // String[] retArray1 =
+ // new String[] {
+ // "5,15,",
+ // };
+ // tableResultSetEqualTest(
+ // "select count(s2), count(s3) from d2 where s3 + 1 > 16",
+ // expectedHeader1,
+ // retArray1, database);
+ //
+ // String[] expectedHeader2 = "count(d2.s2),";
+ // String[] retArray2 =
+ // new String[] {
+ // "5,",
+ // };
+ // tableResultSetEqualTest(
+ // "select count(s2) from d2 where s3 + 1 > 16", expectedHeader2, retArray2, database);
+ //
+ // String[] expectedHeader3 = "count(d2.s3),";
+ // String[] retArray3 =
+ // new String[] {
+ // "15,",
+ // };
+ // tableResultSetEqualTest(
+ // "select count(s3) from d2 where s3 + 1 > 16", expectedHeader3, retArray3, database);
+ // }
+ //
+ // @Ignore
+ // @Test
+ // public void testMixAggregationAlignByTime() {
+ // String[] expectedHeader1 =
+ // "count(d1.s2),count(d2.s2),count(d1.s3),count(d2.s3),";
+ // String[] retArray1 =
+ // new String[] {
+ // "10,10,10,10,",
+ // };
+ // tableResultSetEqualTest(
+ // "select count(s2), count(s3) from d1, d2 where s2 - 1 >= 9 and s2 < 30",
+ // expectedHeader1,
+ // retArray1, database);
+ // }
+ //
+ // @Ignore
+ // @Test
+ // public void testAlignedGroupByTimeAlignByTime1() {
+ // String[] expectedHeader = "Time,count(d1.s2),sum(d1.s3),";
+ // String[] retArray = new String[] {"1,1,10.0,", "11,9,142.0,", "21,0,null,", "31,0,null,"};
+ // tableResultSetEqualTest(
+ // "select count(s2), sum(s3) from d1 where s2 - 1 >= 9 and s2 < 30 group by ([1, 41),
+ // 10ms)",
+ // expectedHeader,
+ // retArray, database);
+ // }
+ //
+ // @Ignore
+ // @Test
+ // public void testAlignedGroupByTimeAlignByTime2() {
+ // String[] expectedHeader = "Time,count(d1.s2),sum(d1.s3),";
+ // String[] retArray =
+ // new String[] {"1,0,30000.0,", "11,6,130090.0,", "21,0,230232.0,", "31,0,null,"};
+ // tableResultSetEqualTest(
+ // "select count(s2), sum(s3) from d1 where s3 + 1 > 16 group by ([1, 41), 10ms)",
+ // expectedHeader,
+ // retArray, database);
+ // }
+ //
+ // @Ignore
+ // @Test
+ // public void testNonAlignedGroupByTimeAlignByTime1() {
+ // String[] expectedHeader = "Time,count(d2.s2),sum(d2.s3 + 1),";
+ // String[] retArray = new String[] {"1,1,11.0,", "11,10,165.0,", "21,0,null,", "31,0,null,"};
+ // tableResultSetEqualTest(
+ // "select count(s2), sum(s3 + 1) from d2 where s2 - 1 >= 9 and s2 < 30 group by ([1, 41),
+ // 10ms)",
+ // expectedHeader,
+ // retArray, database);
+ // }
+ //
+ // @Ignore
+ // @Test
+ // public void testNonAlignedGroupByTimeAlignByTime2() {
+ // String[] expectedHeader = "Time,count(d2.s2),sum(d2.s3),";
+ // String[] retArray = new String[] {"1,0,null,", "11,5,90.0,", "21,0,255.0,", "31,0,null,"};
+ // tableResultSetEqualTest(
+ // "select count(s2), sum(s3) from d2 where s3 + 1 > 16 group by ([1, 41), 10ms)",
+ // expectedHeader,
+ // retArray, database);
+ // }
+ //
+ // @Ignore
+ // @Test
+ // public void testMixGroupByTimeAlignByTime() {
+ // String[] expectedHeader =
+ // "Time,count(d1.s2),count(d2.s2),sum(d1.s3),sum(d2.s3),";
+ // String[] retArray =
+ // new String[] {
+ // "1,1,1,10.0,10.0,", "11,9,9,142.0,142.0,", "21,0,0,null,null,", "31,0,0,null,null,"
+ // };
+ // tableResultSetEqualTest(
+ // "select count(s2), sum(s3) from d1, d2 where s2 - 1 >= 9 and s2 < 30 group by ([1, 41),
+ // 10ms)",
+ // expectedHeader,
+ // retArray, database);
+ // }
+
+ @Test
+ public void testRawDataAlignByDevice1() {
+ String[] expectedHeader = new String[] {"Time", "Device", "s2", "s3"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.010Z,d2,10,10,",
+ "1970-01-01T00:00:00.011Z,d2,11,11,",
+ "1970-01-01T00:00:00.012Z,d2,12,12,",
+ "1970-01-01T00:00:00.013Z,d2,13,13,",
+ "1970-01-01T00:00:00.014Z,d2,14,14,",
+ "1970-01-01T00:00:00.015Z,d2,15,15,",
+ "1970-01-01T00:00:00.016Z,d2,16,16,",
+ "1970-01-01T00:00:00.017Z,d2,17,17,",
+ "1970-01-01T00:00:00.018Z,d2,18,18,",
+ "1970-01-01T00:00:00.019Z,d2,19,19,",
+ "1970-01-01T00:00:00.020Z,d2,20,20,",
+ "1970-01-01T00:00:00.010Z,d1,10,10,",
+ "1970-01-01T00:00:00.011Z,d1,11,11,",
+ "1970-01-01T00:00:00.012Z,d1,12,12,",
+ "1970-01-01T00:00:00.014Z,d1,14,14,",
+ "1970-01-01T00:00:00.015Z,d1,15,15,",
+ "1970-01-01T00:00:00.016Z,d1,16,16,",
+ "1970-01-01T00:00:00.017Z,d1,17,17,",
+ "1970-01-01T00:00:00.018Z,d1,18,18,",
+ "1970-01-01T00:00:00.019Z,d1,19,19,",
+ "1970-01-01T00:00:00.020Z,d1,20,20,",
+ };
+ tableResultSetEqualTest(
+ "select Time, Device,s2, s3 from table0 where s2 - 1 >= 9 and s2 < 30 order by device desc",
+ expectedHeader,
+ retArray,
+ database);
+ }
+
+ @Test
+ public void testRawDataAlignByDevice2() {
+ String[] expectedHeader = new String[] {"Time", "Device", "s2", "_col3"};
+ String[] retArray =
+ new String[] {
+ "1970-01-01T00:00:00.003Z,d1,null,30001,",
+ "1970-01-01T00:00:00.013Z,d1,130000,130001,",
+ "1970-01-01T00:00:00.016Z,d1,16,17,",
+ "1970-01-01T00:00:00.017Z,d1,17,18,",
+ "1970-01-01T00:00:00.018Z,d1,18,19,",
+ "1970-01-01T00:00:00.019Z,d1,19,20,",
+ "1970-01-01T00:00:00.020Z,d1,20,21,",
+ "1970-01-01T00:00:00.021Z,d1,null,22,",
+ "1970-01-01T00:00:00.022Z,d1,null,23,",
+ "1970-01-01T00:00:00.023Z,d1,null,230001,",
+ "1970-01-01T00:00:00.024Z,d1,null,25,",
+ "1970-01-01T00:00:00.025Z,d1,null,26,",
+ "1970-01-01T00:00:00.026Z,d1,null,27,",
+ "1970-01-01T00:00:00.027Z,d1,null,28,",
+ "1970-01-01T00:00:00.028Z,d1,null,29,",
+ "1970-01-01T00:00:00.029Z,d1,null,30,",
+ "1970-01-01T00:00:00.030Z,d1,null,31,",
+ "1970-01-01T00:00:00.016Z,d2,16,17,",
+ "1970-01-01T00:00:00.017Z,d2,17,18,",
+ "1970-01-01T00:00:00.018Z,d2,18,19,",
+ "1970-01-01T00:00:00.019Z,d2,19,20,",
+ "1970-01-01T00:00:00.020Z,d2,20,21,",
+ "1970-01-01T00:00:00.021Z,d2,null,22,",
+ "1970-01-01T00:00:00.022Z,d2,null,23,",
+ "1970-01-01T00:00:00.023Z,d2,null,24,",
+ "1970-01-01T00:00:00.024Z,d2,null,25,",
+ "1970-01-01T00:00:00.025Z,d2,null,26,",
+ "1970-01-01T00:00:00.026Z,d2,null,27,",
+ "1970-01-01T00:00:00.027Z,d2,null,28,",
+ "1970-01-01T00:00:00.028Z,d2,null,29,",
+ "1970-01-01T00:00:00.029Z,d2,null,30,",
+ "1970-01-01T00:00:00.030Z,d2,null,31,",
+ };
+ tableResultSetEqualTest(
+ "select Time,Device,s2, s3 + 1 from table0 where s3 + 1 > 16 order by device",
+ expectedHeader,
+ retArray,
+ database);
+ }
+
+ @Ignore
+ @Test
+ public void testAggregationAlignByDevice1() {
+ String[] expectedHeader = new String[] {"Device,count(s2),sum(s3),"};
+ String[] retArray = new String[] {"d2,11,165.0,", "d1,10,152.0,"};
+ tableResultSetEqualTest(
+ "select count(s2), sum(s3) from d1, d2 where s2 - 1 >= 9 and s2 < 30 order by device desc align by device",
+ expectedHeader,
+ retArray,
+ database);
+ }
+
+ @Ignore
+ @Test
+ public void testAggregationAlignByDevice2() {
+ String[] expectedHeader = new String[] {"Device,count(s2),sum(s3 + 1),"};
+ String[] retArray = new String[] {"d1,6,390339.0,", "d2,5,360.0,"};
+ tableResultSetEqualTest(
+ "select count(s2), sum(s3 + 1) from d1, d2 where s3 + 1 > 16 align by device",
+ expectedHeader,
+ retArray,
+ database);
+ }
+
+ @Ignore
+ @Test
+ public void testGroupByTimeAlignByDevice1() {
+ String[] expectedHeader = new String[] {"Time,Device,count(s2),sum(s3),"};
+ String[] retArray =
+ new String[] {
+ "1,d2,1,10.0,",
+ "11,d2,10,155.0,",
+ "21,d2,0,null,",
+ "31,d2,0,null,",
+ "1,d1,1,10.0,",
+ "11,d1,9,142.0,",
+ "21,d1,0,null,",
+ "31,d1,0,null,"
+ };
+ tableResultSetEqualTest(
+ "select count(s2), sum(s3) from d1, d2 where s2 - 1 >= 9 and s2 < 30 group by ([1, 41), 10ms) order by device desc align by device",
+ expectedHeader,
... 16560 lines suppressed ...