You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by hx...@apache.org on 2021/06/06 01:38:21 UTC
[iotdb] branch rel/0.11 updated: fix low-quality IT codes in
IoTDBAggregationIT
This is an automated email from the ASF dual-hosted git repository.
hxd pushed a commit to branch rel/0.11
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/rel/0.11 by this push:
new f308773 fix low-quality IT codes in IoTDBAggregationIT
f308773 is described below
commit f30877392f57e3255176e7f1d6a6194e64f184a5
Author: xiangdong huang <sa...@gmail.com>
AuthorDate: Sun Jun 6 09:37:44 2021 +0800
fix low-quality IT codes in IoTDBAggregationIT
---
.../iotdb/db/integration/IoTDBAggregationIT.java | 790 +++++++++++++--------
1 file changed, 478 insertions(+), 312 deletions(-)
diff --git a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBAggregationIT.java b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBAggregationIT.java
index 3d8f1b5..219e537 100644
--- a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBAggregationIT.java
+++ b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBAggregationIT.java
@@ -19,23 +19,6 @@
package org.apache.iotdb.db.integration;
-import static org.apache.iotdb.db.constant.TestConstant.avg;
-import static org.apache.iotdb.db.constant.TestConstant.count;
-import static org.apache.iotdb.db.constant.TestConstant.first_value;
-import static org.apache.iotdb.db.constant.TestConstant.last_value;
-import static org.apache.iotdb.db.constant.TestConstant.max_time;
-import static org.apache.iotdb.db.constant.TestConstant.max_value;
-import static org.apache.iotdb.db.constant.TestConstant.min_time;
-import static org.apache.iotdb.db.constant.TestConstant.min_value;
-import static org.apache.iotdb.db.constant.TestConstant.sum;
-import static org.junit.Assert.fail;
-
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
-import java.util.Locale;
import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.engine.compaction.CompactionStrategy;
import org.apache.iotdb.db.utils.EnvironmentUtils;
@@ -45,56 +28,68 @@ import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Locale;
+
+import static org.apache.iotdb.db.constant.TestConstant.*;
+import static org.junit.Assert.fail;
+
public class IoTDBAggregationIT {
private static final String TIMESTAMP_STR = "Time";
private static final String TEMPERATURE_STR = "root.ln.wf01.wt01.temperature";
- private static String[] creationSqls = new String[]{
- "SET STORAGE GROUP TO root.vehicle.d0",
- "SET STORAGE GROUP TO root.vehicle.d1",
-
- "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"
- };
- private static String[] dataSet2 = new String[]{
- "SET STORAGE GROUP TO root.ln.wf01.wt01",
- "CREATE TIMESERIES root.ln.wf01.wt01.status WITH DATATYPE=BOOLEAN, ENCODING=PLAIN",
- "CREATE TIMESERIES root.ln.wf01.wt01.temperature WITH DATATYPE=FLOAT, ENCODING=PLAIN",
- "CREATE TIMESERIES root.ln.wf01.wt01.hardware WITH DATATYPE=INT32, ENCODING=PLAIN",
- "INSERT INTO root.ln.wf01.wt01(timestamp,temperature,status, hardware) "
- + "values(1, 1.1, false, 11)",
- "INSERT INTO root.ln.wf01.wt01(timestamp,temperature,status, hardware) "
- + "values(2, 2.2, true, 22)",
- "INSERT INTO root.ln.wf01.wt01(timestamp,temperature,status, hardware) "
- + "values(3, 3.3, false, 33 )",
- "INSERT INTO root.ln.wf01.wt01(timestamp,temperature,status, hardware) "
- + "values(4, 4.4, false, 44)",
- "INSERT INTO root.ln.wf01.wt01(timestamp,temperature,status, hardware) "
- + "values(5, 5.5, false, 55)"
- };
- private static String[] dataSet3 = new String[]{
- "SET STORAGE GROUP TO root.sg",
- "CREATE TIMESERIES root.sg.d1.s1 WITH DATATYPE=INT32, ENCODING=RLE",
- "insert into root.sg.d1(timestamp,s1) values(5,5)",
- "insert into root.sg.d1(timestamp,s1) values(12,12)",
- "flush",
- "insert into root.sg.d1(timestamp,s1) values(15,15)",
- "insert into root.sg.d1(timestamp,s1) values(25,25)",
- "flush",
- "insert into root.sg.d1(timestamp,s1) values(1,111)",
- "insert into root.sg.d1(timestamp,s1) values(20,200)",
- "flush"
- };
+ private static String[] creationSqls =
+ new String[] {
+ "SET STORAGE GROUP TO root.vehicle.d0",
+ "SET STORAGE GROUP TO root.vehicle.d1",
+ "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"
+ };
+ private static String[] dataSet2 =
+ new String[] {
+ "SET STORAGE GROUP TO root.ln.wf01.wt01",
+ "CREATE TIMESERIES root.ln.wf01.wt01.status WITH DATATYPE=BOOLEAN, ENCODING=PLAIN",
+ "CREATE TIMESERIES root.ln.wf01.wt01.temperature WITH DATATYPE=FLOAT, ENCODING=PLAIN",
+ "CREATE TIMESERIES root.ln.wf01.wt01.hardware WITH DATATYPE=INT32, ENCODING=PLAIN",
+ "INSERT INTO root.ln.wf01.wt01(timestamp,temperature,status, hardware) "
+ + "values(1, 1.1, false, 11)",
+ "INSERT INTO root.ln.wf01.wt01(timestamp,temperature,status, hardware) "
+ + "values(2, 2.2, true, 22)",
+ "INSERT INTO root.ln.wf01.wt01(timestamp,temperature,status, hardware) "
+ + "values(3, 3.3, false, 33 )",
+ "INSERT INTO root.ln.wf01.wt01(timestamp,temperature,status, hardware) "
+ + "values(4, 4.4, false, 44)",
+ "INSERT INTO root.ln.wf01.wt01(timestamp,temperature,status, hardware) "
+ + "values(5, 5.5, false, 55)"
+ };
+ private static String[] dataSet3 =
+ new String[] {
+ "SET STORAGE GROUP TO root.sg",
+ "CREATE TIMESERIES root.sg.d1.s1 WITH DATATYPE=INT32, ENCODING=RLE",
+ "insert into root.sg.d1(timestamp,s1) values(5,5)",
+ "insert into root.sg.d1(timestamp,s1) values(12,12)",
+ "flush",
+ "insert into root.sg.d1(timestamp,s1) values(15,15)",
+ "insert into root.sg.d1(timestamp,s1) values(25,25)",
+ "flush",
+ "insert into root.sg.d1(timestamp,s1) values(1,111)",
+ "insert into root.sg.d1(timestamp,s1) values(20,200)",
+ "flush"
+ };
private final String d0s0 = "root.vehicle.d0.s0";
private final String d0s1 = "root.vehicle.d0.s1";
private final String d0s2 = "root.vehicle.d0.s2";
private final String d0s3 = "root.vehicle.d0.s3";
- private String insertTemplate = "INSERT INTO root.vehicle.d0(timestamp,s0,s1,s2,s3,s4)"
- + " VALUES(%d,%d,%d,%f,%s,%s)";
+ private String insertTemplate =
+ "INSERT INTO root.vehicle.d0(timestamp,s0,s1,s2,s3,s4)" + " VALUES(%d,%d,%d,%f,%s,%s)";
private long prevPartitionInterval;
@Before
@@ -102,7 +97,8 @@ public class IoTDBAggregationIT {
EnvironmentUtils.closeStatMonitor();
prevPartitionInterval = IoTDBDescriptor.getInstance().getConfig().getPartitionInterval();
IoTDBDescriptor.getInstance().getConfig().setPartitionInterval(1000);
- IoTDBDescriptor.getInstance().getConfig()
+ IoTDBDescriptor.getInstance()
+ .getConfig()
.setCompactionStrategy(CompactionStrategy.NO_COMPACTION);
EnvironmentUtils.envSetUp();
Class.forName(Config.JDBC_DRIVER_NAME);
@@ -113,75 +109,82 @@ public class IoTDBAggregationIT {
public void tearDown() throws Exception {
EnvironmentUtils.cleanEnv();
IoTDBDescriptor.getInstance().getConfig().setPartitionInterval(prevPartitionInterval);
- IoTDBDescriptor.getInstance().getConfig()
+ IoTDBDescriptor.getInstance()
+ .getConfig()
.setCompactionStrategy(CompactionStrategy.LEVEL_COMPACTION);
}
- //add test for part of points in page don't satisfy filter
- //details in: https://issues.apache.org/jira/projects/IOTDB/issues/IOTDB-54
+ // add test for part of points in page don't satisfy filter
+ // details in: https://issues.apache.org/jira/projects/IOTDB/issues/IOTDB-54
@Test
public void test() throws SQLException {
- String[] retArray = new String[]{
- "0,2",
- "0,4",
- "0,3"
- };
- try (Connection connection = DriverManager.
- getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
+ String[] retArray = new String[] {"0,2", "0,4", "0,3"};
+ try (Connection connection =
+ DriverManager.getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
Statement statement = connection.createStatement()) {
- boolean hasResultSet = statement.execute(
- "SELECT count(temperature) FROM root.ln.wf01.wt01 WHERE time > 3");
+ boolean hasResultSet =
+ statement.execute("SELECT count(temperature) FROM root.ln.wf01.wt01 WHERE time > 3");
Assert.assertTrue(hasResultSet);
int cnt;
- try (ResultSet resultSet = statement.getResultSet();) {
+ try (ResultSet resultSet = statement.getResultSet(); ) {
cnt = 0;
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," +
- resultSet.getString(count(TEMPERATURE_STR));
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count(TEMPERATURE_STR));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
Assert.assertEquals(1, cnt);
}
- hasResultSet = statement.execute(
- "SELECT count(temperature) FROM root.ln.wf01.wt01 WHERE time > 3 order by time desc");
+ hasResultSet =
+ statement.execute(
+ "SELECT count(temperature) FROM root.ln.wf01.wt01 WHERE time > 3 order by time desc");
Assert.assertTrue(hasResultSet);
- try (ResultSet resultSet = statement.getResultSet();) {
+ try (ResultSet resultSet = statement.getResultSet(); ) {
cnt = 0;
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," +
- resultSet.getString(count(TEMPERATURE_STR));
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count(TEMPERATURE_STR));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
Assert.assertEquals(1, cnt);
}
- hasResultSet = statement.execute(
- "SELECT min_time(temperature) FROM root.ln.wf01.wt01 WHERE time > 3");
+ hasResultSet =
+ statement.execute("SELECT min_time(temperature) FROM root.ln.wf01.wt01 WHERE time > 3");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," +
- resultSet.getString(min_time(TEMPERATURE_STR));
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(min_time(TEMPERATURE_STR));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
Assert.assertEquals(2, cnt);
}
- hasResultSet = statement.execute(
- "SELECT min_time(temperature) FROM root.ln.wf01.wt01 WHERE temperature > 3");
+ hasResultSet =
+ statement.execute(
+ "SELECT min_time(temperature) FROM root.ln.wf01.wt01 WHERE temperature > 3");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," +
- resultSet.getString(min_time(TEMPERATURE_STR));
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(min_time(TEMPERATURE_STR));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
@@ -196,39 +199,53 @@ public class IoTDBAggregationIT {
@Test
public void countTest() throws SQLException {
- String[] retArray = new String[]{
- "0,2001,2001,2001,2001",
- "0,7500,7500,7500,7500"
- };
- try (Connection connection = DriverManager.
- getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
+ String[] retArray = new String[] {"0,2001,2001,2001,2001", "0,7500,7500,7500,7500"};
+ try (Connection connection =
+ DriverManager.getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
Statement statement = connection.createStatement()) {
- boolean hasResultSet = statement.execute("SELECT count(s0),count(s1),count(s2),count(s3) " +
- "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
+ boolean hasResultSet =
+ statement.execute(
+ "SELECT count(s0),count(s1),count(s2),count(s3) "
+ + "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
Assert.assertTrue(hasResultSet);
int cnt;
- try (ResultSet resultSet = statement.getResultSet();) {
+ try (ResultSet resultSet = statement.getResultSet(); ) {
cnt = 0;
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(count(d0s0))
- + "," + resultSet.getString(count(d0s1)) + "," + resultSet.getString(count(d0s2))
- + "," + resultSet.getString(count(d0s3));
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count(d0s0))
+ + ","
+ + resultSet.getString(count(d0s1))
+ + ","
+ + resultSet.getString(count(d0s2))
+ + ","
+ + resultSet.getString(count(d0s3));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
Assert.assertEquals(1, cnt);
}
- hasResultSet = statement.execute("SELECT count(s0),count(s1),count(s2),count(s3) " +
- "FROM root.vehicle.d0");
+ hasResultSet =
+ statement.execute(
+ "SELECT count(s0),count(s1),count(s2),count(s3) " + "FROM root.vehicle.d0");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(count(d0s0))
- + "," + resultSet.getString(count(d0s1)) + "," + resultSet.getString(count(d0s2))
- + "," + resultSet.getString(count(d0s3));
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count(d0s0))
+ + ","
+ + resultSet.getString(count(d0s1))
+ + ","
+ + resultSet.getString(count(d0s2))
+ + ","
+ + resultSet.getString(count(d0s3));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
@@ -236,29 +253,47 @@ public class IoTDBAggregationIT {
}
// keep the correctness of `order by time desc`
- hasResultSet = statement.execute("SELECT count(s0),count(s1),count(s2),count(s3) " +
- "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000 order by time desc");
+ hasResultSet =
+ statement.execute(
+ "SELECT count(s0),count(s1),count(s2),count(s3) "
+ + "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000 order by time desc");
Assert.assertTrue(hasResultSet);
- try (ResultSet resultSet = statement.getResultSet();) {
+ try (ResultSet resultSet = statement.getResultSet(); ) {
cnt = 0;
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(count(d0s0))
- + "," + resultSet.getString(count(d0s1)) + "," + resultSet.getString(count(d0s2))
- + "," + resultSet.getString(count(d0s3));
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count(d0s0))
+ + ","
+ + resultSet.getString(count(d0s1))
+ + ","
+ + resultSet.getString(count(d0s2))
+ + ","
+ + resultSet.getString(count(d0s3));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
Assert.assertEquals(1, cnt);
}
- hasResultSet = statement.execute("SELECT count(s0),count(s1),count(s2),count(s3) " +
- "FROM root.vehicle.d0 order by time desc");
+ hasResultSet =
+ statement.execute(
+ "SELECT count(s0),count(s1),count(s2),count(s3) "
+ + "FROM root.vehicle.d0 order by time desc");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(count(d0s0))
- + "," + resultSet.getString(count(d0s1)) + "," + resultSet.getString(count(d0s2))
- + "," + resultSet.getString(count(d0s3));
+ String ans =
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(count(d0s0))
+ + ","
+ + resultSet.getString(count(d0s1))
+ + ","
+ + resultSet.getString(count(d0s2))
+ + ","
+ + resultSet.getString(count(d0s3));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
@@ -272,44 +307,53 @@ public class IoTDBAggregationIT {
@Test
public void firstTest() {
- String[] retArray = new String[]{
- "0,2000,2000,2000.0,2000",
- "0,500,500,500.0,500"
- };
- try (Connection connection = DriverManager.
- getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
+ String[] retArray = new String[] {"0,2000,2000,2000.0,2000", "0,500,500,500.0,500"};
+ try (Connection connection =
+ DriverManager.getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
Statement statement = connection.createStatement()) {
- boolean hasResultSet = statement
- .execute("SELECT first_value(s0),first_value(s1),first_value(s2),first_value(s3) " +
- "FROM root.vehicle.d0 WHERE time >= 1500 AND time <= 9000");
+ boolean hasResultSet =
+ statement.execute(
+ "SELECT first_value(s0),first_value(s1),first_value(s2),first_value(s3) "
+ + "FROM root.vehicle.d0 WHERE time >= 1500 AND time <= 9000");
Assert.assertTrue(hasResultSet);
int cnt;
try (ResultSet resultSet = statement.getResultSet()) {
cnt = 0;
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(first_value(d0s0))
- + "," + resultSet.getString(first_value(d0s1)) + "," + resultSet
- .getString(first_value(d0s2))
- + "," + resultSet.getString(first_value(d0s3));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(first_value(d0s0))
+ + ","
+ + resultSet.getString(first_value(d0s1))
+ + ","
+ + resultSet.getString(first_value(d0s2))
+ + ","
+ + resultSet.getString(first_value(d0s3));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
Assert.assertEquals(1, cnt);
}
- hasResultSet = statement
- .execute("SELECT first_value(s0),first_value(s1),first_value(s2),first_value(s3) " +
- "FROM root.vehicle.d0");
+ hasResultSet =
+ statement.execute(
+ "SELECT first_value(s0),first_value(s1),first_value(s2),first_value(s3) "
+ + "FROM root.vehicle.d0");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(first_value(d0s0))
- + "," + resultSet.getString(first_value(d0s1)) + "," + resultSet
- .getString(first_value(d0s2))
- + "," + resultSet.getString(first_value(d0s3));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(first_value(d0s0))
+ + ","
+ + resultSet.getString(first_value(d0s1))
+ + ","
+ + resultSet.getString(first_value(d0s2))
+ + ","
+ + resultSet.getString(first_value(d0s3));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
@@ -317,18 +361,24 @@ public class IoTDBAggregationIT {
}
// keep the correctness of `order by time desc`
- hasResultSet = statement
- .execute("SELECT first_value(s0),first_value(s1),first_value(s2),first_value(s3) " +
- "FROM root.vehicle.d0 WHERE time >= 1500 AND time <= 9000 order by time desc");
+ hasResultSet =
+ statement.execute(
+ "SELECT first_value(s0),first_value(s1),first_value(s2),first_value(s3) "
+ + "FROM root.vehicle.d0 WHERE time >= 1500 AND time <= 9000 order by time desc");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
cnt = 0;
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(first_value(d0s0))
- + "," + resultSet.getString(first_value(d0s1)) + "," + resultSet
- .getString(first_value(d0s2))
- + "," + resultSet.getString(first_value(d0s3));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(first_value(d0s0))
+ + ","
+ + resultSet.getString(first_value(d0s1))
+ + ","
+ + resultSet.getString(first_value(d0s2))
+ + ","
+ + resultSet.getString(first_value(d0s3));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
@@ -342,70 +392,84 @@ public class IoTDBAggregationIT {
@Test
public void lastTest() throws SQLException {
- String[] retArray = new String[]{
- "0,8499,8499.0",
- "0,1499,1499.0",
- "0,2200,2200.0"
- };
- try (Connection connection = DriverManager.
- getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
+ String[] retArray = new String[] {"0,8499,8499.0", "0,1499,1499.0", "0,2200,2200.0"};
+ try (Connection connection =
+ DriverManager.getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
Statement statement = connection.createStatement()) {
- boolean hasResultSet = statement.execute("SELECT last_value(s0),last_value(s2) " +
- "FROM root.vehicle.d0 WHERE time >= 1500 AND time < 9000");
+ boolean hasResultSet =
+ statement.execute(
+ "SELECT last_value(s0),last_value(s2) "
+ + "FROM root.vehicle.d0 WHERE time >= 1500 AND time < 9000");
Assert.assertTrue(hasResultSet);
int cnt;
try (ResultSet resultSet = statement.getResultSet()) {
cnt = 0;
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(last_value(d0s0))
- + "," + resultSet.getString(last_value(d0s2));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(last_value(d0s0))
+ + ","
+ + resultSet.getString(last_value(d0s2));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
Assert.assertEquals(1, cnt);
}
- hasResultSet = statement.execute("SELECT last_value(s0),last_value(s2) " +
- "FROM root.vehicle.d0 WHERE time <= 1600");
+ hasResultSet =
+ statement.execute(
+ "SELECT last_value(s0),last_value(s2) " + "FROM root.vehicle.d0 WHERE time <= 1600");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(last_value(d0s0))
- + "," + resultSet.getString(last_value(d0s2));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(last_value(d0s0))
+ + ","
+ + resultSet.getString(last_value(d0s2));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
Assert.assertEquals(2, cnt);
}
- hasResultSet = statement.execute("SELECT last_value(s0),last_value(s2) " +
- "FROM root.vehicle.d0 WHERE time <= 2200");
+ hasResultSet =
+ statement.execute(
+ "SELECT last_value(s0),last_value(s2) " + "FROM root.vehicle.d0 WHERE time <= 2200");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(last_value(d0s0))
- + "," + resultSet.getString(last_value(d0s2));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(last_value(d0s0))
+ + ","
+ + resultSet.getString(last_value(d0s2));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
Assert.assertEquals(3, cnt);
}
- hasResultSet = statement.execute("SELECT last_value(s0),last_value(s2) " +
- "FROM root.vehicle.d0 WHERE time <= 2200 order by time desc");
+ hasResultSet =
+ statement.execute(
+ "SELECT last_value(s0),last_value(s2) "
+ + "FROM root.vehicle.d0 WHERE time <= 2200 order by time desc");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
cnt = 0;
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(last_value(d0s0))
- + "," + resultSet.getString(last_value(d0s2));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(last_value(d0s0))
+ + ","
+ + resultSet.getString(last_value(d0s2));
Assert.assertEquals(retArray[retArray.length - cnt - 1], ans);
cnt++;
}
@@ -413,15 +477,20 @@ public class IoTDBAggregationIT {
}
// keep the correctness of `order by time desc`
- hasResultSet = statement.execute("SELECT last_value(s0),last_value(s2) " +
- "FROM root.vehicle.d0 WHERE time >= 1500 AND time < 9000 order by time desc");
+ hasResultSet =
+ statement.execute(
+ "SELECT last_value(s0),last_value(s2) "
+ + "FROM root.vehicle.d0 WHERE time >= 1500 AND time < 9000 order by time desc");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
cnt = 0;
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(last_value(d0s0))
- + "," + resultSet.getString(last_value(d0s2));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(last_value(d0s0))
+ + ","
+ + resultSet.getString(last_value(d0s2));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
@@ -435,38 +504,45 @@ public class IoTDBAggregationIT {
@Test
public void maxminTimeTest() throws SQLException {
- String[] retArray = new String[]{
- "0,8499,500",
- "0,2499,2000"
- };
- try (Connection connection = DriverManager.
- getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
+ String[] retArray = new String[] {"0,8499,500", "0,2499,2000"};
+ try (Connection connection =
+ DriverManager.getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
Statement statement = connection.createStatement()) {
- boolean hasResultSet = statement.execute("SELECT max_time(s0),min_time(s2) " +
- "FROM root.vehicle.d0 WHERE time >= 100 AND time < 9000");
+ boolean hasResultSet =
+ statement.execute(
+ "SELECT max_time(s0),min_time(s2) "
+ + "FROM root.vehicle.d0 WHERE time >= 100 AND time < 9000");
Assert.assertTrue(hasResultSet);
int cnt;
try (ResultSet resultSet = statement.getResultSet()) {
cnt = 0;
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(max_time(d0s0))
- + "," + resultSet.getString(min_time(d0s2));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(max_time(d0s0))
+ + ","
+ + resultSet.getString(min_time(d0s2));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
Assert.assertEquals(1, cnt);
}
- hasResultSet = statement.execute("SELECT max_time(s0),min_time(s2) " +
- "FROM root.vehicle.d0 WHERE time <= 2500 AND time > 1800");
+ hasResultSet =
+ statement.execute(
+ "SELECT max_time(s0),min_time(s2) "
+ + "FROM root.vehicle.d0 WHERE time <= 2500 AND time > 1800");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(max_time(d0s0))
- + "," + resultSet.getString(min_time(d0s2));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(max_time(d0s0))
+ + ","
+ + resultSet.getString(min_time(d0s2));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
@@ -474,15 +550,20 @@ public class IoTDBAggregationIT {
}
// keep the correctness of `order by time desc`
- hasResultSet = statement.execute("SELECT max_time(s0),min_time(s2) " +
- "FROM root.vehicle.d0 WHERE time >= 100 AND time < 9000 order by time desc");
+ hasResultSet =
+ statement.execute(
+ "SELECT max_time(s0),min_time(s2) "
+ + "FROM root.vehicle.d0 WHERE time >= 100 AND time < 9000 order by time desc");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
cnt = 0;
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(max_time(d0s0))
- + "," + resultSet.getString(min_time(d0s2));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(max_time(d0s0))
+ + ","
+ + resultSet.getString(min_time(d0s2));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
@@ -496,24 +577,29 @@ public class IoTDBAggregationIT {
@Test
public void firstLastValueTest() throws SQLException {
- String[] retArray = new String[]{
- "0,2.2,4.4",
- };
- try (Connection connection = DriverManager.
- getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
+ String[] retArray =
+ new String[] {
+ "0,2.2,4.4",
+ };
+ try (Connection connection =
+ DriverManager.getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
Statement statement = connection.createStatement()) {
- boolean hasResultSet = statement
- .execute("SELECT first_value(temperature),last_value(temperature) " +
- "FROM root.ln.wf01.wt01 WHERE time > 1 AND time < 5");
+ boolean hasResultSet =
+ statement.execute(
+ "SELECT first_value(temperature),last_value(temperature) "
+ + "FROM root.ln.wf01.wt01 WHERE time > 1 AND time < 5");
Assert.assertTrue(hasResultSet);
int cnt;
try (ResultSet resultSet = statement.getResultSet()) {
cnt = 0;
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(1)
- + "," + resultSet.getString(2);
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(1)
+ + ","
+ + resultSet.getString(2);
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
@@ -524,16 +610,15 @@ public class IoTDBAggregationIT {
@Test
public void maxminValueTest() throws SQLException {
- String[] retArray = new String[]{
- "0,8499,500.0",
- "0,2499,500.0"
- };
- try (Connection connection = DriverManager.
- getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
+ String[] retArray = new String[] {"0,8499,500.0", "0,2499,500.0"};
+ try (Connection connection =
+ DriverManager.getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
Statement statement = connection.createStatement()) {
- boolean hasResultSet = statement.execute("SELECT max_value(s0),min_value(s2) " +
- "FROM root.vehicle.d0 WHERE time >= 100 AND time < 9000");
+ boolean hasResultSet =
+ statement.execute(
+ "SELECT max_value(s0),min_value(s2) "
+ + "FROM root.vehicle.d0 WHERE time >= 100 AND time < 9000");
Assert.assertTrue(hasResultSet);
int cnt;
@@ -541,23 +626,30 @@ public class IoTDBAggregationIT {
cnt = 0;
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(max_value(d0s0))
- + "," + resultSet.getString(min_value(d0s2));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(max_value(d0s0))
+ + ","
+ + resultSet.getString(min_value(d0s2));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
Assert.assertEquals(1, cnt);
}
- hasResultSet = statement.execute("SELECT max_value(s0),min_value(s2) " +
- "FROM root.vehicle.d0 WHERE time < 2500");
+ hasResultSet =
+ statement.execute(
+ "SELECT max_value(s0),min_value(s2) " + "FROM root.vehicle.d0 WHERE time < 2500");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(max_value(d0s0))
- + "," + resultSet.getString(min_value(d0s2));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(max_value(d0s0))
+ + ","
+ + resultSet.getString(min_value(d0s2));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
@@ -565,16 +657,21 @@ public class IoTDBAggregationIT {
}
// keep the correctness of `order by time desc`
- hasResultSet = statement.execute("SELECT max_value(s0),min_value(s2) " +
- "FROM root.vehicle.d0 WHERE time >= 100 AND time < 9000 order by time desc");
+ hasResultSet =
+ statement.execute(
+ "SELECT max_value(s0),min_value(s2) "
+ + "FROM root.vehicle.d0 WHERE time >= 100 AND time < 9000 order by time desc");
Assert.assertTrue(hasResultSet);
cnt = 0;
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(max_value(d0s0))
- + "," + resultSet.getString(min_value(d0s2));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(max_value(d0s0))
+ + ","
+ + resultSet.getString(min_value(d0s2));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
@@ -588,54 +685,59 @@ public class IoTDBAggregationIT {
@Test
public void avgSumTest() {
- String[] retArray = new String[]{
- "0,1.4508E7,7250.374812593702",
- "0,626750.0,1250.9980039920158"
- };
- try (Connection connection = DriverManager.
- getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
+ long[] retTimeArray = new long[] {0, 0};
+ double[] retDouble1Array = new double[] {1.4508E7, 626750.0};
+ double[] retDouble2Array = new double[] {7250.374812593702, 1250.9980039920158};
+ try (Connection connection =
+ DriverManager.getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
Statement statement = connection.createStatement()) {
- boolean hasResultSet = statement.execute("SELECT sum(s0),avg(s2)" +
- "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
+ boolean hasResultSet =
+ statement.execute(
+ "SELECT sum(s0),avg(s2)"
+ + "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
Assert.assertTrue(hasResultSet);
int cnt = 0;
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(sum(d0s0))
- + "," + resultSet.getString(avg(d0s2));
- Assert.assertEquals(retArray[cnt], ans);
+ Assert.assertEquals(resultSet.getLong(TIMESTAMP_STR), retTimeArray[cnt]);
+ Assert.assertEquals(resultSet.getDouble(sum(d0s0)), retDouble1Array[cnt], 0.00001);
+ Assert.assertEquals(resultSet.getDouble(avg(d0s2)), retDouble2Array[cnt], 0.00001);
cnt++;
}
Assert.assertEquals(1, cnt);
}
- hasResultSet = statement.execute("SELECT sum(s0),avg(s2)" +
- "FROM root.vehicle.d0 WHERE time >= 1000 AND time <= 2000");
+ hasResultSet =
+ statement.execute(
+ "SELECT sum(s0),avg(s2)"
+ + "FROM root.vehicle.d0 WHERE time >= 1000 AND time <= 2000");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(sum(d0s0))
- + "," + resultSet.getString(avg(d0s2));
- Assert.assertEquals(retArray[cnt], ans);
+ Assert.assertEquals(resultSet.getLong(TIMESTAMP_STR), retTimeArray[cnt]);
+ Assert.assertEquals(resultSet.getDouble(sum(d0s0)), retDouble1Array[cnt], 0.00001);
+ Assert.assertEquals(resultSet.getDouble(avg(d0s2)), retDouble2Array[cnt], 0.00001);
cnt++;
}
Assert.assertEquals(2, cnt);
}
// keep the correctness of `order by time desc`
- hasResultSet = statement.execute("SELECT sum(s0),avg(s2)" +
- "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000 order by time desc");
+ hasResultSet =
+ statement.execute(
+ "SELECT sum(s0),avg(s2)"
+ + "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000 order by time desc");
Assert.assertTrue(hasResultSet);
cnt = 0;
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(sum(d0s0))
- + "," + resultSet.getString(avg(d0s2));
- Assert.assertEquals(retArray[cnt], ans);
+ Assert.assertEquals(resultSet.getLong(TIMESTAMP_STR), retTimeArray[cnt]);
+ Assert.assertEquals(resultSet.getDouble(sum(d0s0)), retDouble1Array[cnt], 0.00001);
+ Assert.assertEquals(resultSet.getDouble(avg(d0s2)), retDouble2Array[cnt], 0.00001);
cnt++;
}
Assert.assertEquals(1, cnt);
@@ -648,12 +750,12 @@ public class IoTDBAggregationIT {
@Test
public void avgSumErrorTest() {
- try (Connection connection = DriverManager.
- getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
+ try (Connection connection =
+ DriverManager.getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
Statement statement = connection.createStatement()) {
try {
- statement.execute("SELECT avg(s3)" +
- "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
+ statement.execute(
+ "SELECT avg(s3)" + "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
try (ResultSet resultSet = statement.getResultSet()) {
resultSet.next();
fail();
@@ -662,8 +764,8 @@ public class IoTDBAggregationIT {
Assert.assertEquals("500: Unsupported data type in aggregation AVG : TEXT", e.getMessage());
}
try {
- statement.execute("SELECT sum(s3)" +
- "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
+ statement.execute(
+ "SELECT sum(s3)" + "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
try (ResultSet resultSet = statement.getResultSet()) {
resultSet.next();
fail();
@@ -672,26 +774,26 @@ public class IoTDBAggregationIT {
Assert.assertEquals("500: Unsupported data type in aggregation SUM : TEXT", e.getMessage());
}
try {
- statement.execute("SELECT avg(s4)" +
- "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
+ statement.execute(
+ "SELECT avg(s4)" + "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
try (ResultSet resultSet = statement.getResultSet()) {
resultSet.next();
fail();
}
} catch (Exception e) {
- Assert.assertEquals("500: Unsupported data type in aggregation AVG : BOOLEAN",
- e.getMessage());
+ Assert.assertEquals(
+ "500: Unsupported data type in aggregation AVG : BOOLEAN", e.getMessage());
}
try {
- statement.execute("SELECT sum(s4)" +
- "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
+ statement.execute(
+ "SELECT sum(s4)" + "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
try (ResultSet resultSet = statement.getResultSet()) {
resultSet.next();
fail();
}
} catch (Exception e) {
- Assert.assertEquals("500: Unsupported data type in aggregation SUM : BOOLEAN",
- e.getMessage());
+ Assert.assertEquals(
+ "500: Unsupported data type in aggregation SUM : BOOLEAN", e.getMessage());
}
try {
statement.execute("SELECT avg(status) FROM root.ln.wf01.wt01");
@@ -700,8 +802,7 @@ public class IoTDBAggregationIT {
fail();
}
} catch (Exception e) {
- Assert.assertEquals("500: Boolean statistics does not support: avg",
- e.getMessage());
+ Assert.assertEquals("500: Boolean statistics does not support: avg", e.getMessage());
}
} catch (Exception e) {
e.printStackTrace();
@@ -709,80 +810,135 @@ public class IoTDBAggregationIT {
}
}
- /**
- * test aggregation query with more than one functions on one series
- */
+ private void assertTrue(
+ long expectTime,
+ double expect1,
+ double expect2,
+ double expect3,
+ double expect4,
+ long realTime,
+ double real1,
+ double real2,
+ double real3,
+ double real4) {
+ Assert.assertEquals(expectTime, realTime);
+ Assert.assertEquals(expect1, real1, 0.00001);
+ Assert.assertEquals(expect2, real2, 0.00001);
+ Assert.assertEquals(expect3, real3, 0.00001);
+ Assert.assertEquals(expect4, real4, 0.00001);
+ }
+
+ /** test aggregation query with more than one functions on one series */
@Test
public void mergeAggrOnOneSeriesTest() {
- String[] retArray = new String[]{
- "0,1.4508E7,7250.374812593702,7250.374812593702,1.4508E7",
- "0,626750.0,1250.9980039920158,1250.9980039920158,626750.0",
- "0,1.4508E7,2001,7250.374812593702,7250.374812593702",
- "0,1.4508E7,2001,7250.374812593702,7250.374812593702,2001,1.4508E7"
-
- };
- try (Connection connection = DriverManager.
- getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
+ long[] retTimeArray = new long[] {0, 0, 0, 0};
+ double[] retDouble1Array = new double[] {1.4508E7, 626750.0, 1.4508E7, 1.4508E7};
+ double[] retDouble2Array = new double[] {7250.374812593702, 1250.9980039920158, 2001, 2001};
+ double[] retDouble3Array =
+ new double[] {7250.374812593702, 1250.9980039920158, 7250.374812593702, 7250.374812593702};
+ double[] retDouble4Array =
+ new double[] {1.4508E7, 626750.0, 7250.374812593702, 7250.374812593702};
+ int retCount = 2001;
+ double retSum = 1.4508E7;
+
+ try (Connection connection =
+ DriverManager.getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
Statement statement = connection.createStatement()) {
- boolean hasResultSet = statement.execute("SELECT sum(s0), avg(s2), avg(s0), sum(s2)" +
- "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
+ boolean hasResultSet =
+ statement.execute(
+ "SELECT sum(s0), avg(s2), avg(s0), sum(s2)"
+ + "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
Assert.assertTrue(hasResultSet);
int cnt = 0;
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(sum(d0s0))
- + "," + resultSet.getString(avg(d0s2)) + "," + resultSet.getString(avg(d0s0))
- + "," + resultSet.getString(sum(d0s2));
- Assert.assertEquals(retArray[cnt], ans);
+ assertTrue(
+ retTimeArray[cnt],
+ retDouble1Array[cnt],
+ retDouble2Array[cnt],
+ retDouble3Array[cnt],
+ retDouble4Array[cnt],
+ resultSet.getLong(TIMESTAMP_STR),
+ resultSet.getDouble(sum(d0s0)),
+ resultSet.getDouble(avg(d0s2)),
+ resultSet.getDouble(avg(d0s0)),
+ resultSet.getDouble(sum(d0s2)));
cnt++;
}
Assert.assertEquals(1, cnt);
}
- hasResultSet = statement.execute("SELECT sum(s0), avg(s2), avg(s0), sum(s2)" +
- "FROM root.vehicle.d0 WHERE time >= 1000 AND time <= 2000");
+ hasResultSet =
+ statement.execute(
+ "SELECT sum(s0), avg(s2), avg(s0), sum(s2)"
+ + "FROM root.vehicle.d0 WHERE time >= 1000 AND time <= 2000");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(sum(d0s0))
- + "," + resultSet.getString(avg(d0s2)) + "," + resultSet.getString(avg(d0s0))
- + "," + resultSet.getString(sum(d0s2));
- Assert.assertEquals(retArray[cnt], ans);
+ assertTrue(
+ retTimeArray[cnt],
+ retDouble1Array[cnt],
+ retDouble2Array[cnt],
+ retDouble3Array[cnt],
+ retDouble4Array[cnt],
+ resultSet.getLong(TIMESTAMP_STR),
+ resultSet.getDouble(sum(d0s0)),
+ resultSet.getDouble(avg(d0s2)),
+ resultSet.getDouble(avg(d0s0)),
+ resultSet.getDouble(sum(d0s2)));
cnt++;
}
Assert.assertEquals(2, cnt);
}
- hasResultSet = statement.execute("SELECT sum(s0), count(s0), avg(s2), avg(s0)" +
- "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
+ hasResultSet =
+ statement.execute(
+ "SELECT sum(s0), count(s0), avg(s2), avg(s0)"
+ + "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(sum(d0s0))
- + "," + resultSet.getString(count(d0s0)) + "," + resultSet.getString(avg(d0s2))
- + "," + resultSet.getString(avg(d0s0));
- Assert.assertEquals(retArray[cnt], ans);
+ assertTrue(
+ retTimeArray[cnt],
+ retDouble1Array[cnt],
+ retDouble2Array[cnt],
+ retDouble3Array[cnt],
+ retDouble4Array[cnt],
+ resultSet.getLong(TIMESTAMP_STR),
+ resultSet.getDouble(sum(d0s0)),
+ resultSet.getInt(count(d0s0)),
+ resultSet.getDouble(avg(d0s2)),
+ resultSet.getDouble(avg(d0s0)));
cnt++;
}
Assert.assertEquals(3, cnt);
}
- hasResultSet = statement
- .execute("SELECT sum(s2), count(s0), avg(s2), avg(s1), count(s2),sum(s0)" +
- "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
+ hasResultSet =
+ statement.execute(
+ "SELECT sum(s2), count(s0), avg(s2), avg(s1), count(s2),sum(s0)"
+ + "FROM root.vehicle.d0 WHERE time >= 6000 AND time <= 9000");
Assert.assertTrue(hasResultSet);
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
- String ans = resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(sum(d0s2))
- + "," + resultSet.getString(count(d0s0)) + "," + resultSet.getString(avg(d0s2))
- + "," + resultSet.getString(avg(d0s1)) + "," + resultSet.getString(count(d0s2))
- + "," + resultSet.getString(sum(d0s0));
- Assert.assertEquals(retArray[cnt], ans);
+ assertTrue(
+ retTimeArray[cnt],
+ retDouble1Array[cnt],
+ retDouble2Array[cnt],
+ retDouble3Array[cnt],
+ retDouble4Array[cnt],
+ resultSet.getLong(TIMESTAMP_STR),
+ resultSet.getDouble(sum(d0s2)),
+ resultSet.getInt(count(d0s0)),
+ resultSet.getDouble(avg(d0s2)),
+ resultSet.getDouble(avg(d0s1)));
+ Assert.assertEquals(resultSet.getInt(count(d0s2)), retCount);
+ Assert.assertEquals(resultSet.getDouble(sum(d0s0)), retSum, 0.00001);
cnt++;
}
Assert.assertEquals(4, cnt);
@@ -795,21 +951,25 @@ public class IoTDBAggregationIT {
@Test
public void descAggregationWithUnseqData() {
- String[] retArray = new String[]{
- "0,12",
- };
- try (Connection connection = DriverManager.
- getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
+ String[] retArray =
+ new String[] {
+ "0,12",
+ };
+ try (Connection connection =
+ DriverManager.getConnection("jdbc:iotdb://127.0.0.1:6667/", "root", "root");
Statement statement = connection.createStatement()) {
- boolean hasResultSet = statement.execute("SELECT max_time(s1) FROM root.sg.d1 where time < 15");
+ boolean hasResultSet =
+ statement.execute("SELECT max_time(s1) FROM root.sg.d1 where time < 15");
Assert.assertTrue(hasResultSet);
int cnt = 0;
try (ResultSet resultSet = statement.getResultSet()) {
while (resultSet.next()) {
String ans =
- resultSet.getString(TIMESTAMP_STR) + "," + resultSet.getString(max_time("root.sg.d1.s1"));
+ resultSet.getString(TIMESTAMP_STR)
+ + ","
+ + resultSet.getString(max_time("root.sg.d1.s1"));
Assert.assertEquals(retArray[cnt], ans);
cnt++;
}
@@ -822,9 +982,9 @@ public class IoTDBAggregationIT {
}
private void prepareData() {
- try (Connection connection = DriverManager
- .getConnection(Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root",
- "root");
+ try (Connection connection =
+ DriverManager.getConnection(
+ Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
Statement statement = connection.createStatement()) {
for (String sql : creationSqls) {
@@ -833,36 +993,42 @@ public class IoTDBAggregationIT {
// prepare BufferWrite file
for (int i = 5000; i < 7000; i++) {
- statement.execute(String
- .format(Locale.ENGLISH, insertTemplate, i, i, i, (double) i, "\'" + i + "\'", "true"));
+ statement.execute(
+ String.format(
+ Locale.ENGLISH, insertTemplate, i, i, i, (double) i, "\'" + i + "\'", "true"));
}
statement.execute("FLUSH");
for (int i = 7500; i < 8500; i++) {
- statement.execute(String
- .format(Locale.ENGLISH, insertTemplate, i, i, i, (double) i, "\'" + i + "\'", "false"));
+ statement.execute(
+ String.format(
+ Locale.ENGLISH, insertTemplate, i, i, i, (double) i, "\'" + i + "\'", "false"));
}
statement.execute("FLUSH");
// prepare Unseq-File
for (int i = 500; i < 1500; i++) {
- statement.execute(String
- .format(Locale.ENGLISH, insertTemplate, i, i, i, (double) i, "\'" + i + "\'", "true"));
+ statement.execute(
+ String.format(
+ Locale.ENGLISH, insertTemplate, i, i, i, (double) i, "\'" + i + "\'", "true"));
}
statement.execute("FLUSH");
for (int i = 3000; i < 6500; i++) {
- statement.execute(String
- .format(Locale.ENGLISH, insertTemplate, i, i, i, (double) i, "\'" + i + "\'", "false"));
+ statement.execute(
+ String.format(
+ Locale.ENGLISH, insertTemplate, i, i, i, (double) i, "\'" + i + "\'", "false"));
}
statement.execute("merge");
// prepare BufferWrite cache
for (int i = 9000; i < 10000; i++) {
- statement.execute(String
- .format(Locale.ENGLISH, insertTemplate, i, i, i, (double) i, "\'" + i + "\'", "true"));
+ statement.execute(
+ String.format(
+ Locale.ENGLISH, insertTemplate, i, i, i, (double) i, "\'" + i + "\'", "true"));
}
// prepare Overflow cache
for (int i = 2000; i < 2500; i++) {
- statement.execute(String
- .format(Locale.ENGLISH, insertTemplate, i, i, i, (double) i, "\'" + i + "\'", "false"));
+ statement.execute(
+ String.format(
+ Locale.ENGLISH, insertTemplate, i, i, i, (double) i, "\'" + i + "\'", "false"));
}
for (String sql : dataSet3) {