You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by ha...@apache.org on 2022/12/13 07:27:47 UTC
[iotdb] branch move_udf_it created (now f7fb0e563c)
This is an automated email from the ASF dual-hosted git repository.
haonan pushed a change to branch move_udf_it
in repository https://gitbox.apache.org/repos/asf/iotdb.git
at f7fb0e563c [IOTDB-5190] Move Library-udf IT to integration-test
This branch includes the following new commits:
new 8b69c2a6c2 [IOTDB-5190] Move Library-udf IT to integration-test
new f7fb0e563c [IOTDB-5190] Move Library-udf IT to integration-test
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
[iotdb] 02/02: [IOTDB-5190] Move Library-udf IT to integration-test
Posted by ha...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
haonan pushed a commit to branch move_udf_it
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit f7fb0e563c586c460bd31f40541e5dc80dca3a92
Author: HTHou <hh...@outlook.com>
AuthorDate: Tue Dec 13 15:27:33 2022 +0800
[IOTDB-5190] Move Library-udf IT to integration-test
---
.../apache/iotdb/libudf/it/anomaly/AnomalyIT.java | 1509 ++++++++++++++++++++
.../apache/iotdb/libudf/it/dmatch/DMatchIT.java | 805 +++++++++++
.../iotdb/libudf/it/dprofile/DProfileIT.java | 586 ++++++++
.../iotdb/libudf/it/dquality/DQualityIT.java | 356 +++++
.../apache/iotdb/libudf/it/drepair/DRepairIT.java | 279 ++++
.../iotdb/libudf/it/frequency/FrequencyIT.java | 282 ++++
.../apache/iotdb/libudf/it/series/SeriesIT.java | 472 ++++++
.../apache/iotdb/libudf/it/string/StringIT.java | 252 ++++
8 files changed, 4541 insertions(+)
diff --git a/integration-test/src/test/java/org/apache/iotdb/libudf/it/anomaly/AnomalyIT.java b/integration-test/src/test/java/org/apache/iotdb/libudf/it/anomaly/AnomalyIT.java
new file mode 100644
index 0000000000..a52fc64ec7
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/libudf/it/anomaly/AnomalyIT.java
@@ -0,0 +1,1509 @@
+/*
+ * 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.libudf.it.anomaly;
+
+import org.apache.iotdb.it.env.ConfigFactory;
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.LocalStandaloneIT;
+
+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.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({LocalStandaloneIT.class})
+public class AnomalyIT {
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ ConfigFactory.getConfig()
+ .setUdfCollectorMemoryBudgetInMB(5)
+ .setUdfTransformerMemoryBudgetInMB(5)
+ .setUdfReaderMemoryBudgetInMB(5);
+ EnvFactory.getEnv().initBeforeClass();
+ createTimeSeries();
+ generateData();
+ registerUDF();
+ }
+
+ private static void createTimeSeries() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.addBatch("create database root.vehicle");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s1 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s2 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s3 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s4 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s1 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s2 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s3 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s4 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d3.s1 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d3.s2 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d3.s3 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d3.s4 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d3.s5 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d3.s6 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d3.s7 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d3.s8 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d4.s1 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d4.s2 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d4.s3 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d4.s4 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d6.s1 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d6.s2 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d6.s3 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d6.s4 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.executeBatch();
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void generateData() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 100, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 200, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 300, -2, -2, -2, -2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 400, -1, -1, -1, -1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 500, 10, 10, 10, 10));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 600, 1, 1, 1, 1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 700, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 800, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 900, -1, -1, -1, -1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1000, 1, 1, 1, 1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 100, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 200, 50, 50, 50, 50));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 300, 100, 100, 100, 100));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 400, 150, 150, 150, 150));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 500, 200, 200, 200, 200));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 600, 200, 200, 200, 200));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 700, 200, 200, 200, 200));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 800, 200, 200, 200, 200));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 900, 200, 200, 200, 200));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1000, 200, 200, 200, 200));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1100, 150, 150, 150, 150));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1200, 100, 100, 100, 100));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1300, 50, 50, 50, 50));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1400, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 100, 0, 0, 0, 0, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 200, 0, 0, 0, 0, 1, 1, 1, 1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 300, 1, 1, 1, 1, 1, 1, 1, 1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 400, 1, 1, 1, 1, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 500, 0, 0, 0, 0, -1, -1, -1, -1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 600, -1, -1, -1, -1, -1, -1, -1, -1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 700, -1, -1, -1, -1, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 800, 2, 2, 2, 2, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 100, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 200, 1, 1, 1, 1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 300, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 400, 1, 1, 1, 1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 500, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 600, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 700, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 800, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 900, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1000, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1100, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1200, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1300, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1400, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1500, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1600, 1, 1, 1, 1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1700, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1800, 1, 1, 1, 1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1900, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 2000, 1, 1, 1, 1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 100, 2002, 2002, 2002, 2002));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 200, 1946, 1946, 1946, 1946));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 300, 1958, 1958, 1958, 1958));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 400, 2012, 2012, 2012, 2012));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 500, 2051, 2051, 2051, 2051));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 600, 1898, 1898, 1898, 1898));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 700, 2014, 2014, 2014, 2014));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 800, 2052, 2052, 2052, 2052));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 900, 1935, 1935, 1935, 1935));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1000, 1901, 1901, 1901, 1901));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1100, 1972, 1972, 1972, 1972));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1200, 1969, 1969, 1969, 1969));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1300, 1984, 1984, 1984, 1984));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1400, 2018, 2018, 2018, 2018));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1500, 1484, 1484, 1484, 1484));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1600, 1055, 1055, 1055, 1055));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1700, 1050, 1050, 1050, 1050));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1800, 1023, 1023, 1023, 1023));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1900, 1056, 1056, 1056, 1056));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 2000, 978, 978, 978, 978));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 2100, 1050, 1050, 1050, 1050));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 2200, 1123, 1123, 1123, 1123));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 2300, 1150, 1150, 1150, 1150));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 2400, 1034, 1034, 1034, 1034));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 2500, 950, 950, 950, 950));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 2600, 1059, 1059, 1059, 1059));
+ statement.executeBatch();
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void registerUDF() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute("create function iqr as 'org.apache.iotdb.library.anomaly.UDTFIQR'");
+ statement.execute("create function ksigma as 'org.apache.iotdb.library.anomaly.UDTFKSigma'");
+ statement.execute(
+ "create function missdetect as 'org.apache.iotdb.library.anomaly.UDTFMissDetect'");
+ statement.execute("create function lof as 'org.apache.iotdb.library.anomaly.UDTFLOF'");
+ statement.execute("create function range as 'org.apache.iotdb.library.anomaly.UDTFRange'");
+ statement.execute(
+ "create function TwoSidedFilter as 'org.apache.iotdb.library.anomaly.UDTFTwoSidedFilter'");
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanAfterClass();
+ }
+
+ @Test
+ public void testIRQR1() {
+ String sqlStr = "select iqr(d1.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(10.0, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testIQR2() {
+ String sqlStr = "select iqr(d1.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(10.0, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testIQR3() {
+ String sqlStr = "select iqr(d1.s3) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(10.0, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testIQR4() {
+ String sqlStr = "select iqr(d1.s4) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(10.0, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testKSigma1() {
+ String sqlStr = "select ksigma(d2.s1,\"k\"=\"1.0\") from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getInt(2);
+ resultSet.next();
+ double result2 = resultSet.getInt(2);
+ resultSet.next();
+ double result3 = resultSet.getInt(2);
+ resultSet.next();
+ double result4 = resultSet.getInt(2);
+ Assert.assertEquals(0.0, result1, 0.01);
+ Assert.assertEquals(50.0, result2, 0.01);
+ Assert.assertEquals(50.0, result3, 0.01);
+ Assert.assertEquals(0.0, result4, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testKSigma2() {
+ String sqlStr = "select ksigma(d2.s2,\"k\"=\"1.0\") from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getLong(2);
+ resultSet.next();
+ double result2 = resultSet.getLong(2);
+ resultSet.next();
+ double result3 = resultSet.getLong(2);
+ resultSet.next();
+ double result4 = resultSet.getLong(2);
+ Assert.assertEquals(0.0, result1, 0.01);
+ Assert.assertEquals(50.0, result2, 0.01);
+ Assert.assertEquals(50.0, result3, 0.01);
+ Assert.assertEquals(0.0, result4, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testKSigma3() {
+ String sqlStr = "select ksigma(d2.s3,\"k\"=\"1.0\") from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getFloat(2);
+ resultSet.next();
+ double result2 = resultSet.getFloat(2);
+ resultSet.next();
+ double result3 = resultSet.getFloat(2);
+ resultSet.next();
+ double result4 = resultSet.getFloat(2);
+ Assert.assertEquals(0.0, result1, 0.01);
+ Assert.assertEquals(50.0, result2, 0.01);
+ Assert.assertEquals(50.0, result3, 0.01);
+ Assert.assertEquals(0.0, result4, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testKSigma4() {
+ String sqlStr = "select ksigma(d2.s4,\"k\"=\"1.0\") from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ resultSet.next();
+ double result3 = resultSet.getDouble(2);
+ resultSet.next();
+ double result4 = resultSet.getDouble(2);
+ Assert.assertEquals(0.0, result1, 0.01);
+ Assert.assertEquals(50.0, result2, 0.01);
+ Assert.assertEquals(50.0, result3, 0.01);
+ Assert.assertEquals(0.0, result4, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testMissDetect1() {
+ String sqlStr = "select missdetect(d4.s1,'minlen'='10') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ boolean result1 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result2 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result3 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result4 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result5 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result6 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result7 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result8 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result9 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result10 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result11 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result12 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result13 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result14 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result15 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result16 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result17 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result18 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result19 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result20 = resultSet.getBoolean(2);
+ Assert.assertFalse(result1);
+ Assert.assertFalse(result2);
+ Assert.assertFalse(result3);
+ Assert.assertFalse(result4);
+ Assert.assertTrue(result5);
+ Assert.assertTrue(result6);
+ Assert.assertTrue(result7);
+ Assert.assertTrue(result8);
+ Assert.assertTrue(result9);
+ Assert.assertTrue(result10);
+ Assert.assertTrue(result11);
+ Assert.assertTrue(result12);
+ Assert.assertTrue(result13);
+ Assert.assertTrue(result14);
+ Assert.assertTrue(result15);
+ Assert.assertFalse(result16);
+ Assert.assertFalse(result17);
+ Assert.assertFalse(result18);
+ Assert.assertFalse(result19);
+ Assert.assertFalse(result20);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testMissDetect2() {
+ String sqlStr = "select missdetect(d4.s2,'minlen'='10') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ boolean result1 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result2 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result3 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result4 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result5 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result6 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result7 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result8 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result9 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result10 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result11 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result12 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result13 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result14 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result15 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result16 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result17 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result18 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result19 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result20 = resultSet.getBoolean(2);
+ Assert.assertFalse(result1);
+ Assert.assertFalse(result2);
+ Assert.assertFalse(result3);
+ Assert.assertFalse(result4);
+ Assert.assertTrue(result5);
+ Assert.assertTrue(result6);
+ Assert.assertTrue(result7);
+ Assert.assertTrue(result8);
+ Assert.assertTrue(result9);
+ Assert.assertTrue(result10);
+ Assert.assertTrue(result11);
+ Assert.assertTrue(result12);
+ Assert.assertTrue(result13);
+ Assert.assertTrue(result14);
+ Assert.assertTrue(result15);
+ Assert.assertFalse(result16);
+ Assert.assertFalse(result17);
+ Assert.assertFalse(result18);
+ Assert.assertFalse(result19);
+ Assert.assertFalse(result20);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testMissDetect3() {
+ String sqlStr = "select missdetect(d4.s3,'minlen'='10') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ boolean result1 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result2 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result3 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result4 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result5 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result6 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result7 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result8 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result9 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result10 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result11 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result12 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result13 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result14 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result15 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result16 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result17 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result18 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result19 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result20 = resultSet.getBoolean(2);
+ Assert.assertFalse(result1);
+ Assert.assertFalse(result2);
+ Assert.assertFalse(result3);
+ Assert.assertFalse(result4);
+ Assert.assertTrue(result5);
+ Assert.assertTrue(result6);
+ Assert.assertTrue(result7);
+ Assert.assertTrue(result8);
+ Assert.assertTrue(result9);
+ Assert.assertTrue(result10);
+ Assert.assertTrue(result11);
+ Assert.assertTrue(result12);
+ Assert.assertTrue(result13);
+ Assert.assertTrue(result14);
+ Assert.assertTrue(result15);
+ Assert.assertFalse(result16);
+ Assert.assertFalse(result17);
+ Assert.assertFalse(result18);
+ Assert.assertFalse(result19);
+ Assert.assertFalse(result20);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testMissDetect4() {
+ String sqlStr = "select missdetect(d4.s4,'minlen'='10') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ boolean result1 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result2 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result3 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result4 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result5 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result6 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result7 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result8 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result9 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result10 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result11 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result12 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result13 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result14 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result15 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result16 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result17 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result18 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result19 = resultSet.getBoolean(2);
+ resultSet.next();
+ boolean result20 = resultSet.getBoolean(2);
+ Assert.assertFalse(result1);
+ Assert.assertFalse(result2);
+ Assert.assertFalse(result3);
+ Assert.assertFalse(result4);
+ Assert.assertTrue(result5);
+ Assert.assertTrue(result6);
+ Assert.assertTrue(result7);
+ Assert.assertTrue(result8);
+ Assert.assertTrue(result9);
+ Assert.assertTrue(result10);
+ Assert.assertTrue(result11);
+ Assert.assertTrue(result12);
+ Assert.assertTrue(result13);
+ Assert.assertTrue(result14);
+ Assert.assertTrue(result15);
+ Assert.assertFalse(result16);
+ Assert.assertFalse(result17);
+ Assert.assertFalse(result18);
+ Assert.assertFalse(result19);
+ Assert.assertFalse(result20);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testLOF1() {
+ String sqlStr = "select lof(d3.s1,d3.s5) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ resultSet.next();
+ double result3 = resultSet.getDouble(2);
+ resultSet.next();
+ double result4 = resultSet.getDouble(2);
+ resultSet.next();
+ double result5 = resultSet.getDouble(2);
+ resultSet.next();
+ double result6 = resultSet.getDouble(2);
+ resultSet.next();
+ double result7 = resultSet.getDouble(2);
+ resultSet.next();
+ double result8 = resultSet.getDouble(2);
+ Assert.assertEquals(3.8274824267668244, result1, 0.01);
+ Assert.assertEquals(3.0117631741126156, result2, 0.01);
+ Assert.assertEquals(2.838155437762879, result3, 0.01);
+ Assert.assertEquals(3.0117631741126156, result4, 0.01);
+ Assert.assertEquals(2.73518261244453, result5, 0.01);
+ Assert.assertEquals(2.371440975708148, result6, 0.01);
+ Assert.assertEquals(2.73518261244453, result7, 0.01);
+ Assert.assertEquals(1.7561416374270742, result8, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testLOF2() {
+ String sqlStr = "select lof(d3.s2,d3.s6) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ resultSet.next();
+ double result3 = resultSet.getDouble(2);
+ resultSet.next();
+ double result4 = resultSet.getDouble(2);
+ resultSet.next();
+ double result5 = resultSet.getDouble(2);
+ resultSet.next();
+ double result6 = resultSet.getDouble(2);
+ resultSet.next();
+ double result7 = resultSet.getDouble(2);
+ resultSet.next();
+ double result8 = resultSet.getDouble(2);
+ Assert.assertEquals(3.8274824267668244, result1, 0.01);
+ Assert.assertEquals(3.0117631741126156, result2, 0.01);
+ Assert.assertEquals(2.838155437762879, result3, 0.01);
+ Assert.assertEquals(3.0117631741126156, result4, 0.01);
+ Assert.assertEquals(2.73518261244453, result5, 0.01);
+ Assert.assertEquals(2.371440975708148, result6, 0.01);
+ Assert.assertEquals(2.73518261244453, result7, 0.01);
+ Assert.assertEquals(1.7561416374270742, result8, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testLOF3() {
+ String sqlStr = "select lof(d3.s3,d3.s7) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ resultSet.next();
+ double result3 = resultSet.getDouble(2);
+ resultSet.next();
+ double result4 = resultSet.getDouble(2);
+ resultSet.next();
+ double result5 = resultSet.getDouble(2);
+ resultSet.next();
+ double result6 = resultSet.getDouble(2);
+ resultSet.next();
+ double result7 = resultSet.getDouble(2);
+ resultSet.next();
+ double result8 = resultSet.getDouble(2);
+ Assert.assertEquals(3.8274824267668244, result1, 0.01);
+ Assert.assertEquals(3.0117631741126156, result2, 0.01);
+ Assert.assertEquals(2.838155437762879, result3, 0.01);
+ Assert.assertEquals(3.0117631741126156, result4, 0.01);
+ Assert.assertEquals(2.73518261244453, result5, 0.01);
+ Assert.assertEquals(2.371440975708148, result6, 0.01);
+ Assert.assertEquals(2.73518261244453, result7, 0.01);
+ Assert.assertEquals(1.7561416374270742, result8, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testLOF4() {
+ String sqlStr = "select lof(d3.s4,d3.s8) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ resultSet.next();
+ double result3 = resultSet.getDouble(2);
+ resultSet.next();
+ double result4 = resultSet.getDouble(2);
+ resultSet.next();
+ double result5 = resultSet.getDouble(2);
+ resultSet.next();
+ double result6 = resultSet.getDouble(2);
+ resultSet.next();
+ double result7 = resultSet.getDouble(2);
+ resultSet.next();
+ double result8 = resultSet.getDouble(2);
+ Assert.assertEquals(3.8274824267668244, result1, 0.01);
+ Assert.assertEquals(3.0117631741126156, result2, 0.01);
+ Assert.assertEquals(2.838155437762879, result3, 0.01);
+ Assert.assertEquals(3.0117631741126156, result4, 0.01);
+ Assert.assertEquals(2.73518261244453, result5, 0.01);
+ Assert.assertEquals(2.371440975708148, result6, 0.01);
+ Assert.assertEquals(2.73518261244453, result7, 0.01);
+ Assert.assertEquals(1.7561416374270742, result8, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testRange1() {
+ String sqlStr =
+ "select range(d1.s1,\"lower_bound\"=\"-5.0\",\"upper_bound\"=\"5.0\") from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getInt(2);
+ Assert.assertEquals(10.0, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testRange2() {
+ String sqlStr =
+ "select range(d1.s2,\"lower_bound\"=\"-5.0\",\"upper_bound\"=\"5.0\") from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getLong(2);
+ Assert.assertEquals(10.0, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testRange3() {
+ String sqlStr =
+ "select range(d1.s3,\"lower_bound\"=\"-5.0\",\"upper_bound\"=\"5.0\") from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getFloat(2);
+ Assert.assertEquals(10.0, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testRange4() {
+ String sqlStr =
+ "select range(d1.s4,\"lower_bound\"=\"-5.0\",\"upper_bound\"=\"5.0\") from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(10.0, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testTwoSidedFileter1() {
+ String sqlStr = "select TwoSidedFilter(d6.s1, 'len'='3', 'threshold'='0.3') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getInt(2);
+ resultSet.next();
+ double result2 = resultSet.getInt(2);
+ resultSet.next();
+ double result3 = resultSet.getInt(2);
+ resultSet.next();
+ double result4 = resultSet.getInt(2);
+ resultSet.next();
+ double result5 = resultSet.getInt(2);
+ resultSet.next();
+ double result6 = resultSet.getInt(2);
+ resultSet.next();
+ double result7 = resultSet.getInt(2);
+ resultSet.next();
+ double result8 = resultSet.getInt(2);
+ resultSet.next();
+ double result9 = resultSet.getInt(2);
+ resultSet.next();
+ double result10 = resultSet.getInt(2);
+ resultSet.next();
+ double result11 = resultSet.getInt(2);
+ resultSet.next();
+ double result12 = resultSet.getInt(2);
+ resultSet.next();
+ double result13 = resultSet.getInt(2);
+ resultSet.next();
+ double result14 = resultSet.getInt(2);
+ resultSet.next();
+ double result15 = resultSet.getInt(2);
+ resultSet.next();
+ double result16 = resultSet.getInt(2);
+ resultSet.next();
+ double result17 = resultSet.getInt(2);
+ resultSet.next();
+ double result18 = resultSet.getInt(2);
+ resultSet.next();
+ double result19 = resultSet.getInt(2);
+ resultSet.next();
+ double result20 = resultSet.getInt(2);
+ resultSet.next();
+ double result21 = resultSet.getInt(2);
+ resultSet.next();
+ double result22 = resultSet.getInt(2);
+ resultSet.next();
+ double result23 = resultSet.getInt(2);
+ Assert.assertEquals(2002.0, result1, 0.01);
+ Assert.assertEquals(1946.0, result2, 0.01);
+ Assert.assertEquals(1958.0, result3, 0.01);
+ Assert.assertEquals(2012.0, result4, 0.01);
+ Assert.assertEquals(2051.0, result5, 0.01);
+ Assert.assertEquals(1898.0, result6, 0.01);
+ Assert.assertEquals(2014.0, result7, 0.01);
+ Assert.assertEquals(2052.0, result8, 0.01);
+ Assert.assertEquals(1935.0, result9, 0.01);
+ Assert.assertEquals(1901.0, result10, 0.01);
+ Assert.assertEquals(1972.0, result11, 0.01);
+ Assert.assertEquals(1969.0, result12, 0.01);
+ Assert.assertEquals(1984.0, result13, 0.01);
+ Assert.assertEquals(2018.0, result14, 0.01);
+ Assert.assertEquals(1023.0, result15, 0.01);
+ Assert.assertEquals(1056.0, result16, 0.01);
+ Assert.assertEquals(978.0, result17, 0.01);
+ Assert.assertEquals(1050.0, result18, 0.01);
+ Assert.assertEquals(1123.0, result19, 0.01);
+ Assert.assertEquals(1150.0, result20, 0.01);
+ Assert.assertEquals(1134.0, result21, 0.01);
+ Assert.assertEquals(950.0, result22, 0.01);
+ Assert.assertEquals(1059.0, result23, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testTwoSidedFileter2() {
+ String sqlStr = "select TwoSidedFilter(d6.s2, 'len'='3', 'threshold'='0.3') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getLong(2);
+ resultSet.next();
+ double result2 = resultSet.getLong(2);
+ resultSet.next();
+ double result3 = resultSet.getLong(2);
+ resultSet.next();
+ double result4 = resultSet.getLong(2);
+ resultSet.next();
+ double result5 = resultSet.getLong(2);
+ resultSet.next();
+ double result6 = resultSet.getLong(2);
+ resultSet.next();
+ double result7 = resultSet.getLong(2);
+ resultSet.next();
+ double result8 = resultSet.getLong(2);
+ resultSet.next();
+ double result9 = resultSet.getLong(2);
+ resultSet.next();
+ double result10 = resultSet.getLong(2);
+ resultSet.next();
+ double result11 = resultSet.getLong(2);
+ resultSet.next();
+ double result12 = resultSet.getLong(2);
+ resultSet.next();
+ double result13 = resultSet.getLong(2);
+ resultSet.next();
+ double result14 = resultSet.getLong(2);
+ resultSet.next();
+ double result15 = resultSet.getLong(2);
+ resultSet.next();
+ double result16 = resultSet.getLong(2);
+ resultSet.next();
+ double result17 = resultSet.getLong(2);
+ resultSet.next();
+ double result18 = resultSet.getLong(2);
+ resultSet.next();
+ double result19 = resultSet.getLong(2);
+ resultSet.next();
+ double result20 = resultSet.getLong(2);
+ resultSet.next();
+ double result21 = resultSet.getLong(2);
+ resultSet.next();
+ double result22 = resultSet.getLong(2);
+ resultSet.next();
+ double result23 = resultSet.getLong(2);
+ Assert.assertEquals(2002.0, result1, 0.01);
+ Assert.assertEquals(1946.0, result2, 0.01);
+ Assert.assertEquals(1958.0, result3, 0.01);
+ Assert.assertEquals(2012.0, result4, 0.01);
+ Assert.assertEquals(2051.0, result5, 0.01);
+ Assert.assertEquals(1898.0, result6, 0.01);
+ Assert.assertEquals(2014.0, result7, 0.01);
+ Assert.assertEquals(2052.0, result8, 0.01);
+ Assert.assertEquals(1935.0, result9, 0.01);
+ Assert.assertEquals(1901.0, result10, 0.01);
+ Assert.assertEquals(1972.0, result11, 0.01);
+ Assert.assertEquals(1969.0, result12, 0.01);
+ Assert.assertEquals(1984.0, result13, 0.01);
+ Assert.assertEquals(2018.0, result14, 0.01);
+ Assert.assertEquals(1023.0, result15, 0.01);
+ Assert.assertEquals(1056.0, result16, 0.01);
+ Assert.assertEquals(978.0, result17, 0.01);
+ Assert.assertEquals(1050.0, result18, 0.01);
+ Assert.assertEquals(1123.0, result19, 0.01);
+ Assert.assertEquals(1150.0, result20, 0.01);
+ Assert.assertEquals(1134.0, result21, 0.01);
+ Assert.assertEquals(950.0, result22, 0.01);
+ Assert.assertEquals(1059.0, result23, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testTwoSidedFileter3() {
+ String sqlStr = "select TwoSidedFilter(d6.s3, 'len'='3', 'threshold'='0.3') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getFloat(2);
+ resultSet.next();
+ double result2 = resultSet.getFloat(2);
+ resultSet.next();
+ double result3 = resultSet.getFloat(2);
+ resultSet.next();
+ double result4 = resultSet.getFloat(2);
+ resultSet.next();
+ double result5 = resultSet.getFloat(2);
+ resultSet.next();
+ double result6 = resultSet.getFloat(2);
+ resultSet.next();
+ double result7 = resultSet.getFloat(2);
+ resultSet.next();
+ double result8 = resultSet.getFloat(2);
+ resultSet.next();
+ double result9 = resultSet.getFloat(2);
+ resultSet.next();
+ double result10 = resultSet.getFloat(2);
+ resultSet.next();
+ double result11 = resultSet.getFloat(2);
+ resultSet.next();
+ double result12 = resultSet.getFloat(2);
+ resultSet.next();
+ double result13 = resultSet.getFloat(2);
+ resultSet.next();
+ double result14 = resultSet.getFloat(2);
+ resultSet.next();
+ double result15 = resultSet.getFloat(2);
+ resultSet.next();
+ double result16 = resultSet.getFloat(2);
+ resultSet.next();
+ double result17 = resultSet.getFloat(2);
+ resultSet.next();
+ double result18 = resultSet.getFloat(2);
+ resultSet.next();
+ double result19 = resultSet.getFloat(2);
+ resultSet.next();
+ double result20 = resultSet.getFloat(2);
+ resultSet.next();
+ double result21 = resultSet.getFloat(2);
+ resultSet.next();
+ double result22 = resultSet.getFloat(2);
+ resultSet.next();
+ double result23 = resultSet.getFloat(2);
+ Assert.assertEquals(2002.0, result1, 0.01);
+ Assert.assertEquals(1946.0, result2, 0.01);
+ Assert.assertEquals(1958.0, result3, 0.01);
+ Assert.assertEquals(2012.0, result4, 0.01);
+ Assert.assertEquals(2051.0, result5, 0.01);
+ Assert.assertEquals(1898.0, result6, 0.01);
+ Assert.assertEquals(2014.0, result7, 0.01);
+ Assert.assertEquals(2052.0, result8, 0.01);
+ Assert.assertEquals(1935.0, result9, 0.01);
+ Assert.assertEquals(1901.0, result10, 0.01);
+ Assert.assertEquals(1972.0, result11, 0.01);
+ Assert.assertEquals(1969.0, result12, 0.01);
+ Assert.assertEquals(1984.0, result13, 0.01);
+ Assert.assertEquals(2018.0, result14, 0.01);
+ Assert.assertEquals(1023.0, result15, 0.01);
+ Assert.assertEquals(1056.0, result16, 0.01);
+ Assert.assertEquals(978.0, result17, 0.01);
+ Assert.assertEquals(1050.0, result18, 0.01);
+ Assert.assertEquals(1123.0, result19, 0.01);
+ Assert.assertEquals(1150.0, result20, 0.01);
+ Assert.assertEquals(1134.0, result21, 0.01);
+ Assert.assertEquals(950.0, result22, 0.01);
+ Assert.assertEquals(1059.0, result23, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testTwoSidedFileter4() {
+ String sqlStr = "select TwoSidedFilter(d6.s4, 'len'='3', 'threshold'='0.3') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ resultSet.next();
+ double result3 = resultSet.getDouble(2);
+ resultSet.next();
+ double result4 = resultSet.getDouble(2);
+ resultSet.next();
+ double result5 = resultSet.getDouble(2);
+ resultSet.next();
+ double result6 = resultSet.getDouble(2);
+ resultSet.next();
+ double result7 = resultSet.getDouble(2);
+ resultSet.next();
+ double result8 = resultSet.getDouble(2);
+ resultSet.next();
+ double result9 = resultSet.getDouble(2);
+ resultSet.next();
+ double result10 = resultSet.getDouble(2);
+ resultSet.next();
+ double result11 = resultSet.getDouble(2);
+ resultSet.next();
+ double result12 = resultSet.getDouble(2);
+ resultSet.next();
+ double result13 = resultSet.getDouble(2);
+ resultSet.next();
+ double result14 = resultSet.getDouble(2);
+ resultSet.next();
+ double result15 = resultSet.getDouble(2);
+ resultSet.next();
+ double result16 = resultSet.getDouble(2);
+ resultSet.next();
+ double result17 = resultSet.getDouble(2);
+ resultSet.next();
+ double result18 = resultSet.getDouble(2);
+ resultSet.next();
+ double result19 = resultSet.getDouble(2);
+ resultSet.next();
+ double result20 = resultSet.getDouble(2);
+ resultSet.next();
+ double result21 = resultSet.getDouble(2);
+ resultSet.next();
+ double result22 = resultSet.getDouble(2);
+ resultSet.next();
+ double result23 = resultSet.getDouble(2);
+ Assert.assertEquals(2002.0, result1, 0.01);
+ Assert.assertEquals(1946.0, result2, 0.01);
+ Assert.assertEquals(1958.0, result3, 0.01);
+ Assert.assertEquals(2012.0, result4, 0.01);
+ Assert.assertEquals(2051.0, result5, 0.01);
+ Assert.assertEquals(1898.0, result6, 0.01);
+ Assert.assertEquals(2014.0, result7, 0.01);
+ Assert.assertEquals(2052.0, result8, 0.01);
+ Assert.assertEquals(1935.0, result9, 0.01);
+ Assert.assertEquals(1901.0, result10, 0.01);
+ Assert.assertEquals(1972.0, result11, 0.01);
+ Assert.assertEquals(1969.0, result12, 0.01);
+ Assert.assertEquals(1984.0, result13, 0.01);
+ Assert.assertEquals(2018.0, result14, 0.01);
+ Assert.assertEquals(1023.0, result15, 0.01);
+ Assert.assertEquals(1056.0, result16, 0.01);
+ Assert.assertEquals(978.0, result17, 0.01);
+ Assert.assertEquals(1050.0, result18, 0.01);
+ Assert.assertEquals(1123.0, result19, 0.01);
+ Assert.assertEquals(1150.0, result20, 0.01);
+ Assert.assertEquals(1134.0, result21, 0.01);
+ Assert.assertEquals(950.0, result22, 0.01);
+ Assert.assertEquals(1059.0, result23, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/libudf/it/dmatch/DMatchIT.java b/integration-test/src/test/java/org/apache/iotdb/libudf/it/dmatch/DMatchIT.java
new file mode 100644
index 0000000000..9a7c63a5f0
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/libudf/it/dmatch/DMatchIT.java
@@ -0,0 +1,805 @@
+/*
+ * 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.libudf.it.dmatch;
+
+import org.apache.iotdb.it.env.ConfigFactory;
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.LocalStandaloneIT;
+
+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.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({LocalStandaloneIT.class})
+public class DMatchIT {
+ @BeforeClass
+ public static void setUp() throws Exception {
+ ConfigFactory.getConfig()
+ .setUdfCollectorMemoryBudgetInMB(5)
+ .setUdfTransformerMemoryBudgetInMB(5)
+ .setUdfReaderMemoryBudgetInMB(5);
+ EnvFactory.getEnv().initBeforeClass();
+ createTimeSeries();
+ generateData();
+ registerUDF();
+ }
+
+ private static void createTimeSeries() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.addBatch("create database root.vehicle");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s1 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s2 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s3 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s4 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s5 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s6 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s7 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s8 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s1 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s2 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s3 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s4 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s5 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s6 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s7 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s8 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d3.s1 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d3.s2 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d3.s3 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d3.s4 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d4.s1 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d4.s2 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d4.s3 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d4.s4 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d4.s5 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d4.s6 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d4.s7 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d4.s8 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.executeBatch();
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void generateData() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 100, 100, 100, 100, 100, 101, 101, 101, 101));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 100, 100, 100, 100, 100, 101, 101, 101, 101));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 200, 102, 102, 102, 102, 101, 101, 101, 101));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 300, 104, 104, 104, 104, 102, 102, 102, 102));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 400, 126, 126, 126, 126, 102, 102, 102, 102));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 500, 108, 108, 108, 108, 103, 103, 103, 103));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 600, 112, 112, 112, 112, 104, 104, 104, 104));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 700, 114, 114, 114, 114, 104, 104, 104, 104));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 800, 116, 116, 116, 116, 105, 105, 105, 105));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 900, 118, 118, 118, 118, 105, 105, 105, 105));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 1000, 100, 100, 100, 100, 106, 106, 106, 106));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 1100, 124, 124, 124, 124, 108, 108, 108, 108));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 1200, 126, 126, 126, 126, 108, 108, 108, 108));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 1300, 116, 116, 116, 116, 105, 105, 105, 105));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 100, 1, 1, 1, 1, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 200, 1, 1, 1, 1, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 300, 1, 1, 1, 1, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 400, 1, 1, 1, 1, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 500, 1, 1, 1, 1, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 600, 1, 1, 1, 1, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 700, 1, 1, 1, 1, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 800, 1, 1, 1, 1, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 100, 1, 1, 1, 1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 200, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 300, 3, 3, 3, 3));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 400, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 500, 1, 1, 1, 1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 600, 1, 1, 1, 1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 700, 1, 1, 1, 1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 800, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 900, 3, 3, 3, 3));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1000, 2, 2, 2, 2));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
+ 1100, 1, 1, 1, 1));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 100, 0, 0, 0, 0, 6, 6, 6, 6));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 200, 2, 2, 2, 2, 7, 7, 7, 7));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 300, 3, 3, 3, 3, 0, 0, 0, 0));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 400, 4, 4, 4, 4, 9, 9, 9, 9));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ 500, 5, 5, 5, 5, 10, 10, 10, 10));
+ statement.executeBatch();
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void registerUDF() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute("create function cov as 'org.apache.iotdb.library.dmatch.UDAFCov'");
+ statement.execute("create function dtw as 'org.apache.iotdb.library.dmatch.UDAFDtw'");
+ statement.execute("create function pearson as 'org.apache.iotdb.library.dmatch.UDAFPearson'");
+ statement.execute("create function ptnsym as 'org.apache.iotdb.library.dmatch.UDTFPtnSym'");
+ statement.execute("create function xcorr as 'org.apache.iotdb.library.dmatch.UDTFXCorr'");
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanAfterClass();
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testCov1() {
+ String sqlStr = "select cov(d1.s1,d1.s5) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(12.291666666666666, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testCov2() {
+ String sqlStr = "select cov(d1.s2,d1.s6) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(12.291666666666666, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testCov3() {
+ String sqlStr = "select cov(d1.s3,d1.s7) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(12.291666666666666, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testCov4() {
+ String sqlStr = "select cov(d1.s4,d1.s8) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(12.291666666666666, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testDtw1() {
+ String sqlStr = "select dtw(d2.s1,d2.s5) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(8.0, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testDtw2() {
+ String sqlStr = "select dtw(d2.s2,d2.s6) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(8.0, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testDtw3() {
+ String sqlStr = "select dtw(d2.s3,d2.s7) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(8.0, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testDtw4() {
+ String sqlStr = "select dtw(d2.s4,d2.s8) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(8.0, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testPearson1() {
+ String sqlStr = "select pearson(d1.s1,d1.s5) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(0.5630881927754872, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testPearson2() {
+ String sqlStr = "select pearson(d1.s2,d1.s6) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(0.5630881927754872, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testPearson3() {
+ String sqlStr = "select pearson(d1.s3,d1.s7) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(0.5630881927754872, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testPearson4() {
+ String sqlStr = "select pearson(d1.s4,d1.s8) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ Assert.assertEquals(0.5630881927754872, result1, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testPthSym1() {
+ String sqlStr = "select ptnsym(d1.s1, 'window'='3', 'threshold'='0') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ Assert.assertEquals(0.0, result1, 0.01);
+ Assert.assertEquals(0.0, result2, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testPtnSym2() {
+ String sqlStr = "select ptnsym(d1.s2, 'window'='3', 'threshold'='0') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ Assert.assertEquals(0.0, result1, 0.01);
+ Assert.assertEquals(0.0, result2, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testPtnSym3() {
+ String sqlStr = "select ptnsym(d2.s1, 'window'='3', 'threshold'='0') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ Assert.assertEquals(0.0, result1, 0.01);
+ Assert.assertEquals(0.0, result2, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testPtnSym4() {
+ String sqlStr = "select ptnsym(d2.s2, 'window'='3', 'threshold'='0') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ Assert.assertEquals(0.0, result1, 0.01);
+ Assert.assertEquals(0.0, result2, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testXCorr1() {
+ String sqlStr = "select xcorr(d4.s1,d4.s5) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ resultSet.next();
+ double result3 = resultSet.getDouble(2);
+ resultSet.next();
+ double result4 = resultSet.getDouble(2);
+ resultSet.next();
+ double result5 = resultSet.getDouble(2);
+ resultSet.next();
+ double result6 = resultSet.getDouble(2);
+ resultSet.next();
+ double result7 = resultSet.getDouble(2);
+ resultSet.next();
+ double result8 = resultSet.getDouble(2);
+ resultSet.next();
+ double result9 = resultSet.getDouble(2);
+ Assert.assertEquals(0.0, result1, 0.01);
+ Assert.assertEquals(4.0, result2, 0.01);
+ Assert.assertEquals(9.6, result3, 0.01);
+ Assert.assertEquals(13.4, result4, 0.01);
+ Assert.assertEquals(20.0, result5, 0.01);
+ Assert.assertEquals(15.6, result6, 0.01);
+ Assert.assertEquals(9.2, result7, 0.01);
+ Assert.assertEquals(11.8, result8, 0.01);
+ Assert.assertEquals(6.0, result9, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testXCorr2() {
+ String sqlStr = "select xcorr(d4.s2, d4.s6) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ resultSet.next();
+ double result3 = resultSet.getDouble(2);
+ resultSet.next();
+ double result4 = resultSet.getDouble(2);
+ resultSet.next();
+ double result5 = resultSet.getDouble(2);
+ resultSet.next();
+ double result6 = resultSet.getDouble(2);
+ resultSet.next();
+ double result7 = resultSet.getDouble(2);
+ resultSet.next();
+ double result8 = resultSet.getDouble(2);
+ resultSet.next();
+ double result9 = resultSet.getDouble(2);
+ Assert.assertEquals(0.0, result1, 0.01);
+ Assert.assertEquals(4.0, result2, 0.01);
+ Assert.assertEquals(9.6, result3, 0.01);
+ Assert.assertEquals(13.4, result4, 0.01);
+ Assert.assertEquals(20.0, result5, 0.01);
+ Assert.assertEquals(15.6, result6, 0.01);
+ Assert.assertEquals(9.2, result7, 0.01);
+ Assert.assertEquals(11.8, result8, 0.01);
+ Assert.assertEquals(6.0, result9, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testXCorr3() {
+ String sqlStr = "select xcorr(d4.s3, d4.s7) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ resultSet.next();
+ double result3 = resultSet.getDouble(2);
+ resultSet.next();
+ double result4 = resultSet.getDouble(2);
+ resultSet.next();
+ double result5 = resultSet.getDouble(2);
+ resultSet.next();
+ double result6 = resultSet.getDouble(2);
+ resultSet.next();
+ double result7 = resultSet.getDouble(2);
+ resultSet.next();
+ double result8 = resultSet.getDouble(2);
+ resultSet.next();
+ double result9 = resultSet.getDouble(2);
+ Assert.assertEquals(0.0, result1, 0.01);
+ Assert.assertEquals(4.0, result2, 0.01);
+ Assert.assertEquals(9.6, result3, 0.01);
+ Assert.assertEquals(13.4, result4, 0.01);
+ Assert.assertEquals(20.0, result5, 0.01);
+ Assert.assertEquals(15.6, result6, 0.01);
+ Assert.assertEquals(9.2, result7, 0.01);
+ Assert.assertEquals(11.8, result8, 0.01);
+ Assert.assertEquals(6.0, result9, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testXCorr4() {
+ String sqlStr = "select xcorr(d4.s4,d4.s8) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ resultSet.next();
+ double result3 = resultSet.getDouble(2);
+ resultSet.next();
+ double result4 = resultSet.getDouble(2);
+ resultSet.next();
+ double result5 = resultSet.getDouble(2);
+ resultSet.next();
+ double result6 = resultSet.getDouble(2);
+ resultSet.next();
+ double result7 = resultSet.getDouble(2);
+ resultSet.next();
+ double result8 = resultSet.getDouble(2);
+ resultSet.next();
+ double result9 = resultSet.getDouble(2);
+ Assert.assertEquals(0.0, result1, 0.01);
+ Assert.assertEquals(4.0, result2, 0.01);
+ Assert.assertEquals(9.6, result3, 0.01);
+ Assert.assertEquals(13.4, result4, 0.01);
+ Assert.assertEquals(20.0, result5, 0.01);
+ Assert.assertEquals(15.6, result6, 0.01);
+ Assert.assertEquals(9.2, result7, 0.01);
+ Assert.assertEquals(11.8, result8, 0.01);
+ Assert.assertEquals(6.0, result9, 0.01);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/libudf/it/dprofile/DProfileIT.java b/integration-test/src/test/java/org/apache/iotdb/libudf/it/dprofile/DProfileIT.java
new file mode 100644
index 0000000000..160dbf8ac6
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/libudf/it/dprofile/DProfileIT.java
@@ -0,0 +1,586 @@
+/*
+ * 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.libudf.it.dprofile;
+
+import org.apache.iotdb.it.env.ConfigFactory;
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.LocalStandaloneIT;
+
+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 java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({LocalStandaloneIT.class})
+public class DProfileIT {
+ protected static final int ITERATION_TIMES = 10_000;
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ ConfigFactory.getConfig()
+ .setUdfCollectorMemoryBudgetInMB(5)
+ .setUdfTransformerMemoryBudgetInMB(5)
+ .setUdfReaderMemoryBudgetInMB(5);
+ EnvFactory.getEnv().initBeforeClass();
+ createTimeSeries();
+ generateData();
+ registerUDF();
+ }
+
+ private static void createTimeSeries() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.addBatch("create database root.vehicle");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s1 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s2 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s1 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s2 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.executeBatch();
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void generateData() {
+ double x = -100d, y = 100d; // borders of random value
+ 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) values(%d,%d,%d)",
+ i * 1000,
+ (int) Math.floor(x + Math.random() * y % (y - x + 1)),
+ (int) Math.floor(x + Math.random() * y % (y - x + 1))));
+ statement.execute(
+ (String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%f,%f)",
+ i * 1000,
+ x + Math.random() * y % (y - x + 1),
+ x + Math.random() * y % (y - x + 1))));
+ }
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void registerUDF() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(
+ "create function distinct as 'org.apache.iotdb.library.dprofile.UDTFDistinct'");
+ statement.execute(
+ "create function histogram as 'org.apache.iotdb.library.dprofile.UDTFHistogram'");
+ statement.execute(
+ "create function integral as 'org.apache.iotdb.library.dprofile.UDAFIntegral'");
+ statement.execute(
+ "create function integralavg as 'org.apache.iotdb.library.dprofile.UDAFIntegralAvg'");
+ statement.execute("create function mad as 'org.apache.iotdb.library.dprofile.UDAFMad'");
+ statement.execute("create function median as 'org.apache.iotdb.library.dprofile.UDAFMedian'");
+ statement.execute("create function mode as 'org.apache.iotdb.library.dprofile.UDAFMode'");
+ statement.execute(
+ "create function percentile as 'org.apache.iotdb.library.dprofile.UDAFPercentile'");
+ statement.execute("create function period as 'org.apache.iotdb.library.dprofile.UDAFPeriod'");
+ statement.execute("create function qlb as 'org.apache.iotdb.library.dprofile.UDTFQLB'");
+ statement.execute(
+ "create function resample as 'org.apache.iotdb.library.dprofile.UDTFResample'");
+ statement.execute("create function sample as 'org.apache.iotdb.library.dprofile.UDTFSample'");
+ statement.execute(
+ "create function segment as 'org.apache.iotdb.library.dprofile.UDTFSegment'");
+ statement.execute("create function skew as 'org.apache.iotdb.library.dprofile.UDAFSkew'");
+ statement.execute("create function spread as 'org.apache.iotdb.library.dprofile.UDAFSpread'");
+ statement.execute("create function stddev as 'org.apache.iotdb.library.dprofile.UDAFStddev'");
+ statement.execute("create function minmax as 'org.apache.iotdb.library.dprofile.UDTFMinMax'");
+ statement.execute("create function zscore as 'org.apache.iotdb.library.dprofile.UDTFZScore'");
+ statement.execute("create function spline as 'org.apache.iotdb.library.dprofile.UDTFSpline'");
+ statement.execute("create function mvavg as 'org.apache.iotdb.library.dprofile.UDTFMvAvg'");
+ statement.execute("create function acf as 'org.apache.iotdb.library.dprofile.UDTFACF'");
+ statement.execute("create function pacf as 'org.apache.iotdb.library.dprofile.UDTFPACF'");
+ statement.execute(
+ "create function consistency as 'org.apache.iotdb.library.dquality.UDTFConsistency'");
+ statement.execute(
+ "create function timeliness as 'org.apache.iotdb.library.dquality.UDTFTimeliness'");
+ statement.execute(
+ "create function completeness as 'org.apache.iotdb.library.dquality.UDTFCompleteness'");
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanAfterClass();
+ }
+
+ @Test
+ public void testIntegral1() {
+ String sqlStr = "select integral(d1.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testIntegral2() {
+ String sqlStr = "select completeness(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testIntegralAvg1() {
+ String sqlStr = "select integralavg(d1.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testIntegralAvg2() {
+ String sqlStr = "select integralavg(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testMad1() {
+ String sqlStr = "select mad(d1.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testMad2() {
+ String sqlStr = "select timeliness(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testMedian1() {
+ String sqlStr = "select median(d1.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testMedian2() {
+ String sqlStr = "select median(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testMode1() {
+ String sqlStr = "select consistency(d1.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testPercentile1() {
+ String sqlStr = "select percentile(d1.s2,'rank'='0.7') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testPercentile2() {
+ String sqlStr = "select percentile(d2.s2,'rank'='0.3') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testPeriod1() {
+ String sqlStr = "select period(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testSkew1() {
+ String sqlStr = "select skew(d1.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testSkew2() {
+ String sqlStr = "select skew(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testSpread1() {
+ String sqlStr = "select spread(d1.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testSpread2() {
+ String sqlStr = "select spread(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testSddev1() {
+ String sqlStr = "select stddev(d1.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testStddev2() {
+ String sqlStr = "select stddev(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Object result = resultSet.getObject(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testACF1() {
+ String sqlStr = "select acf(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testDistinct1() {
+ String sqlStr = "select distinct(d1.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testHistogram1() {
+ String sqlStr =
+ String.format(
+ "select histogram(d1.s1,'min'='%f','max'='%f','count'='20') from root.vehicle",
+ -100d, 100d);
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testMinMax1() {
+ String sqlStr =
+ String.format("select minmax(d2.s2,'min'='%f','max'='%f') from root.vehicle", -100d, 100d);
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testMvAvg1() {
+ String sqlStr = "select mvavg(d1.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testMvAvg2() {
+ String sqlStr = "select mvavg(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testPACF1() {
+ String sqlStr = "select pacf(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testQLB1() {
+ String sqlStr = "select qlb(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testResample1() {
+ String sqlStr = "select resample(d2.s1, 'every'='5s') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testResample2() {
+ String sqlStr = "select resample(d2.s2, 'every'='10s', 'aggr'='median') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testSample1() {
+ String sqlStr = "select resample(d2.s1, 'method'='reservoir','k'='5') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testsample2() {
+ String sqlStr = "select resample(d1.s2, 'method'='isometric','k'='5') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testsample3() {
+ String sqlStr = "select sample(d1.s2, 'method'='triangle','k'='5') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testSegment1() {
+ String sqlStr = "select segment(d2.s2,'error'='10') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testSpline1() {
+ String sqlStr = "select spline(d2.s1, 'points'='100') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testZScore1() {
+ String sqlStr = "select zscore(d1.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testZScore2() {
+ String sqlStr = "select zscore(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/libudf/it/dquality/DQualityIT.java b/integration-test/src/test/java/org/apache/iotdb/libudf/it/dquality/DQualityIT.java
new file mode 100644
index 0000000000..757d610c74
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/libudf/it/dquality/DQualityIT.java
@@ -0,0 +1,356 @@
+/*
+ * 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.libudf.it.dquality;
+
+import org.apache.iotdb.it.env.ConfigFactory;
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.LocalStandaloneIT;
+
+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 static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({LocalStandaloneIT.class})
+public class DQualityIT {
+ protected static final int ITERATION_TIMES = 10_000;
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ ConfigFactory.getConfig()
+ .setUdfCollectorMemoryBudgetInMB(5)
+ .setUdfTransformerMemoryBudgetInMB(5)
+ .setUdfReaderMemoryBudgetInMB(5);
+ EnvFactory.getEnv().initBeforeClass();
+ createTimeSeries();
+ generateData();
+ registerUDF();
+ }
+
+ private static void createTimeSeries() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.addBatch("create database root.vehicle");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s1 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s2 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s1 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s2 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.executeBatch();
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void generateData() {
+ double x = -100d, y = 100d; // borders of random value
+ long a = 0, b = 1000000000;
+ 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) values(%d,%d,%d)",
+ (int) Math.floor(a + Math.random() * b % (b - a + 1)),
+ (int) Math.floor(x + Math.random() * y % (y - x + 1)),
+ (int) Math.floor(x + Math.random() * y % (y - x + 1))));
+ statement.execute(
+ (String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%f,%f)",
+ (int) Math.floor(a + Math.random() * b % (b - a + 1)),
+ x + Math.random() * y % (y - x + 1),
+ x + Math.random() * y % (y - x + 1))));
+ }
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void registerUDF() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(
+ "create function completeness as 'org.apache.iotdb.library.dquality.UDTFCompleteness'");
+ statement.execute(
+ "create function timeliness as 'org.apache.iotdb.library.dquality.UDTFTimeliness'");
+ statement.execute(
+ "create function consistency as 'org.apache.iotdb.library.dquality.UDTFConsistency'");
+ statement.execute(
+ "create function validity as 'org.apache.iotdb.library.dquality.UDTFValidity'");
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanAfterClass();
+ }
+
+ @Test
+ public void testCompleteness1() {
+ String sqlStr = "select completeness(d1.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testCompleteness2() {
+ String sqlStr = "select completeness(d1.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testCompleteness3() {
+ String sqlStr = "select completeness(d2.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testCompleteness4() {
+ String sqlStr = "select completeness(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testTimeliness1() {
+ String sqlStr = "select timeliness(d1.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testTimeliness2() {
+ String sqlStr = "select timeliness(d1.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testTimeliness3() {
+ String sqlStr = "select timeliness(d2.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testTimeliness4() {
+ String sqlStr = "select timeliness(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testConsistency1() {
+ String sqlStr = "select consistency(d1.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testConsistency2() {
+ String sqlStr = "select consistency(d1.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testConsistency3() {
+ String sqlStr = "select consistency(d2.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testConsistency4() {
+ String sqlStr = "select consistency(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testValidity1() {
+ String sqlStr = "select validity(d1.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testValidity2() {
+ String sqlStr = "select validity(d1.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testValidity3() {
+ String sqlStr = "select validity(d2.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testValidity4() {
+ String sqlStr = "select validity(d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result = resultSet.getDouble(2);
+ Assert.assertTrue(result >= -0.0D && result <= 1.0D);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/libudf/it/drepair/DRepairIT.java b/integration-test/src/test/java/org/apache/iotdb/libudf/it/drepair/DRepairIT.java
new file mode 100644
index 0000000000..4c44ef9637
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/libudf/it/drepair/DRepairIT.java
@@ -0,0 +1,279 @@
+/*
+ * 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.libudf.it.drepair;
+
+import org.apache.iotdb.it.env.ConfigFactory;
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.LocalStandaloneIT;
+
+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 java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({LocalStandaloneIT.class})
+public class DRepairIT {
+ protected static final int ITERATION_TIMES = 1_000;
+ protected static final int DELTA_T = 100;
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ ConfigFactory.getConfig()
+ .setUdfCollectorMemoryBudgetInMB(5)
+ .setUdfTransformerMemoryBudgetInMB(5)
+ .setUdfReaderMemoryBudgetInMB(5);
+ EnvFactory.getEnv().initBeforeClass();
+ createTimeSeries();
+ generateData();
+ registerUDF();
+ }
+
+ private static void createTimeSeries() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.addBatch("create database root.vehicle");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s1 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s1 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d3.s1 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.executeBatch();
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void generateData() {
+ double x = -100d, y = 100d; // borders of random value
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ for (int i = 1; i <= ITERATION_TIMES; ++i) {
+ if (Math.random() < 0.99) {
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1) values(%d,%d)",
+ (long) i * DELTA_T, (int) Math.floor(x + Math.random() * y % (y - x + 1))));
+ } else {
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1) values(%d,%d)",
+ (long) i * DELTA_T + (long) Math.floor((Math.random() - 0.5) * DELTA_T),
+ (int) Math.floor(x + Math.random() * y % (y - x + 1))));
+ }
+ }
+ for (int i = 1; i <= ITERATION_TIMES; ++i) {
+ if (Math.random() < 0.97) {
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1) values(%d,%d)",
+ (long) i * DELTA_T, (long) Math.floor(x + Math.random() * y % (y - x + 1))));
+ } else {
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1) values(%d,%d)",
+ (long) i * DELTA_T, 0));
+ }
+ }
+ for (int i = 1; i <= ITERATION_TIMES; ++i) {
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d3(timestamp,s1) values(%d,%f)",
+ (long) i * DELTA_T,
+ i / (double) ITERATION_TIMES * (y - x) + (Math.random() - 0.5) * (y - x)));
+ }
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void registerUDF() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(
+ "create function timestamprepair as 'org.apache.iotdb.library.drepair.UDTFTimestampRepair'");
+ statement.execute(
+ "create function valuefill as 'org.apache.iotdb.library.drepair.UDTFValueFill'");
+ statement.execute(
+ "create function valuerepair as 'org.apache.iotdb.library.drepair.UDTFValueRepair'");
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanAfterClass();
+ }
+
+ @Test
+ public void testTimestampRepair1() {
+ String sqlStr =
+ String.format("select timestamprepair(d1.s1,'interval'='%d') from root.vehicle", DELTA_T);
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testTimestampRepair2() {
+ String sqlStr = "select timestamprepair(d1.s1,'method'='median') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testTimestampRepair3() {
+ String sqlStr = "select timestamprepair(d1.s1,'method'='mode') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testTimestampRepair4() {
+ String sqlStr = "select timestamprepair(d1.s1,'method'='cluster') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testValueFill1() {
+ String sqlStr = "select valuefill(d2.s1,'method'='previous') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testValueFill2() {
+ String sqlStr = "select valuefill(d2.s1,'method'='linear') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testValueFill3() {
+ String sqlStr = "select valuefill(d2.s1,'method'='likelihood') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testValueFill4() {
+ String sqlStr = "select valuefill(d2.s1,'method'='ar') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testValueFill5() {
+ String sqlStr = "select valuefill(d2.s1,'method'='mean') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testValueFill6() {
+ String sqlStr = "select valuefill(d2.s1,'method'='screen') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testValueRepair1() {
+ String sqlStr = "select valuerepair(d3.s1,'method'='screen') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testValueRepair2() {
+ String sqlStr = "select valuerepair(d3.s1,'method'='lsgreedy') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/libudf/it/frequency/FrequencyIT.java b/integration-test/src/test/java/org/apache/iotdb/libudf/it/frequency/FrequencyIT.java
new file mode 100644
index 0000000000..326b65df59
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/libudf/it/frequency/FrequencyIT.java
@@ -0,0 +1,282 @@
+/*
+ * 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.libudf.it.frequency;
+
+import org.apache.iotdb.it.env.ConfigFactory;
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.LocalStandaloneIT;
+
+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.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({LocalStandaloneIT.class})
+public class FrequencyIT {
+ protected static final int ITERATION_TIMES = 16384;
+ protected static final int DELTA_T = 100;
+ protected static final int PERIOD_1 = 10;
+ protected static final int PEROID_2 = 200;
+ protected static final double pi = Math.PI;
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ ConfigFactory.getConfig()
+ .setUdfCollectorMemoryBudgetInMB(5)
+ .setUdfTransformerMemoryBudgetInMB(5)
+ .setUdfReaderMemoryBudgetInMB(5);
+ EnvFactory.getEnv().initBeforeClass();
+ createTimeSeries();
+ generateData();
+ registerUDF();
+ }
+
+ private static void createTimeSeries() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.addBatch("create database root.vehicle");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s1 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s2 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s3 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s1 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s2 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.executeBatch();
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void generateData() {
+ double x = -100d, y = 100d; // borders of random value
+ long a = 0, b = 1000000000;
+ 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.d1(timestamp,s1,s2,s3) values(%d,%f,%f,%f)",
+ (long) (i + 1) * DELTA_T,
+ Math.sin(i % PERIOD_1 * 2 * pi / (double) PERIOD_1),
+ Math.sin(i % PEROID_2 * 2 * pi / (double) PEROID_2),
+ 0.5 * Math.sin(i % PERIOD_1 * pi) + Math.sin(i % PEROID_2 * pi)));
+ }
+ statement.execute(
+ String.format("insert into root.vehicle.d2(timestamp,s1) values(%d, 2)", DELTA_T));
+ statement.execute(
+ String.format("insert into root.vehicle.d2(timestamp,s1) values(%d, 7)", 2 * DELTA_T));
+ statement.execute(
+ String.format("insert into root.vehicle.d2(timestamp,s1) values(%d, 4)", 3 * DELTA_T));
+ statement.execute(
+ String.format("insert into root.vehicle.d2(timestamp,s1) values(%d, 9)", 4 * DELTA_T));
+ statement.execute(
+ String.format("insert into root.vehicle.d2(timestamp,s2) values(%d, 1)", DELTA_T));
+ statement.execute(
+ String.format("insert into root.vehicle.d2(timestamp,s2) values(%d, 0)", 2 * DELTA_T));
+ statement.execute(
+ String.format("insert into root.vehicle.d2(timestamp,s2) values(%d, 1)", 3 * DELTA_T));
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void registerUDF() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute("create function conv as 'org.apache.iotdb.library.frequency.UDTFConv'");
+ statement.execute(
+ "create function deconv as 'org.apache.iotdb.library.frequency.UDTFDeconv'");
+ statement.execute("create function dwt as 'org.apache.iotdb.library.frequency.UDTFDWT'");
+ statement.execute("create function fft as 'org.apache.iotdb.library.frequency.UDTFFFT'");
+ statement.execute(
+ "create function highpass as 'org.apache.iotdb.library.frequency.UDTFHighPass'");
+ statement.execute("create function idwt as 'org.apache.iotdb.library.frequency.UDTFIDWT'");
+ statement.execute(
+ "create function lowpass as 'org.apache.iotdb.library.frequency.UDTFLowPass'");
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanAfterClass();
+ }
+
+ // No possible tests for IDWT, IFFT
+ @Test
+ public void testConv1() {
+ String sqlStr = "select conv(d1.s1, d1.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ resultSet.getDouble(2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testDeconv1() {
+ String sqlStr = "select deconv(d2.s1,d2.s2) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ double result2 = resultSet.getDouble(2);
+ Assert.assertTrue(Math.abs(result1 - 2d) < 1e-5 && Math.abs(result2 - 7d) < 1e-5);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testDeconv2() {
+ String sqlStr = "select deconv(d2.s1,d2.s2,'result'='remainder') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ Double result1 = resultSet.getDouble(2);
+ resultSet.next();
+ Double result2 = resultSet.getDouble(2);
+ resultSet.next();
+ Double result3 = resultSet.getDouble(2);
+ resultSet.next();
+ Double result4 = resultSet.getDouble(2);
+ Assert.assertTrue(
+ Math.abs(result1) < 1e-5
+ && Math.abs(result2) < 1e-5
+ && Math.abs(result3 - 2d) < 1e-5
+ && Math.abs(result4 - 2d) < 1e-5);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testDWT1() {
+ String sqlStr = "select dwt(d2.s3,'method'='haar') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testDWT2() {
+ String sqlStr = "select dwt(d2.s3,'method'='DB4') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testFFT1() {
+ String sqlStr = "select fft(d1.s1) from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testHighPass1() {
+ String sqlStr = "select highpass(d1.s3,'wpass'='0.5') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet1 = statement.executeQuery(sqlStr);
+ ResultSet resultSet2 = statement.executeQuery("select d1.s1 from root.vehicle");
+ for (int i = 1; i < ITERATION_TIMES; ++i) {
+ resultSet1.next();
+ resultSet2.next();
+ double result1 = resultSet1.getDouble(2);
+ double result2 = resultSet2.getDouble(2);
+ Assert.assertTrue(Math.abs(result1 - 0.5 * result2) < 1e-2);
+ }
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testLowPass1() {
+ String sqlStr = "select lowpass(d1.s3,'wpass'='0.5') from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet1 = statement.executeQuery(sqlStr);
+ ResultSet resultSet2 = statement.executeQuery("select d1.s2 from root.vehicle");
+ for (int i = 1; i < ITERATION_TIMES; ++i) {
+ resultSet1.next();
+ resultSet2.next();
+ double result1 = resultSet1.getDouble(2);
+ double result2 = resultSet2.getDouble(2);
+ Assert.assertTrue(Math.abs(result1 - result2) < 1e-2);
+ }
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/libudf/it/series/SeriesIT.java b/integration-test/src/test/java/org/apache/iotdb/libudf/it/series/SeriesIT.java
new file mode 100644
index 0000000000..7c78eb49e0
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/libudf/it/series/SeriesIT.java
@@ -0,0 +1,472 @@
+/*
+ * 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.libudf.it.series;
+
+import org.apache.iotdb.it.env.ConfigFactory;
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.LocalStandaloneIT;
+
+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.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({LocalStandaloneIT.class})
+public class SeriesIT {
+ protected static final int ITERATION_TIMES = 10_000;
+
+ protected static final long TIMESTAMP_INTERVAL = 60; // gap = 60ms
+
+ protected static final long START_TIMESTAMP = 0;
+
+ protected static final long END_TIMESTAMP = START_TIMESTAMP + ITERATION_TIMES * ITERATION_TIMES;
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ ConfigFactory.getConfig()
+ .setUdfCollectorMemoryBudgetInMB(5)
+ .setUdfTransformerMemoryBudgetInMB(5)
+ .setUdfReaderMemoryBudgetInMB(5);
+ EnvFactory.getEnv().initBeforeClass();
+ createTimeSeries();
+ generateData();
+ registerUDF();
+ }
+
+ private static void createTimeSeries() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.addBatch("create database root.vehicle");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s1 with "
+ + "datatype=int32, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s2 with "
+ + "datatype=int64, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s1 with "
+ + "datatype=float, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s2 with "
+ + "datatype=double, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.executeBatch();
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void generateData() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ // d1
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577808000000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577808300000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577808600000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577809200000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577809500000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577809800000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577810100000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1) values(%d,%d)",
+ 1577810400000L, 1)); // s2 == null
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577810700000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577811000000L, 1, 1));
+ // d2
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577808000000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577808300000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577808600000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577809200000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577809500000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577809800000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577810100000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1) values(%d,%d)",
+ 1577810400000L, 1)); // s2 == null
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577810700000L, 1, 1));
+ statement.execute(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)",
+ 1577811000000L, 1, 1));
+
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void registerUDF() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(
+ "create function ConsecutiveSequences as 'org.apache.iotdb.library.series.UDTFConsecutiveSequences'");
+ statement.execute(
+ "create function ConsecutiveWindows as 'org.apache.iotdb.library.series.UDTFConsecutiveWindows'");
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanAfterClass();
+ }
+
+ @Test
+ public void testConsecutiveSequences1() {
+ String sqlStr = "select ConsecutiveSequences(d1.s1,d1.s2) from root.vehicle";
+ long timeStamp = 0;
+ int value = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+
+ resultSet.next();
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577808000000L);
+ Assert.assertEquals(value, 3);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577809200000L);
+ Assert.assertEquals(value, 4);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577810700000L);
+ Assert.assertEquals(value, 2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testConsecutiveSequences2() {
+ String sqlStr = "select ConsecutiveSequences(d2.s1,d2.s2) from root.vehicle";
+ long timeStamp = 0;
+ int value = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577808000000L);
+ Assert.assertEquals(value, 3);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577809200000L);
+ Assert.assertEquals(value, 4);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577810700000L);
+ Assert.assertEquals(value, 2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testConsecutiveSequences3() {
+ String sqlStr = "select ConsecutiveSequences(d1.s1,d1.s2,'gap'='5m') from root.vehicle";
+ long timeStamp = 0;
+ int value = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577808000000L);
+ Assert.assertEquals(value, 3);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577809200000L);
+ Assert.assertEquals(value, 4);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577810700000L);
+ Assert.assertEquals(value, 2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testConsecutiveSequences4() {
+ String sqlStr = "select ConsecutiveSequences(d2.s1,d2.s2,'gap'='5m') from root.vehicle";
+ long timeStamp = 0;
+ int value = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577808000000L);
+ Assert.assertEquals(value, 3);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577809200000L);
+ Assert.assertEquals(value, 4);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577810700000L);
+ Assert.assertEquals(value, 2);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testConsecutiveWindows1() {
+ String sqlStr = "select ConsecutiveWindows(d1.s1,d1.s2,'length'='10m') from root.vehicle";
+ long timeStamp = 0;
+ int value = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577808000000L);
+ Assert.assertEquals(value, 3);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577809200000L);
+ Assert.assertEquals(value, 3);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577809500000L);
+ Assert.assertEquals(value, 3);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testConsecutiveWindows2() {
+ String sqlStr = "select ConsecutiveWindows(d2.s1,d2.s2,'length'='10m') from root.vehicle";
+ long timeStamp = 0;
+ int value = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577808000000L);
+ Assert.assertEquals(value, 3);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577809200000L);
+ Assert.assertEquals(value, 3);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577809500000L);
+ Assert.assertEquals(value, 3);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testConsecutiveWindows3() {
+ String sqlStr =
+ "select ConsecutiveWindows(d1.s1,d1.s2,'length'='10m','gap'='5m') from root.vehicle";
+ long timeStamp = 0;
+ int value = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577808000000L);
+ Assert.assertEquals(value, 3);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577809200000L);
+ Assert.assertEquals(value, 3);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577809500000L);
+ Assert.assertEquals(value, 3);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Ignore // TODO: This test case failed, please check the function implementation
+ @Test
+ public void testConsecutiveWindows4() {
+ String sqlStr =
+ "select ConsecutiveWindows(d2.s1,d2.s2,'length'='10m','gap'='5m') from root.vehicle";
+ long timeStamp = 0;
+ int value = 0;
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577808000000L);
+ Assert.assertEquals(value, 3);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577809200000L);
+ Assert.assertEquals(value, 3);
+
+ resultSet.next();
+
+ timeStamp = resultSet.getLong(1);
+ value = resultSet.getInt(2);
+ Assert.assertEquals(timeStamp, 1577809500000L);
+ Assert.assertEquals(value, 3);
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/libudf/it/string/StringIT.java b/integration-test/src/test/java/org/apache/iotdb/libudf/it/string/StringIT.java
new file mode 100644
index 0000000000..b5c10572c1
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/libudf/it/string/StringIT.java
@@ -0,0 +1,252 @@
+/*
+ * 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.libudf.it.string;
+
+import org.apache.iotdb.it.env.ConfigFactory;
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.LocalStandaloneIT;
+
+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 static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({LocalStandaloneIT.class})
+public class StringIT {
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ ConfigFactory.getConfig()
+ .setUdfCollectorMemoryBudgetInMB(5)
+ .setUdfTransformerMemoryBudgetInMB(5)
+ .setUdfReaderMemoryBudgetInMB(5);
+ EnvFactory.getEnv().initBeforeClass();
+ createTimeSeries();
+ generateData();
+ registerUDF();
+ }
+
+ private static void createTimeSeries() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.addBatch("create database root.vehicle");
+ statement.addBatch(
+ "create timeseries root.vehicle.d1.s1 with "
+ + "datatype=text, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.addBatch(
+ "create timeseries root.vehicle.d2.s1 with "
+ + "datatype=text, "
+ + "encoding=plain, "
+ + "compression=uncompressed");
+ statement.executeBatch();
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void generateData() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1) values(%d,%s)",
+ 100, "\"[192.168.0.1] [SUCCESS]\""));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1) values(%d,%s)",
+ 200, "\"[192.168.0.24] [SUCCESS]\""));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1) values(%d,%s)",
+ 300, "\"[192.168.0.2] [FAIL]\""));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1) values(%d,%s)",
+ 400, "\"[192.168.0.5] [SUCCESS]\""));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d1(timestamp,s1) values(%d,%s)",
+ 500, "\"[192.168.0.124] [SUCCESS]\""));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1) values(%d,%s)", 100, "\"A,B,A+,B-\""));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1) values(%d,%s)", 200, "\"A,A+,A,B+\""));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1) values(%d,%s)", 300, "\"B+,B,B\""));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1) values(%d,%s)", 400, "\"A+,A,A+,A\""));
+ statement.addBatch(
+ String.format(
+ "insert into root.vehicle.d2(timestamp,s1) values(%d,%s)", 500, "\"A,B-,B,B\""));
+ statement.executeBatch();
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ private static void registerUDF() {
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(
+ "create function regexmatch as 'org.apache.iotdb.library.string.UDTFRegexMatch'");
+ statement.execute(
+ "create function regexreplace as 'org.apache.iotdb.library.string.UDTFRegexReplace'");
+ statement.execute(
+ "create function regexsplit as 'org.apache.iotdb.library.string.UDTFRegexSplit'");
+ statement.execute(
+ "create function strreplace as 'org.apache.iotdb.library.string.UDTFStrReplace'");
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanAfterClass();
+ }
+
+ @Test
+ public void testRegexMatch1() {
+ String sqlStr =
+ "select regexmatch(d1.s1,\"regex\"=\"\\d+\\.\\d+\\.\\d+\\.\\d+\", \"group\"=\"0\") from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ String result1 = resultSet.getString(2);
+ resultSet.next();
+ String result2 = resultSet.getString(2);
+ resultSet.next();
+ String result3 = resultSet.getString(2);
+ resultSet.next();
+ String result4 = resultSet.getString(2);
+ resultSet.next();
+ String result5 = resultSet.getString(2);
+ Assert.assertEquals("192.168.0.1", result1);
+ Assert.assertEquals("192.168.0.24", result2);
+ Assert.assertEquals("192.168.0.2", result3);
+ Assert.assertEquals("192.168.0.5", result4);
+ Assert.assertEquals("192.168.0.124", result5);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testRegexReplace1() {
+ String sqlStr =
+ "select regexreplace(d1.s1,\"regex\"=\"192\\.168\\.0\\.(\\d+)\", \"replace\"=\"cluster-$1\") from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ String result1 = resultSet.getString(2);
+ resultSet.next();
+ String result2 = resultSet.getString(2);
+ resultSet.next();
+ String result3 = resultSet.getString(2);
+ resultSet.next();
+ String result4 = resultSet.getString(2);
+ resultSet.next();
+ String result5 = resultSet.getString(2);
+ Assert.assertEquals("[cluster-1] [SUCCESS]", result1);
+ Assert.assertEquals("[cluster-24] [SUCCESS]", result2);
+ Assert.assertEquals("[cluster-2] [FAIL]", result3);
+ Assert.assertEquals("[cluster-5] [SUCCESS]", result4);
+ Assert.assertEquals("[cluster-124] [SUCCESS]", result5);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testRegexSplit1() {
+ String sqlStr = "select regexsplit(d2.s1, \"regex\"=\",\", \"index\"=\"-1\") from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ int result1 = resultSet.getInt(2);
+ resultSet.next();
+ int result2 = resultSet.getInt(2);
+ resultSet.next();
+ int result3 = resultSet.getInt(2);
+ resultSet.next();
+ int result4 = resultSet.getInt(2);
+ resultSet.next();
+ int result5 = resultSet.getInt(2);
+ Assert.assertEquals(4, result1);
+ Assert.assertEquals(4, result2);
+ Assert.assertEquals(3, result3);
+ Assert.assertEquals(4, result4);
+ Assert.assertEquals(4, result5);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+
+ @Test
+ public void testStrReplace1() {
+ String sqlStr =
+ "select strreplace(d2.s1,\"target\"=\",\", \"replace\"=\"/\", \"limit\"=\"2\") from root.vehicle";
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement()) {
+ ResultSet resultSet = statement.executeQuery(sqlStr);
+ resultSet.next();
+ String result1 = resultSet.getString(2);
+ resultSet.next();
+ String result2 = resultSet.getString(2);
+ resultSet.next();
+ String result3 = resultSet.getString(2);
+ resultSet.next();
+ String result4 = resultSet.getString(2);
+ resultSet.next();
+ String result5 = resultSet.getString(2);
+ Assert.assertEquals("A/B/A+,B-", result1);
+ Assert.assertEquals("A/A+/A,B+", result2);
+ Assert.assertEquals("B+/B/B", result3);
+ Assert.assertEquals("A+/A/A+,A", result4);
+ Assert.assertEquals("A/B-/B,B", result5);
+ Assert.assertFalse(resultSet.next());
+ } catch (SQLException throwable) {
+ fail(throwable.getMessage());
+ }
+ }
+}
[iotdb] 01/02: [IOTDB-5190] Move Library-udf IT to integration-test
Posted by ha...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
haonan pushed a commit to branch move_udf_it
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit 8b69c2a6c22e9c112ff82ff1f9ac7f3152621a20
Author: HTHou <hh...@outlook.com>
AuthorDate: Tue Dec 13 15:27:24 2022 +0800
[IOTDB-5190] Move Library-udf IT to integration-test
---
.github/workflows/main-unix.yml | 2 +-
.github/workflows/main-win.yml | 2 +-
Jenkinsfile | 2 +-
integration-test/pom.xml | 5 +
library-udf/pom.xml | 50 +-
.../apache/iotdb/library/anomaly/AnomalyTests.java | 1558 --------------------
.../apache/iotdb/library/dmatch/DMatchTests.java | 854 -----------
.../iotdb/library/dprofile/DProfileTests.java | 646 --------
.../iotdb/library/dquality/DQualityTests.java | 389 -----
.../apache/iotdb/library/drepair/DRepairTests.java | 320 ----
.../iotdb/library/frequency/FrequencyTests.java | 309 ----
.../apache/iotdb/library/series/SeriesTest.java | 471 ------
.../apache/iotdb/library/string/StringTests.java | 260 ----
13 files changed, 19 insertions(+), 4849 deletions(-)
diff --git a/.github/workflows/main-unix.yml b/.github/workflows/main-unix.yml
index 937353f0e4..1d471e745b 100644
--- a/.github/workflows/main-unix.yml
+++ b/.github/workflows/main-unix.yml
@@ -61,4 +61,4 @@ jobs:
- name: IT/UT Test
shell: bash
# we do not compile client-cpp for saving time, it is tested in client.yml
- run: mvn -B clean test -Dtest.port.closed=true -P '!testcontainer' -P compile-library-udf
+ run: mvn -B clean test -Dtest.port.closed=true -P '!testcontainer' -P get-jar-with-dependencies
diff --git a/.github/workflows/main-win.yml b/.github/workflows/main-win.yml
index 4e496d10db..0778ad1b55 100644
--- a/.github/workflows/main-win.yml
+++ b/.github/workflows/main-win.yml
@@ -109,5 +109,5 @@ jobs:
- name: Test Other Modules with Maven
shell: bash
if: ${{ matrix.it_task == 'others'}}
- run: source ~/.bash_profile && mvn -B clean test -Dtest.port.closed=true -Diotdb.test.skip=true -P compile-library-udf
+ run: source ~/.bash_profile && mvn -B clean test -Dtest.port.closed=true -Diotdb.test.skip=true -P get-jar-with-dependencies
diff --git a/Jenkinsfile b/Jenkinsfile
index 782c21b448..6212f96b57 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -106,7 +106,7 @@ pipeline {
sh 'mvn clean'
// We'll deploy to a relative directory so we can
// deploy new versions only if the entire build succeeds
- sh 'mvn ${MVN_TEST_FAIL_IGNORE} -DaltDeploymentRepository=snapshot-repo::default::file:./local-snapshots-dir clean deploy -P get-jar-with-dependencies
+ sh 'mvn ${MVN_TEST_FAIL_IGNORE} -DaltDeploymentRepository=snapshot-repo::default::file:./local-snapshots-dir clean deploy -P get-jar-with-dependencies'
}
post {
always {
diff --git a/integration-test/pom.xml b/integration-test/pom.xml
index e5e1387374..3829a3131a 100644
--- a/integration-test/pom.xml
+++ b/integration-test/pom.xml
@@ -68,6 +68,11 @@
<artifactId>iotdb-confignode</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.apache.iotdb</groupId>
+ <artifactId>library-udf</artifactId>
+ <version>${project.version}</version>
+ </dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
diff --git a/library-udf/pom.xml b/library-udf/pom.xml
index 71073062a6..6ddc52ca02 100644
--- a/library-udf/pom.xml
+++ b/library-udf/pom.xml
@@ -78,6 +78,16 @@
<groupId>com.github.chen0040</groupId>
<artifactId>java-local-outlier-factor</artifactId>
<version>1.0.4</version>
+ <exclusions>
+ <exclusion>
+ <groupId>log4j</groupId>
+ <artifactId>log4j</artifactId>
+ </exclusion>
+ <exclusion>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-log4j12</artifactId>
+ </exclusion>
+ </exclusions>
</dependency>
<!-- FFT, IFFT, LowPass, HighPass -->
<dependency>
@@ -100,24 +110,6 @@
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
</dependency>
- <dependency>
- <groupId>org.junit.jupiter</groupId>
- <artifactId>junit-jupiter-api</artifactId>
- <version>5.8.2</version>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.apache.iotdb</groupId>
- <artifactId>integration</artifactId>
- <version>${project.version}</version>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.apache.iotdb</groupId>
- <artifactId>iotdb-jdbc</artifactId>
- <version>${project.version}</version>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.apache.iotdb</groupId>
<artifactId>iotdb-server</artifactId>
@@ -137,7 +129,7 @@
</dependencies>
<profiles>
<profile>
- <id>compile-library-udf</id>
+ <id>get-jar-with-dependencies</id>
<build>
<plugins>
<plugin>
@@ -171,26 +163,6 @@
<artifactId>maven-resources-plugin</artifactId>
<version>2.4.3</version>
</plugin>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-surefire-plugin</artifactId>
- <version>3.0.0-M5</version>
- <dependencies>
- <dependency>
- <groupId>org.junit.jupiter</groupId>
- <artifactId>junit-jupiter-engine</artifactId>
- <version>5.8.2</version>
- </dependency>
- </dependencies>
- </plugin>
- <plugin>
- <groupId>org.codehaus.mojo</groupId>
- <artifactId>exec-maven-plugin</artifactId>
- <version>1.6.0</version>
- <configuration>
- <classpathScope>test</classpathScope>
- </configuration>
- </plugin>
</plugins>
</build>
</profile>
diff --git a/library-udf/src/test/java/org/apache/iotdb/library/anomaly/AnomalyTests.java b/library-udf/src/test/java/org/apache/iotdb/library/anomaly/AnomalyTests.java
deleted file mode 100644
index 09fd440533..0000000000
--- a/library-udf/src/test/java/org/apache/iotdb/library/anomaly/AnomalyTests.java
+++ /dev/null
@@ -1,1558 +0,0 @@
-/*
- * 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.library.anomaly;
-
-import org.apache.iotdb.commons.exception.IllegalPathException;
-import org.apache.iotdb.commons.exception.MetadataException;
-import org.apache.iotdb.commons.path.PartialPath;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
-import org.apache.iotdb.db.metadata.LocalSchemaProcessor;
-import org.apache.iotdb.integration.env.ConfigFactory;
-import org.apache.iotdb.integration.env.EnvFactory;
-import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
-
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.sql.Connection;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
-
-import static org.junit.Assert.fail;
-
-public class AnomalyTests {
- private static final float oldUdfCollectorMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfCollectorMemoryBudgetInMB();
- private static final float oldUdfTransformerMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfTransformerMemoryBudgetInMB();
- private static final float oldUdfReaderMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfReaderMemoryBudgetInMB();
-
- @BeforeClass
- public static void setUp() throws Exception {
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(5)
- .setUdfTransformerMemoryBudgetInMB(5)
- .setUdfReaderMemoryBudgetInMB(5);
- EnvFactory.getEnv().initBeforeClass();
- createTimeSeries();
- generateData();
- registerUDF();
- }
-
- private static void createTimeSeries() throws MetadataException, IllegalPathException {
- LocalSchemaProcessor.getInstance().setStorageGroup(new PartialPath("root.vehicle"));
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s1"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s2"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s3"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s4"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s1"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s2"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s3"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s4"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d3.s1"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d3.s2"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d3.s3"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d3.s4"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d3.s5"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d3.s6"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d3.s7"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d3.s8"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d4.s1"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d4.s2"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d4.s3"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d4.s4"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d6.s1"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d6.s2"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d6.s3"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d6.s4"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- }
-
- private static void generateData() {
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 100, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 200, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 300, -2, -2, -2, -2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 400, -1, -1, -1, -1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 500, 10, 10, 10, 10));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 600, 1, 1, 1, 1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 700, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 800, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 900, -1, -1, -1, -1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1000, 1, 1, 1, 1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 100, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 200, 50, 50, 50, 50));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 300, 100, 100, 100, 100));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 400, 150, 150, 150, 150));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 500, 200, 200, 200, 200));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 600, 200, 200, 200, 200));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 700, 200, 200, 200, 200));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 800, 200, 200, 200, 200));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 900, 200, 200, 200, 200));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1000, 200, 200, 200, 200));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1100, 150, 150, 150, 150));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1200, 100, 100, 100, 100));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1300, 50, 50, 50, 50));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1400, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 100, 0, 0, 0, 0, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 200, 0, 0, 0, 0, 1, 1, 1, 1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 300, 1, 1, 1, 1, 1, 1, 1, 1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 400, 1, 1, 1, 1, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 500, 0, 0, 0, 0, -1, -1, -1, -1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 600, -1, -1, -1, -1, -1, -1, -1, -1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 700, -1, -1, -1, -1, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 800, 2, 2, 2, 2, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 100, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 200, 1, 1, 1, 1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 300, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 400, 1, 1, 1, 1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 500, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 600, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 700, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 800, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 900, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1000, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1100, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1200, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1300, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1400, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1500, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1600, 1, 1, 1, 1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1700, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1800, 1, 1, 1, 1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1900, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 2000, 1, 1, 1, 1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 100, 2002, 2002, 2002, 2002));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 200, 1946, 1946, 1946, 1946));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 300, 1958, 1958, 1958, 1958));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 400, 2012, 2012, 2012, 2012));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 500, 2051, 2051, 2051, 2051));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 600, 1898, 1898, 1898, 1898));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 700, 2014, 2014, 2014, 2014));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 800, 2052, 2052, 2052, 2052));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 900, 1935, 1935, 1935, 1935));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1000, 1901, 1901, 1901, 1901));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1100, 1972, 1972, 1972, 1972));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1200, 1969, 1969, 1969, 1969));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1300, 1984, 1984, 1984, 1984));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1400, 2018, 2018, 2018, 2018));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1500, 1484, 1484, 1484, 1484));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1600, 1055, 1055, 1055, 1055));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1700, 1050, 1050, 1050, 1050));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1800, 1023, 1023, 1023, 1023));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1900, 1056, 1056, 1056, 1056));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 2000, 978, 978, 978, 978));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 2100, 1050, 1050, 1050, 1050));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 2200, 1123, 1123, 1123, 1123));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 2300, 1150, 1150, 1150, 1150));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 2400, 1034, 1034, 1034, 1034));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 2500, 950, 950, 950, 950));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d6(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 2600, 1059, 1059, 1059, 1059));
- statement.executeBatch();
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- private static void registerUDF() {
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- statement.execute("create function iqr as 'org.apache.iotdb.library.anomaly.UDTFIQR'");
- statement.execute("create function ksigma as 'org.apache.iotdb.library.anomaly.UDTFKSigma'");
- statement.execute(
- "create function missdetect as 'org.apache.iotdb.library.anomaly.UDTFMissDetect'");
- statement.execute("create function lof as 'org.apache.iotdb.library.anomaly.UDTFLOF'");
- statement.execute("create function range as 'org.apache.iotdb.library.anomaly.UDTFRange'");
- statement.execute(
- "create function TwoSidedFilter as 'org.apache.iotdb.library.anomaly.UDTFTwoSidedFilter'");
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @AfterClass
- public static void tearDown() throws Exception {
- EnvFactory.getEnv().cleanAfterClass();
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(oldUdfCollectorMemoryBudgetInMB)
- .setUdfTransformerMemoryBudgetInMB(oldUdfTransformerMemoryBudgetInMB)
- .setUdfReaderMemoryBudgetInMB(oldUdfReaderMemoryBudgetInMB);
- }
-
- @Test
- public void testIRQR1() {
- String sqlStr = "select iqr(d1.s1) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(10.0, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testIQR2() {
- String sqlStr = "select iqr(d1.s2) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(10.0, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testIQR3() {
- String sqlStr = "select iqr(d1.s3) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(10.0, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testIQR4() {
- String sqlStr = "select iqr(d1.s4) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(10.0, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testKSigma1() {
- String sqlStr = "select ksigma(d2.s1,\"k\"=\"1.0\") from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- Assert.assertEquals(0.0, result1, 0.01);
- Assert.assertEquals(50.0, result2, 0.01);
- Assert.assertEquals(50.0, result3, 0.01);
- Assert.assertEquals(0.0, result4, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testKSigma2() {
- String sqlStr = "select ksigma(d2.s2,\"k\"=\"1.0\") from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- Assert.assertEquals(0.0, result1, 0.01);
- Assert.assertEquals(50.0, result2, 0.01);
- Assert.assertEquals(50.0, result3, 0.01);
- Assert.assertEquals(0.0, result4, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testKSigma3() {
- String sqlStr = "select ksigma(d2.s3,\"k\"=\"1.0\") from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- Assert.assertEquals(0.0, result1, 0.01);
- Assert.assertEquals(50.0, result2, 0.01);
- Assert.assertEquals(50.0, result3, 0.01);
- Assert.assertEquals(0.0, result4, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testKSigma4() {
- String sqlStr = "select ksigma(d2.s4,\"k\"=\"1.0\") from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- Assert.assertEquals(0.0, result1, 0.01);
- Assert.assertEquals(50.0, result2, 0.01);
- Assert.assertEquals(50.0, result3, 0.01);
- Assert.assertEquals(0.0, result4, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testMissDetect1() {
- String sqlStr = "select missdetect(d4.s1,'minlen'='10') from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- boolean result1 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result2 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result3 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result4 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result5 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result6 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result7 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result8 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result9 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result10 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result11 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result12 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result13 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result14 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result15 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result16 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result17 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result18 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result19 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result20 = resultSet.getBoolean(1);
- Assert.assertFalse(result1);
- Assert.assertFalse(result2);
- Assert.assertFalse(result3);
- Assert.assertFalse(result4);
- Assert.assertTrue(result5);
- Assert.assertTrue(result6);
- Assert.assertTrue(result7);
- Assert.assertTrue(result8);
- Assert.assertTrue(result9);
- Assert.assertTrue(result10);
- Assert.assertTrue(result11);
- Assert.assertTrue(result12);
- Assert.assertTrue(result13);
- Assert.assertTrue(result14);
- Assert.assertTrue(result15);
- Assert.assertFalse(result16);
- Assert.assertFalse(result17);
- Assert.assertFalse(result18);
- Assert.assertFalse(result19);
- Assert.assertFalse(result20);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testMissDetect2() {
- String sqlStr = "select missdetect(d4.s2,'minlen'='10') from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- boolean result1 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result2 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result3 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result4 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result5 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result6 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result7 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result8 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result9 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result10 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result11 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result12 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result13 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result14 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result15 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result16 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result17 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result18 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result19 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result20 = resultSet.getBoolean(1);
- Assert.assertFalse(result1);
- Assert.assertFalse(result2);
- Assert.assertFalse(result3);
- Assert.assertFalse(result4);
- Assert.assertTrue(result5);
- Assert.assertTrue(result6);
- Assert.assertTrue(result7);
- Assert.assertTrue(result8);
- Assert.assertTrue(result9);
- Assert.assertTrue(result10);
- Assert.assertTrue(result11);
- Assert.assertTrue(result12);
- Assert.assertTrue(result13);
- Assert.assertTrue(result14);
- Assert.assertTrue(result15);
- Assert.assertFalse(result16);
- Assert.assertFalse(result17);
- Assert.assertFalse(result18);
- Assert.assertFalse(result19);
- Assert.assertFalse(result20);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testMissDetect3() {
- String sqlStr = "select missdetect(d4.s3,'minlen'='10') from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- boolean result1 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result2 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result3 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result4 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result5 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result6 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result7 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result8 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result9 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result10 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result11 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result12 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result13 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result14 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result15 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result16 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result17 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result18 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result19 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result20 = resultSet.getBoolean(1);
- Assert.assertFalse(result1);
- Assert.assertFalse(result2);
- Assert.assertFalse(result3);
- Assert.assertFalse(result4);
- Assert.assertTrue(result5);
- Assert.assertTrue(result6);
- Assert.assertTrue(result7);
- Assert.assertTrue(result8);
- Assert.assertTrue(result9);
- Assert.assertTrue(result10);
- Assert.assertTrue(result11);
- Assert.assertTrue(result12);
- Assert.assertTrue(result13);
- Assert.assertTrue(result14);
- Assert.assertTrue(result15);
- Assert.assertFalse(result16);
- Assert.assertFalse(result17);
- Assert.assertFalse(result18);
- Assert.assertFalse(result19);
- Assert.assertFalse(result20);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testMissDetect4() {
- String sqlStr = "select missdetect(d4.s4,'minlen'='10') from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- boolean result1 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result2 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result3 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result4 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result5 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result6 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result7 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result8 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result9 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result10 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result11 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result12 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result13 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result14 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result15 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result16 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result17 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result18 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result19 = resultSet.getBoolean(1);
- resultSet.next();
- boolean result20 = resultSet.getBoolean(1);
- Assert.assertFalse(result1);
- Assert.assertFalse(result2);
- Assert.assertFalse(result3);
- Assert.assertFalse(result4);
- Assert.assertTrue(result5);
- Assert.assertTrue(result6);
- Assert.assertTrue(result7);
- Assert.assertTrue(result8);
- Assert.assertTrue(result9);
- Assert.assertTrue(result10);
- Assert.assertTrue(result11);
- Assert.assertTrue(result12);
- Assert.assertTrue(result13);
- Assert.assertTrue(result14);
- Assert.assertTrue(result15);
- Assert.assertFalse(result16);
- Assert.assertFalse(result17);
- Assert.assertFalse(result18);
- Assert.assertFalse(result19);
- Assert.assertFalse(result20);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testLOF1() {
- String sqlStr = "select lof(d3.s1,d3.s5) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- resultSet.next();
- double result5 = resultSet.getDouble(1);
- resultSet.next();
- double result6 = resultSet.getDouble(1);
- resultSet.next();
- double result7 = resultSet.getDouble(1);
- resultSet.next();
- double result8 = resultSet.getDouble(1);
- Assert.assertEquals(3.8274824267668244, result1, 0.01);
- Assert.assertEquals(3.0117631741126156, result2, 0.01);
- Assert.assertEquals(2.838155437762879, result3, 0.01);
- Assert.assertEquals(3.0117631741126156, result4, 0.01);
- Assert.assertEquals(2.73518261244453, result5, 0.01);
- Assert.assertEquals(2.371440975708148, result6, 0.01);
- Assert.assertEquals(2.73518261244453, result7, 0.01);
- Assert.assertEquals(1.7561416374270742, result8, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testLOF2() {
- String sqlStr = "select lof(d3.s2,d3.s6) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- resultSet.next();
- double result5 = resultSet.getDouble(1);
- resultSet.next();
- double result6 = resultSet.getDouble(1);
- resultSet.next();
- double result7 = resultSet.getDouble(1);
- resultSet.next();
- double result8 = resultSet.getDouble(1);
- Assert.assertEquals(3.8274824267668244, result1, 0.01);
- Assert.assertEquals(3.0117631741126156, result2, 0.01);
- Assert.assertEquals(2.838155437762879, result3, 0.01);
- Assert.assertEquals(3.0117631741126156, result4, 0.01);
- Assert.assertEquals(2.73518261244453, result5, 0.01);
- Assert.assertEquals(2.371440975708148, result6, 0.01);
- Assert.assertEquals(2.73518261244453, result7, 0.01);
- Assert.assertEquals(1.7561416374270742, result8, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testLOF3() {
- String sqlStr = "select lof(d3.s3,d3.s7) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- resultSet.next();
- double result5 = resultSet.getDouble(1);
- resultSet.next();
- double result6 = resultSet.getDouble(1);
- resultSet.next();
- double result7 = resultSet.getDouble(1);
- resultSet.next();
- double result8 = resultSet.getDouble(1);
- Assert.assertEquals(3.8274824267668244, result1, 0.01);
- Assert.assertEquals(3.0117631741126156, result2, 0.01);
- Assert.assertEquals(2.838155437762879, result3, 0.01);
- Assert.assertEquals(3.0117631741126156, result4, 0.01);
- Assert.assertEquals(2.73518261244453, result5, 0.01);
- Assert.assertEquals(2.371440975708148, result6, 0.01);
- Assert.assertEquals(2.73518261244453, result7, 0.01);
- Assert.assertEquals(1.7561416374270742, result8, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testLOF4() {
- String sqlStr = "select lof(d3.s4,d3.s8) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- resultSet.next();
- double result5 = resultSet.getDouble(1);
- resultSet.next();
- double result6 = resultSet.getDouble(1);
- resultSet.next();
- double result7 = resultSet.getDouble(1);
- resultSet.next();
- double result8 = resultSet.getDouble(1);
- Assert.assertEquals(3.8274824267668244, result1, 0.01);
- Assert.assertEquals(3.0117631741126156, result2, 0.01);
- Assert.assertEquals(2.838155437762879, result3, 0.01);
- Assert.assertEquals(3.0117631741126156, result4, 0.01);
- Assert.assertEquals(2.73518261244453, result5, 0.01);
- Assert.assertEquals(2.371440975708148, result6, 0.01);
- Assert.assertEquals(2.73518261244453, result7, 0.01);
- Assert.assertEquals(1.7561416374270742, result8, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testRange1() {
- String sqlStr =
- "select range(d1.s1,\"lower_bound\"=\"-5.0\",\"upper_bound\"=\"5.0\") from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(10.0, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testRange2() {
- String sqlStr =
- "select range(d1.s2,\"lower_bound\"=\"-5.0\",\"upper_bound\"=\"5.0\") from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(10.0, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testRange3() {
- String sqlStr =
- "select range(d1.s3,\"lower_bound\"=\"-5.0\",\"upper_bound\"=\"5.0\") from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(10.0, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testRange4() {
- String sqlStr =
- "select range(d1.s4,\"lower_bound\"=\"-5.0\",\"upper_bound\"=\"5.0\") from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(10.0, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testTwoSidedFileter1() {
- String sqlStr = "select TwoSidedFilter(d6.s1, 'len'='3', 'threshold'='0.3') from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- resultSet.next();
- double result5 = resultSet.getDouble(1);
- resultSet.next();
- double result6 = resultSet.getDouble(1);
- resultSet.next();
- double result7 = resultSet.getDouble(1);
- resultSet.next();
- double result8 = resultSet.getDouble(1);
- resultSet.next();
- double result9 = resultSet.getDouble(1);
- resultSet.next();
- double result10 = resultSet.getDouble(1);
- resultSet.next();
- double result11 = resultSet.getDouble(1);
- resultSet.next();
- double result12 = resultSet.getDouble(1);
- resultSet.next();
- double result13 = resultSet.getDouble(1);
- resultSet.next();
- double result14 = resultSet.getDouble(1);
- resultSet.next();
- double result15 = resultSet.getDouble(1);
- resultSet.next();
- double result16 = resultSet.getDouble(1);
- resultSet.next();
- double result17 = resultSet.getDouble(1);
- resultSet.next();
- double result18 = resultSet.getDouble(1);
- resultSet.next();
- double result19 = resultSet.getDouble(1);
- resultSet.next();
- double result20 = resultSet.getDouble(1);
- resultSet.next();
- double result21 = resultSet.getDouble(1);
- resultSet.next();
- double result22 = resultSet.getDouble(1);
- resultSet.next();
- double result23 = resultSet.getDouble(1);
- Assert.assertEquals(2002.0, result1, 0.01);
- Assert.assertEquals(1946.0, result2, 0.01);
- Assert.assertEquals(1958.0, result3, 0.01);
- Assert.assertEquals(2012.0, result4, 0.01);
- Assert.assertEquals(2051.0, result5, 0.01);
- Assert.assertEquals(1898.0, result6, 0.01);
- Assert.assertEquals(2014.0, result7, 0.01);
- Assert.assertEquals(2052.0, result8, 0.01);
- Assert.assertEquals(1935.0, result9, 0.01);
- Assert.assertEquals(1901.0, result10, 0.01);
- Assert.assertEquals(1972.0, result11, 0.01);
- Assert.assertEquals(1969.0, result12, 0.01);
- Assert.assertEquals(1984.0, result13, 0.01);
- Assert.assertEquals(2018.0, result14, 0.01);
- Assert.assertEquals(1023.0, result15, 0.01);
- Assert.assertEquals(1056.0, result16, 0.01);
- Assert.assertEquals(978.0, result17, 0.01);
- Assert.assertEquals(1050.0, result18, 0.01);
- Assert.assertEquals(1123.0, result19, 0.01);
- Assert.assertEquals(1150.0, result20, 0.01);
- Assert.assertEquals(1134.0, result21, 0.01);
- Assert.assertEquals(950.0, result22, 0.01);
- Assert.assertEquals(1059.0, result23, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testTwoSidedFileter2() {
- String sqlStr = "select TwoSidedFilter(d6.s2, 'len'='3', 'threshold'='0.3') from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- resultSet.next();
- double result5 = resultSet.getDouble(1);
- resultSet.next();
- double result6 = resultSet.getDouble(1);
- resultSet.next();
- double result7 = resultSet.getDouble(1);
- resultSet.next();
- double result8 = resultSet.getDouble(1);
- resultSet.next();
- double result9 = resultSet.getDouble(1);
- resultSet.next();
- double result10 = resultSet.getDouble(1);
- resultSet.next();
- double result11 = resultSet.getDouble(1);
- resultSet.next();
- double result12 = resultSet.getDouble(1);
- resultSet.next();
- double result13 = resultSet.getDouble(1);
- resultSet.next();
- double result14 = resultSet.getDouble(1);
- resultSet.next();
- double result15 = resultSet.getDouble(1);
- resultSet.next();
- double result16 = resultSet.getDouble(1);
- resultSet.next();
- double result17 = resultSet.getDouble(1);
- resultSet.next();
- double result18 = resultSet.getDouble(1);
- resultSet.next();
- double result19 = resultSet.getDouble(1);
- resultSet.next();
- double result20 = resultSet.getDouble(1);
- resultSet.next();
- double result21 = resultSet.getDouble(1);
- resultSet.next();
- double result22 = resultSet.getDouble(1);
- resultSet.next();
- double result23 = resultSet.getDouble(1);
- Assert.assertEquals(2002.0, result1, 0.01);
- Assert.assertEquals(1946.0, result2, 0.01);
- Assert.assertEquals(1958.0, result3, 0.01);
- Assert.assertEquals(2012.0, result4, 0.01);
- Assert.assertEquals(2051.0, result5, 0.01);
- Assert.assertEquals(1898.0, result6, 0.01);
- Assert.assertEquals(2014.0, result7, 0.01);
- Assert.assertEquals(2052.0, result8, 0.01);
- Assert.assertEquals(1935.0, result9, 0.01);
- Assert.assertEquals(1901.0, result10, 0.01);
- Assert.assertEquals(1972.0, result11, 0.01);
- Assert.assertEquals(1969.0, result12, 0.01);
- Assert.assertEquals(1984.0, result13, 0.01);
- Assert.assertEquals(2018.0, result14, 0.01);
- Assert.assertEquals(1023.0, result15, 0.01);
- Assert.assertEquals(1056.0, result16, 0.01);
- Assert.assertEquals(978.0, result17, 0.01);
- Assert.assertEquals(1050.0, result18, 0.01);
- Assert.assertEquals(1123.0, result19, 0.01);
- Assert.assertEquals(1150.0, result20, 0.01);
- Assert.assertEquals(1134.0, result21, 0.01);
- Assert.assertEquals(950.0, result22, 0.01);
- Assert.assertEquals(1059.0, result23, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testTwoSidedFileter3() {
- String sqlStr = "select TwoSidedFilter(d6.s3, 'len'='3', 'threshold'='0.3') from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- resultSet.next();
- double result5 = resultSet.getDouble(1);
- resultSet.next();
- double result6 = resultSet.getDouble(1);
- resultSet.next();
- double result7 = resultSet.getDouble(1);
- resultSet.next();
- double result8 = resultSet.getDouble(1);
- resultSet.next();
- double result9 = resultSet.getDouble(1);
- resultSet.next();
- double result10 = resultSet.getDouble(1);
- resultSet.next();
- double result11 = resultSet.getDouble(1);
- resultSet.next();
- double result12 = resultSet.getDouble(1);
- resultSet.next();
- double result13 = resultSet.getDouble(1);
- resultSet.next();
- double result14 = resultSet.getDouble(1);
- resultSet.next();
- double result15 = resultSet.getDouble(1);
- resultSet.next();
- double result16 = resultSet.getDouble(1);
- resultSet.next();
- double result17 = resultSet.getDouble(1);
- resultSet.next();
- double result18 = resultSet.getDouble(1);
- resultSet.next();
- double result19 = resultSet.getDouble(1);
- resultSet.next();
- double result20 = resultSet.getDouble(1);
- resultSet.next();
- double result21 = resultSet.getDouble(1);
- resultSet.next();
- double result22 = resultSet.getDouble(1);
- resultSet.next();
- double result23 = resultSet.getDouble(1);
- Assert.assertEquals(2002.0, result1, 0.01);
- Assert.assertEquals(1946.0, result2, 0.01);
- Assert.assertEquals(1958.0, result3, 0.01);
- Assert.assertEquals(2012.0, result4, 0.01);
- Assert.assertEquals(2051.0, result5, 0.01);
- Assert.assertEquals(1898.0, result6, 0.01);
- Assert.assertEquals(2014.0, result7, 0.01);
- Assert.assertEquals(2052.0, result8, 0.01);
- Assert.assertEquals(1935.0, result9, 0.01);
- Assert.assertEquals(1901.0, result10, 0.01);
- Assert.assertEquals(1972.0, result11, 0.01);
- Assert.assertEquals(1969.0, result12, 0.01);
- Assert.assertEquals(1984.0, result13, 0.01);
- Assert.assertEquals(2018.0, result14, 0.01);
- Assert.assertEquals(1023.0, result15, 0.01);
- Assert.assertEquals(1056.0, result16, 0.01);
- Assert.assertEquals(978.0, result17, 0.01);
- Assert.assertEquals(1050.0, result18, 0.01);
- Assert.assertEquals(1123.0, result19, 0.01);
- Assert.assertEquals(1150.0, result20, 0.01);
- Assert.assertEquals(1134.0, result21, 0.01);
- Assert.assertEquals(950.0, result22, 0.01);
- Assert.assertEquals(1059.0, result23, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testTwoSidedFileter4() {
- String sqlStr = "select TwoSidedFilter(d6.s4, 'len'='3', 'threshold'='0.3') from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- resultSet.next();
- double result5 = resultSet.getDouble(1);
- resultSet.next();
- double result6 = resultSet.getDouble(1);
- resultSet.next();
- double result7 = resultSet.getDouble(1);
- resultSet.next();
- double result8 = resultSet.getDouble(1);
- resultSet.next();
- double result9 = resultSet.getDouble(1);
- resultSet.next();
- double result10 = resultSet.getDouble(1);
- resultSet.next();
- double result11 = resultSet.getDouble(1);
- resultSet.next();
- double result12 = resultSet.getDouble(1);
- resultSet.next();
- double result13 = resultSet.getDouble(1);
- resultSet.next();
- double result14 = resultSet.getDouble(1);
- resultSet.next();
- double result15 = resultSet.getDouble(1);
- resultSet.next();
- double result16 = resultSet.getDouble(1);
- resultSet.next();
- double result17 = resultSet.getDouble(1);
- resultSet.next();
- double result18 = resultSet.getDouble(1);
- resultSet.next();
- double result19 = resultSet.getDouble(1);
- resultSet.next();
- double result20 = resultSet.getDouble(1);
- resultSet.next();
- double result21 = resultSet.getDouble(1);
- resultSet.next();
- double result22 = resultSet.getDouble(1);
- resultSet.next();
- double result23 = resultSet.getDouble(1);
- Assert.assertEquals(2002.0, result1, 0.01);
- Assert.assertEquals(1946.0, result2, 0.01);
- Assert.assertEquals(1958.0, result3, 0.01);
- Assert.assertEquals(2012.0, result4, 0.01);
- Assert.assertEquals(2051.0, result5, 0.01);
- Assert.assertEquals(1898.0, result6, 0.01);
- Assert.assertEquals(2014.0, result7, 0.01);
- Assert.assertEquals(2052.0, result8, 0.01);
- Assert.assertEquals(1935.0, result9, 0.01);
- Assert.assertEquals(1901.0, result10, 0.01);
- Assert.assertEquals(1972.0, result11, 0.01);
- Assert.assertEquals(1969.0, result12, 0.01);
- Assert.assertEquals(1984.0, result13, 0.01);
- Assert.assertEquals(2018.0, result14, 0.01);
- Assert.assertEquals(1023.0, result15, 0.01);
- Assert.assertEquals(1056.0, result16, 0.01);
- Assert.assertEquals(978.0, result17, 0.01);
- Assert.assertEquals(1050.0, result18, 0.01);
- Assert.assertEquals(1123.0, result19, 0.01);
- Assert.assertEquals(1150.0, result20, 0.01);
- Assert.assertEquals(1134.0, result21, 0.01);
- Assert.assertEquals(950.0, result22, 0.01);
- Assert.assertEquals(1059.0, result23, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-}
diff --git a/library-udf/src/test/java/org/apache/iotdb/library/dmatch/DMatchTests.java b/library-udf/src/test/java/org/apache/iotdb/library/dmatch/DMatchTests.java
deleted file mode 100644
index 2f2c9c3d77..0000000000
--- a/library-udf/src/test/java/org/apache/iotdb/library/dmatch/DMatchTests.java
+++ /dev/null
@@ -1,854 +0,0 @@
-/*
- * 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.library.dmatch;
-
-import org.apache.iotdb.commons.exception.MetadataException;
-import org.apache.iotdb.commons.path.PartialPath;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
-import org.apache.iotdb.db.metadata.LocalSchemaProcessor;
-import org.apache.iotdb.integration.env.ConfigFactory;
-import org.apache.iotdb.integration.env.EnvFactory;
-import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
-
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.sql.Connection;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
-
-import static org.junit.Assert.fail;
-
-public class DMatchTests {
- private static final float oldUdfCollectorMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfCollectorMemoryBudgetInMB();
- private static final float oldUdfTransformerMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfTransformerMemoryBudgetInMB();
- private static final float oldUdfReaderMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfReaderMemoryBudgetInMB();
-
- @BeforeClass
- public static void setUp() throws Exception {
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(5)
- .setUdfTransformerMemoryBudgetInMB(5)
- .setUdfReaderMemoryBudgetInMB(5);
- EnvFactory.getEnv().initBeforeClass();
- createTimeSeries();
- generateData();
- registerUDF();
- }
-
- private static void createTimeSeries() throws MetadataException {
- LocalSchemaProcessor.getInstance().setStorageGroup(new PartialPath("root.vehicle"));
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s1"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s2"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s3"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s4"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s5"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s6"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s7"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s8"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s1"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s2"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s3"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s4"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s5"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s6"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s7"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s8"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d3.s1"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d3.s2"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d3.s3"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d3.s4"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d4.s1"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d4.s2"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d4.s3"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d4.s4"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d4.s5"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d4.s6"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d4.s7"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d4.s8"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- }
-
- private static void generateData() {
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 100, 100, 100, 100, 100, 101, 101, 101, 101));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 100, 100, 100, 100, 100, 101, 101, 101, 101));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 200, 102, 102, 102, 102, 101, 101, 101, 101));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 300, 104, 104, 104, 104, 102, 102, 102, 102));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 400, 126, 126, 126, 126, 102, 102, 102, 102));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 500, 108, 108, 108, 108, 103, 103, 103, 103));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 600, 112, 112, 112, 112, 104, 104, 104, 104));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 700, 114, 114, 114, 114, 104, 104, 104, 104));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 800, 116, 116, 116, 116, 105, 105, 105, 105));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 900, 118, 118, 118, 118, 105, 105, 105, 105));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 1000, 100, 100, 100, 100, 106, 106, 106, 106));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 1100, 124, 124, 124, 124, 108, 108, 108, 108));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 1200, 126, 126, 126, 126, 108, 108, 108, 108));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 1300, 116, 116, 116, 116, 105, 105, 105, 105));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 100, 1, 1, 1, 1, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 200, 1, 1, 1, 1, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 300, 1, 1, 1, 1, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 400, 1, 1, 1, 1, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 500, 1, 1, 1, 1, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 600, 1, 1, 1, 1, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 700, 1, 1, 1, 1, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 800, 1, 1, 1, 1, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 100, 1, 1, 1, 1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 200, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 300, 3, 3, 3, 3));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 400, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 500, 1, 1, 1, 1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 600, 1, 1, 1, 1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 700, 1, 1, 1, 1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 800, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 900, 3, 3, 3, 3));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1000, 2, 2, 2, 2));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1,s2,s3,s4) values(%d,%d,%d,%d,%d)",
- 1100, 1, 1, 1, 1));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 100, 0, 0, 0, 0, 6, 6, 6, 6));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 200, 2, 2, 2, 2, 7, 7, 7, 7));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 300, 3, 3, 3, 3, 0, 0, 0, 0));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 400, 4, 4, 4, 4, 9, 9, 9, 9));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d4(timestamp,s1,s2,s3,s4,s5,s6,s7,s8) values(%d,%d,%d,%d,%d,%d,%d,%d,%d))",
- 500, 5, 5, 5, 5, 10, 10, 10, 10));
- statement.executeBatch();
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- private static void registerUDF() {
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- statement.execute("create function cov as 'org.apache.iotdb.library.dmatch.UDAFCov'");
- statement.execute("create function dtw as 'org.apache.iotdb.library.dmatch.UDAFDtw'");
- statement.execute("create function pearson as 'org.apache.iotdb.library.dmatch.UDAFPearson'");
- statement.execute("create function ptnsym as 'org.apache.iotdb.library.dmatch.UDTFPtnSym'");
- statement.execute("create function xcorr as 'org.apache.iotdb.library.dmatch.UDTFXcorr'");
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @AfterClass
- public static void tearDown() throws Exception {
- EnvFactory.getEnv().cleanAfterClass();
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(oldUdfCollectorMemoryBudgetInMB)
- .setUdfTransformerMemoryBudgetInMB(oldUdfTransformerMemoryBudgetInMB)
- .setUdfReaderMemoryBudgetInMB(oldUdfReaderMemoryBudgetInMB);
- }
-
- @Test
- public void testCov1() {
- String sqlStr = "select cov(d1.s1,d1.s5) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(12.291666666666666, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testCov2() {
- String sqlStr = "select cov(d1.s2,d1.s6) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(12.291666666666666, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testCov3() {
- String sqlStr = "select cov(d1.s3,d1.s7) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(12.291666666666666, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testCov4() {
- String sqlStr = "select cov(d1.s4,d1.s8) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(12.291666666666666, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testDtw1() {
- String sqlStr = "select dtw(d2.s1,d2.s5) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(8.0, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testDtw2() {
- String sqlStr = "select dtw(d2.s2,d2.s6) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(8.0, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testDtw3() {
- String sqlStr = "select dtw(d2.s3,d2.s7) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(8.0, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testDtw4() {
- String sqlStr = "select dtw(d2.s4,d2.s8) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(8.0, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testPearson1() {
- String sqlStr = "select pearson(d1.s1,d1.s5) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(0.5630881927754872, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testPearson2() {
- String sqlStr = "select pearson(d1.s2,d1.s6) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(0.5630881927754872, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testPearson3() {
- String sqlStr = "select pearson(d1.s3,d1.s7) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(0.5630881927754872, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testPearson4() {
- String sqlStr = "select pearson(d1.s4,d1.s8) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- Assert.assertEquals(0.5630881927754872, result1, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testPthSym1() {
- String sqlStr = "select ptnsym(d1.s1, 'window'='3', 'threshold'='0') from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- Assert.assertEquals(0.0, result1, 0.01);
- Assert.assertEquals(0.0, result2, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testPtnSym2() {
- String sqlStr = "select ptnsym(d1.s2, 'window'='3', 'threshold'='0') from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- Assert.assertEquals(0.0, result1, 0.01);
- Assert.assertEquals(0.0, result2, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testPtnSym3() {
- String sqlStr = "select ptnsym(d2.s1, 'window'='3', 'threshold'='0') from";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- Assert.assertEquals(0.0, result1, 0.01);
- Assert.assertEquals(0.0, result2, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testPtnSym4() {
- String sqlStr = "select ptnsym(d2.s2, 'window'='3', 'threshold'='0') from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- Assert.assertEquals(0.0, result1, 0.01);
- Assert.assertEquals(0.0, result2, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testXCorr1() {
- String sqlStr = "select xcorr(d4.s1,d4.s5) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- resultSet.next();
- double result5 = resultSet.getDouble(1);
- resultSet.next();
- double result6 = resultSet.getDouble(1);
- resultSet.next();
- double result7 = resultSet.getDouble(1);
- resultSet.next();
- double result8 = resultSet.getDouble(1);
- resultSet.next();
- double result9 = resultSet.getDouble(1);
- Assert.assertEquals(0.0, result1, 0.01);
- Assert.assertEquals(4.0, result2, 0.01);
- Assert.assertEquals(9.6, result3, 0.01);
- Assert.assertEquals(13.4, result4, 0.01);
- Assert.assertEquals(20.0, result5, 0.01);
- Assert.assertEquals(15.6, result6, 0.01);
- Assert.assertEquals(9.2, result7, 0.01);
- Assert.assertEquals(11.8, result8, 0.01);
- Assert.assertEquals(6.0, result9, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testXCorr2() {
- String sqlStr = "select xcorr(d4.s2, d4.s6) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- resultSet.next();
- double result5 = resultSet.getDouble(1);
- resultSet.next();
- double result6 = resultSet.getDouble(1);
- resultSet.next();
- double result7 = resultSet.getDouble(1);
- resultSet.next();
- double result8 = resultSet.getDouble(1);
- resultSet.next();
- double result9 = resultSet.getDouble(1);
- Assert.assertEquals(0.0, result1, 0.01);
- Assert.assertEquals(4.0, result2, 0.01);
- Assert.assertEquals(9.6, result3, 0.01);
- Assert.assertEquals(13.4, result4, 0.01);
- Assert.assertEquals(20.0, result5, 0.01);
- Assert.assertEquals(15.6, result6, 0.01);
- Assert.assertEquals(9.2, result7, 0.01);
- Assert.assertEquals(11.8, result8, 0.01);
- Assert.assertEquals(6.0, result9, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testXCorr3() {
- String sqlStr = "select xcorr(d4.s3, d4.s7) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- resultSet.next();
- double result5 = resultSet.getDouble(1);
- resultSet.next();
- double result6 = resultSet.getDouble(1);
- resultSet.next();
- double result7 = resultSet.getDouble(1);
- resultSet.next();
- double result8 = resultSet.getDouble(1);
- resultSet.next();
- double result9 = resultSet.getDouble(1);
- Assert.assertEquals(0.0, result1, 0.01);
- Assert.assertEquals(4.0, result2, 0.01);
- Assert.assertEquals(9.6, result3, 0.01);
- Assert.assertEquals(13.4, result4, 0.01);
- Assert.assertEquals(20.0, result5, 0.01);
- Assert.assertEquals(15.6, result6, 0.01);
- Assert.assertEquals(9.2, result7, 0.01);
- Assert.assertEquals(11.8, result8, 0.01);
- Assert.assertEquals(6.0, result9, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testXCorr4() {
- String sqlStr = "select xcorr(d4.s4,d4.s8) from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- double result1 = resultSet.getDouble(1);
- resultSet.next();
- double result2 = resultSet.getDouble(1);
- resultSet.next();
- double result3 = resultSet.getDouble(1);
- resultSet.next();
- double result4 = resultSet.getDouble(1);
- resultSet.next();
- double result5 = resultSet.getDouble(1);
- resultSet.next();
- double result6 = resultSet.getDouble(1);
- resultSet.next();
- double result7 = resultSet.getDouble(1);
- resultSet.next();
- double result8 = resultSet.getDouble(1);
- resultSet.next();
- double result9 = resultSet.getDouble(1);
- Assert.assertEquals(0.0, result1, 0.01);
- Assert.assertEquals(4.0, result2, 0.01);
- Assert.assertEquals(9.6, result3, 0.01);
- Assert.assertEquals(13.4, result4, 0.01);
- Assert.assertEquals(20.0, result5, 0.01);
- Assert.assertEquals(15.6, result6, 0.01);
- Assert.assertEquals(9.2, result7, 0.01);
- Assert.assertEquals(11.8, result8, 0.01);
- Assert.assertEquals(6.0, result9, 0.01);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-}
diff --git a/library-udf/src/test/java/org/apache/iotdb/library/dprofile/DProfileTests.java b/library-udf/src/test/java/org/apache/iotdb/library/dprofile/DProfileTests.java
deleted file mode 100644
index e3d8db1904..0000000000
--- a/library-udf/src/test/java/org/apache/iotdb/library/dprofile/DProfileTests.java
+++ /dev/null
@@ -1,646 +0,0 @@
-/*
- * 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.library.dprofile;
-
-import org.apache.iotdb.commons.exception.MetadataException;
-import org.apache.iotdb.commons.path.PartialPath;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
-import org.apache.iotdb.db.metadata.LocalSchemaProcessor;
-import org.apache.iotdb.integration.env.ConfigFactory;
-import org.apache.iotdb.integration.env.EnvFactory;
-import org.apache.iotdb.jdbc.Config;
-import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
-
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-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 static org.junit.Assert.fail;
-
-public class DProfileTests {
- protected static final int ITERATION_TIMES = 10_000;
-
- private static final float oldUdfCollectorMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfCollectorMemoryBudgetInMB();
- private static final float oldUdfTransformerMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfTransformerMemoryBudgetInMB();
- private static final float oldUdfReaderMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfReaderMemoryBudgetInMB();
-
- @BeforeClass
- public static void setUp() throws Exception {
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(5)
- .setUdfTransformerMemoryBudgetInMB(5)
- .setUdfReaderMemoryBudgetInMB(5);
- EnvFactory.getEnv().initBeforeClass();
- createTimeSeries();
- generateData();
- registerUDF();
- }
-
- private static void createTimeSeries() throws MetadataException {
- LocalSchemaProcessor.getInstance().setStorageGroup(new PartialPath("root.vehicle"));
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s1"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s2"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s1"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s2"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- }
-
- private static void generateData() {
- double x = -100d, y = 100d; // borders of random value
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- for (int i = 1; i <= ITERATION_TIMES; ++i) {
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)",
- i * 1000,
- (int) Math.floor(x + Math.random() * y % (y - x + 1)),
- (int) Math.floor(x + Math.random() * y % (y - x + 1))));
- statement.execute(
- (String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%f,%f)",
- i * 1000,
- x + Math.random() * y % (y - x + 1),
- x + Math.random() * y % (y - x + 1))));
- }
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- private static void registerUDF() {
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- statement.execute(
- "create function distinct as 'org.apache.iotdb.library.dprofile.UDTFDistinct'");
- statement.execute(
- "create function histogram as 'org.apache.iotdb.library.dprofile.UDTFHistogram'");
- statement.execute(
- "create function integral as 'org.apache.iotdb.library.dprofile.UDAFIntegral'");
- statement.execute(
- "create function integralavg as 'org.apache.iotdb.library.dprofile.UDAFIntegralAvg'");
- statement.execute("create function mad as 'org.apache.iotdb.library.dprofile.UDAFMad'");
- statement.execute("create function median as 'org.apache.iotdb.library.dprofile.UDAFMedian'");
- statement.execute("create function mode as 'org.apache.iotdb.library.dprofile.UDAFMode'");
- statement.execute(
- "create function percentile as 'org.apache.iotdb.library.dprofile.UDAFPercentile'");
- statement.execute("create function period as 'org.apache.iotdb.library.dprofile.UDAFPeriod'");
- statement.execute("create function qlb as 'org.apache.iotdb.library.dprofile.UDTFQLB'");
- statement.execute(
- "create function resample as 'org.apache.iotdb.library.dprofile.UDTFResample'");
- statement.execute("create function sample as 'org.apache.iotdb.library.dprofile.UDTFSample'");
- statement.execute(
- "create function segment as 'org.apache.iotdb.library.dprofile.UDTFSegment'");
- statement.execute("create function skew as 'org.apache.iotdb.library.dprofile.UDAFSkew'");
- statement.execute("create function spread as 'org.apache.iotdb.library.dprofile.UDAFSpread'");
- statement.execute("create function stddev as 'org.apache.iotdb.library.dprofile.UDAFStddev'");
- statement.execute("create function minmax as 'org.apache.iotdb.library.dprofile.UDTFMinMax'");
- statement.execute("create function zscore as 'org.apache.iotdb.library.dprofile.UDTFZScore'");
- statement.execute("create function spline as 'org.apache.iotdb.library.dprofile.UDTFSpline'");
- statement.execute("create function mvavg as 'org.apache.iotdb.library.dprofile.UDTFMvAvg'");
- statement.execute("create function acf as 'org.apache.iotdb.library.dprofile.UDTFACF'");
- statement.execute("create function pacf as 'org.apache.iotdb.library.dprofile.UDTFPACF'");
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @AfterClass
- public static void tearDown() throws Exception {
- EnvFactory.getEnv().cleanAfterClass();
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(oldUdfCollectorMemoryBudgetInMB)
- .setUdfTransformerMemoryBudgetInMB(oldUdfTransformerMemoryBudgetInMB)
- .setUdfReaderMemoryBudgetInMB(oldUdfReaderMemoryBudgetInMB);
- }
-
- @Test
- public void testIntegral1() {
- String sqlStr = "select integral(d1.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testIntegral2() {
- String sqlStr = "select completeness(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testIntegralAvg1() {
- String sqlStr = "select integralavg(d1.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testIntegralAvg2() {
- String sqlStr = "select integralavg(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testMad1() {
- String sqlStr = "select mad(d1.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testMad2() {
- String sqlStr = "select timeliness(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testMedian1() {
- String sqlStr = "select median(d1.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testMedian2() {
- String sqlStr = "select median(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testMode1() {
- String sqlStr = "select consistency(d1.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testPercentile1() {
- String sqlStr = "select percentile(d1.s2,'rank'='0.7') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testPercentile2() {
- String sqlStr = "select percentile(d2.s2,'rank'='0.3') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testPeriod1() {
- String sqlStr = "select period(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testSkew1() {
- String sqlStr = "select skew(d1.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testSkew2() {
- String sqlStr = "select skew(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testSpread1() {
- String sqlStr = "select spread(d1.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testSpread2() {
- String sqlStr = "select spread(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testSddev1() {
- String sqlStr = "select stddev(d1.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testStddev2() {
- String sqlStr = "select stddev(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testACF1() {
- String sqlStr = "select acf(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testDistinct1() {
- String sqlStr = "select distinct(d1.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testHistogram1() {
- String sqlStr =
- String.format(
- "select histogram(d1.s1,'min'='%f','max'='%f','count'='20') from root.vehicle",
- -100d, 100d);
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testMinMax1() {
- String sqlStr =
- String.format("select minmax(d2.s2,'min'='%f','max'='%f') from root.vehicle", -100d, 100d);
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testMvAvg1() {
- String sqlStr = "select mvavg(d1.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testMvAvg2() {
- String sqlStr = "select mvavg(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testPACF1() {
- String sqlStr = "select pacf(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testQLB1() {
- String sqlStr = "select qlb(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testResample1() {
- String sqlStr = "select resample(d2.s1, 'every'='5s') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testResample2() {
- String sqlStr = "select resample(d2.s2, 'every'='10s', 'aggr'='median') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testSample1() {
- String sqlStr = "select resample(d2.s1, 'method'='reservoir','k'='5') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testsample2() {
- String sqlStr = "select resample(d1.s2, 'method'='isometric','k'='5') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testsample3() {
- String sqlStr = "select sample(d1.s2, 'method'='triangle','k'='5') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testSegment1() {
- String sqlStr = "select segment(d2.s2,'error'='10') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testSpline1() {
- String sqlStr = "select spline(d2.s1, 'points'='100') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testZScore1() {
- String sqlStr = "select zscore(d1.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testZScore2() {
- String sqlStr = "select zscore(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-}
diff --git a/library-udf/src/test/java/org/apache/iotdb/library/dquality/DQualityTests.java b/library-udf/src/test/java/org/apache/iotdb/library/dquality/DQualityTests.java
deleted file mode 100644
index 72dcc7f0b5..0000000000
--- a/library-udf/src/test/java/org/apache/iotdb/library/dquality/DQualityTests.java
+++ /dev/null
@@ -1,389 +0,0 @@
-/*
- * 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.library.dquality;
-
-import org.apache.iotdb.commons.exception.MetadataException;
-import org.apache.iotdb.commons.path.PartialPath;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
-import org.apache.iotdb.db.metadata.LocalSchemaProcessor;
-import org.apache.iotdb.integration.env.ConfigFactory;
-import org.apache.iotdb.integration.env.EnvFactory;
-import org.apache.iotdb.jdbc.Config;
-import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
-
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-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 static org.junit.Assert.fail;
-
-public class DQualityTests {
- protected static final int ITERATION_TIMES = 10_000;
- private static final float oldUdfCollectorMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfCollectorMemoryBudgetInMB();
- private static final float oldUdfTransformerMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfTransformerMemoryBudgetInMB();
- private static final float oldUdfReaderMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfReaderMemoryBudgetInMB();
-
- @BeforeClass
- public static void setUp() throws Exception {
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(5)
- .setUdfTransformerMemoryBudgetInMB(5)
- .setUdfReaderMemoryBudgetInMB(5);
- EnvFactory.getEnv().initBeforeClass();
- createTimeSeries();
- generateData();
- registerUDF();
- }
-
- private static void createTimeSeries() throws MetadataException {
- LocalSchemaProcessor.getInstance().setStorageGroup(new PartialPath("root.vehicle"));
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s1"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s2"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s1"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s2"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- }
-
- private static void generateData() {
- double x = -100d, y = 100d; // borders of random value
- long a = 0, b = 1000000000;
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- for (int i = 1; i <= ITERATION_TIMES; ++i) {
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)",
- (int) Math.floor(a + Math.random() * b % (b - a + 1)),
- (int) Math.floor(x + Math.random() * y % (y - x + 1)),
- (int) Math.floor(x + Math.random() * y % (y - x + 1))));
- statement.execute(
- (String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%f,%f)",
- (int) Math.floor(a + Math.random() * b % (b - a + 1)),
- x + Math.random() * y % (y - x + 1),
- x + Math.random() * y % (y - x + 1))));
- }
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- private static void registerUDF() {
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- statement.execute(
- "create function completeness as 'org.apache.iotdb.library.dquality.UDTFCompleteness'");
- statement.execute(
- "create function timeliness as 'org.apache.iotdb.library.dquality.UDTFTimeliness'");
- statement.execute(
- "create function consistency as 'org.apache.iotdb.library.dquality.UDTFConsistency'");
- statement.execute(
- "create function validity as 'org.apache.iotdb.library.dquality.UDTFValidity'");
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @AfterClass
- public static void tearDown() throws Exception {
- EnvFactory.getEnv().cleanAfterClass();
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(oldUdfCollectorMemoryBudgetInMB)
- .setUdfTransformerMemoryBudgetInMB(oldUdfTransformerMemoryBudgetInMB)
- .setUdfReaderMemoryBudgetInMB(oldUdfReaderMemoryBudgetInMB);
- }
-
- @Test
- public void testCompleteness1() {
- String sqlStr = "select completeness(d1.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testCompleteness2() {
- String sqlStr = "select completeness(d1.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testCompleteness3() {
- String sqlStr = "select completeness(d2.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testCompleteness4() {
- String sqlStr = "select completeness(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testTimeliness1() {
- String sqlStr = "select timeliness(d1.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testTimeliness2() {
- String sqlStr = "select timeliness(d1.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testTimeliness3() {
- String sqlStr = "select timeliness(d2.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testTimeliness4() {
- String sqlStr = "select timeliness(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testConsistency1() {
- String sqlStr = "select consistency(d1.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testConsistency2() {
- String sqlStr = "select consistency(d1.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testConsistency3() {
- String sqlStr = "select consistency(d2.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testConsistency4() {
- String sqlStr = "select consistency(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testValidity1() {
- String sqlStr = "select validity(d1.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testValidity2() {
- String sqlStr = "select validity(d1.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testValidity3() {
- String sqlStr = "select validity(d2.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testValidity4() {
- String sqlStr = "select validity(d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(result >= -0.0D && result <= 1.0D);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-}
diff --git a/library-udf/src/test/java/org/apache/iotdb/library/drepair/DRepairTests.java b/library-udf/src/test/java/org/apache/iotdb/library/drepair/DRepairTests.java
deleted file mode 100644
index d0c09ab92d..0000000000
--- a/library-udf/src/test/java/org/apache/iotdb/library/drepair/DRepairTests.java
+++ /dev/null
@@ -1,320 +0,0 @@
-/*
- * 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.library.drepair;
-
-import org.apache.iotdb.commons.exception.MetadataException;
-import org.apache.iotdb.commons.path.PartialPath;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
-import org.apache.iotdb.db.metadata.LocalSchemaProcessor;
-import org.apache.iotdb.integration.env.ConfigFactory;
-import org.apache.iotdb.integration.env.EnvFactory;
-import org.apache.iotdb.jdbc.Config;
-import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
-
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-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 static org.junit.Assert.fail;
-
-public class DRepairTests {
- protected static final int ITERATION_TIMES = 100_000;
- protected static final int DELTA_T = 100;
-
- private static final float oldUdfCollectorMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfCollectorMemoryBudgetInMB();
- private static final float oldUdfTransformerMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfTransformerMemoryBudgetInMB();
- private static final float oldUdfReaderMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfReaderMemoryBudgetInMB();
-
- @BeforeClass
- public static void setUp() throws Exception {
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(5)
- .setUdfTransformerMemoryBudgetInMB(5)
- .setUdfReaderMemoryBudgetInMB(5);
- EnvFactory.getEnv().initBeforeClass();
- createTimeSeries();
- generateData();
- registerUDF();
- }
-
- private static void createTimeSeries() throws MetadataException {
- LocalSchemaProcessor.getInstance().setStorageGroup(new PartialPath("root.vehicle"));
- // test series for TimeStampRepair
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s1"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- // test series for ValueFill
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s1"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- // test series for ValueRepair
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d3.s1"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- }
-
- private static void generateData() {
- double x = -100d, y = 100d; // borders of random value
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- for (int i = 1; i <= ITERATION_TIMES; ++i) {
- if (Math.random() < 0.99) {
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1) values(%d,%f)",
- (long) i * DELTA_T, Math.floor(x + Math.random() * y % (y - x + 1))));
- } else {
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1) values(%d,%f)",
- (long) i * DELTA_T + (long) Math.floor((Math.random() - 0.5) * DELTA_T),
- Math.floor(x + Math.random() * y % (y - x + 1))));
- }
- }
- for (int i = 1; i <= ITERATION_TIMES; ++i) {
- if (Math.random() < 0.97) {
- statement.execute(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1) values(%d,%f)",
- (long) i * DELTA_T, Math.floor(x + Math.random() * y % (y - x + 1))));
- } else {
- statement.execute(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1) values(%d,%f)",
- (long) i * DELTA_T, Double.NaN));
- }
- }
- for (int i = 1; i <= ITERATION_TIMES; ++i) {
- statement.execute(
- String.format(
- "insert into root.vehicle.d3(timestamp,s1) values(%d,%f)",
- (long) i * DELTA_T,
- i / (double) ITERATION_TIMES * (y - x) + (Math.random() - 0.5) * (y - x)));
- }
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- private static void registerUDF() {
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- statement.execute(
- "create function timestamprepair as 'org.apache.iotdb.library.dquality.UDTFTimestampRepair'");
- statement.execute(
- "create function valuefill as 'org.apache.iotdb.library.dquality.UDTFValueFill'");
- statement.execute(
- "create function valuerepair as 'org.apache.iotdb.library.dquality.UDTFValueRepair'");
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @AfterClass
- public static void tearDown() throws Exception {
- EnvFactory.getEnv().cleanAfterClass();
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(oldUdfCollectorMemoryBudgetInMB)
- .setUdfTransformerMemoryBudgetInMB(oldUdfTransformerMemoryBudgetInMB)
- .setUdfReaderMemoryBudgetInMB(oldUdfReaderMemoryBudgetInMB);
- }
-
- @Test
- public void testTimestampRepair1() {
- String sqlStr =
- String.format("select timestamprepair(d1.s1,'interval'='%d') from root.vehicle", DELTA_T);
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testTimestampRepair2() {
- String sqlStr = "select timestamprepair(d1.s1,'method'='median') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testTimestampRepair3() {
- String sqlStr = "select timestamprepair(d1.s1,'method'='mode') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testTimestampRepair4() {
- String sqlStr = "select timestamprepair(d1.s1,'method'='cluster') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testValueFill1() {
- String sqlStr = "select valuefill(d2.s1,'method'='previous') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testValueFill2() {
- String sqlStr = "select valuefill(d2.s1,'method'='linear') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testValueFill3() {
- String sqlStr = "select valuefill(d2.s1,'method'='likelihood') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testValueFill4() {
- String sqlStr = "select valuefill(d2.s1,'method'='ar') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testValueFill5() {
- String sqlStr = "select valuefill(d2.s1,'method'='ma') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testValueFill6() {
- String sqlStr = "select valuefill(d2.s1,'method'='screen') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testValueRepair1() {
- String sqlStr = "select valuerepair(d3.s1,'method'='screen') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testValueRepair2() {
- String sqlStr = "select valuerepair(d3.s1,'method'='lsgreedy') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-}
diff --git a/library-udf/src/test/java/org/apache/iotdb/library/frequency/FrequencyTests.java b/library-udf/src/test/java/org/apache/iotdb/library/frequency/FrequencyTests.java
deleted file mode 100644
index 32f40cbeae..0000000000
--- a/library-udf/src/test/java/org/apache/iotdb/library/frequency/FrequencyTests.java
+++ /dev/null
@@ -1,309 +0,0 @@
-/*
- * 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.library.frequency;
-
-import org.apache.iotdb.commons.exception.MetadataException;
-import org.apache.iotdb.commons.path.PartialPath;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
-import org.apache.iotdb.db.metadata.LocalSchemaProcessor;
-import org.apache.iotdb.integration.env.ConfigFactory;
-import org.apache.iotdb.integration.env.EnvFactory;
-import org.apache.iotdb.jdbc.Config;
-import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
-
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-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 static org.junit.Assert.fail;
-
-public class FrequencyTests {
- protected static final int ITERATION_TIMES = 16384;
- protected static final int DELTA_T = 100;
- protected static final int PERIOD_1 = 10;
- protected static final int PEROID_2 = 200;
- protected static final double pi = Math.PI;
-
- private static final float oldUdfCollectorMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfCollectorMemoryBudgetInMB();
- private static final float oldUdfTransformerMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfTransformerMemoryBudgetInMB();
- private static final float oldUdfReaderMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfReaderMemoryBudgetInMB();
-
- @BeforeClass
- public static void setUp() throws Exception {
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(5)
- .setUdfTransformerMemoryBudgetInMB(5)
- .setUdfReaderMemoryBudgetInMB(5);
- EnvFactory.getEnv().initBeforeClass();
- createTimeSeries();
- generateData();
- registerUDF();
- }
-
- private static void createTimeSeries() throws MetadataException {
- LocalSchemaProcessor.getInstance().setStorageGroup(new PartialPath("root.vehicle"));
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s1"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s2"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s3"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s1"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s2"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- }
-
- private static void generateData() {
- double x = -100d, y = 100d; // borders of random value
- long a = 0, b = 1000000000;
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- for (int i = 0; i < ITERATION_TIMES; ++i) {
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2,s3) values(%d,%f,%f,%f)",
- (long) (i + 1) * DELTA_T,
- Math.sin(i % PERIOD_1 * 2 * pi / (double) PERIOD_1),
- Math.sin(i % PEROID_2 * 2 * pi / (double) PEROID_2),
- 0.5 * Math.sin(i % PERIOD_1 * pi) + Math.sin(i % PEROID_2 * pi)));
- }
- statement.execute(
- String.format("insert into root.vehicle.d2(timestamp,s1) values(%d, 2)", DELTA_T));
- statement.execute(
- String.format("insert into root.vehicle.d2(timestamp,s1) values(%d, 7)", 2 * DELTA_T));
- statement.execute(
- String.format("insert into root.vehicle.d2(timestamp,s1) values(%d, 4)", 3 * DELTA_T));
- statement.execute(
- String.format("insert into root.vehicle.d2(timestamp,s1) values(%d, 9)", 4 * DELTA_T));
- statement.execute(
- String.format("insert into root.vehicle.d2(timestamp,s2) values(%d, 1)", DELTA_T));
- statement.execute(
- String.format("insert into root.vehicle.d2(timestamp,s2) values(%d, 0)", 2 * DELTA_T));
- statement.execute(
- String.format("insert into root.vehicle.d2(timestamp,s2) values(%d, 1)", 3 * DELTA_T));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- private static void registerUDF() {
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- statement.execute("create function conv as 'org.apache.iotdb.library.dquality.UDTFConv'");
- statement.execute("create function deconv as 'org.apache.iotdb.library.dquality.UDTFDeconv'");
- statement.execute("create function dwt as 'org.apache.iotdb.library.dquality.UDTFDWT'");
- statement.execute("create function fft as 'org.apache.iotdb.library.dquality.UDTFFFT'");
- statement.execute(
- "create function highpass as 'org.apache.iotdb.library.dquality.UDTFHighPass'");
- statement.execute("create function idwt as 'org.apache.iotdb.library.dquality.UDTFIDWT'");
- statement.execute(
- "create function lowpass as 'org.apache.iotdb.library.dquality.UDTFLowPass'");
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @AfterClass
- public static void tearDown() throws Exception {
- EnvFactory.getEnv().cleanAfterClass();
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(oldUdfCollectorMemoryBudgetInMB)
- .setUdfTransformerMemoryBudgetInMB(oldUdfTransformerMemoryBudgetInMB)
- .setUdfReaderMemoryBudgetInMB(oldUdfReaderMemoryBudgetInMB);
- }
-
- // No possible tests for IDWT, IFFT
- @Test
- public void testConv1() {
- String sqlStr = "select conv(d1.s1, d1.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result = Double.parseDouble(resultSet.getString(1));
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testDeconv1() {
- String sqlStr = "select deconv(d2.s1,d2.s2) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result1 = Double.parseDouble(resultSet.getString(1));
- resultSet.next();
- Double result2 = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(Math.abs(result1 - 2d) < 1e-5 && Math.abs(result2 - 7d) < 1e-5);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testDeconv2() {
- String sqlStr = "select deconv(d2.s1,d2.s2,'result'='remainder') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- Double result1 = Double.parseDouble(resultSet.getString(1));
- resultSet.next();
- Double result2 = Double.parseDouble(resultSet.getString(1));
- resultSet.next();
- Double result3 = Double.parseDouble(resultSet.getString(1));
- resultSet.next();
- Double result4 = Double.parseDouble(resultSet.getString(1));
- Assert.assertTrue(
- Math.abs(result1) < 1e-5
- && Math.abs(result2) < 1e-5
- && Math.abs(result3 - 2d) < 1e-5
- && Math.abs(result4 - 2d) < 1e-5);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testDWT1() {
- String sqlStr = "select dwt(d2.s3,'method'='haar') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testDWT2() {
- String sqlStr = "select dwt(d2.s3,'method'='DB4') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testFFT1() {
- String sqlStr = "select fft(d1.s1) from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testHighPass1() {
- String sqlStr = "select highpass(d1.s3,'wpass'='0.5') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet1 = statement.executeQuery(sqlStr);
- ResultSet resultSet2 = statement.executeQuery("select d1.s1 from root.vehicle");
- for (int i = 1; i < ITERATION_TIMES; ++i) {
- Double result1 = Double.parseDouble(resultSet1.getString(1));
- Double result2 = Double.parseDouble(resultSet2.getString(1));
- resultSet1.next();
- resultSet2.next();
- Assert.assertTrue(Math.abs(result1 - 0.5 * result2) < 1e-2);
- }
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testLowPass1() {
- String sqlStr = "select lowpass(d1.s3,'wpass'='0.5') from root.vehicle";
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet1 = statement.executeQuery(sqlStr);
- ResultSet resultSet2 = statement.executeQuery("select d1.s2 from root.vehicle");
- for (int i = 1; i < ITERATION_TIMES; ++i) {
- Double result1 = Double.parseDouble(resultSet1.getString(1));
- Double result2 = Double.parseDouble(resultSet2.getString(1));
- resultSet1.next();
- resultSet2.next();
- Assert.assertTrue(Math.abs(result1 - result2) < 1e-2);
- }
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-}
diff --git a/library-udf/src/test/java/org/apache/iotdb/library/series/SeriesTest.java b/library-udf/src/test/java/org/apache/iotdb/library/series/SeriesTest.java
deleted file mode 100644
index 8647f2eb3b..0000000000
--- a/library-udf/src/test/java/org/apache/iotdb/library/series/SeriesTest.java
+++ /dev/null
@@ -1,471 +0,0 @@
-/*
- * 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.library.series;
-
-import org.apache.iotdb.commons.exception.MetadataException;
-import org.apache.iotdb.commons.path.PartialPath;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
-import org.apache.iotdb.db.metadata.LocalSchemaProcessor;
-import org.apache.iotdb.integration.env.ConfigFactory;
-import org.apache.iotdb.integration.env.EnvFactory;
-import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
-
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.sql.Connection;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
-
-import static org.junit.Assert.fail;
-
-public class SeriesTest {
- protected static final int ITERATION_TIMES = 10_000;
-
- protected static final long TIMESTAMP_INTERVAL = 60; // gap = 60ms
-
- protected static final long START_TIMESTAMP = 0;
-
- protected static final long END_TIMESTAMP = START_TIMESTAMP + ITERATION_TIMES * ITERATION_TIMES;
-
- private static final float oldUdfCollectorMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfCollectorMemoryBudgetInMB();
- private static final float oldUdfTransformerMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfTransformerMemoryBudgetInMB();
- private static final float oldUdfReaderMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfReaderMemoryBudgetInMB();
-
- @BeforeClass
- public static void setUp() throws Exception {
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(5)
- .setUdfTransformerMemoryBudgetInMB(5)
- .setUdfReaderMemoryBudgetInMB(5);
- EnvFactory.getEnv().initBeforeClass();
- createTimeSeries();
- generateData();
- registerUDF();
- }
-
- private static void createTimeSeries() throws MetadataException {
- LocalSchemaProcessor.getInstance().setStorageGroup(new PartialPath("root.vehicle"));
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s1"),
- TSDataType.INT32,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s2"),
- TSDataType.INT64,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s1"),
- TSDataType.FLOAT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s2"),
- TSDataType.DOUBLE,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- }
-
- private static void generateData() {
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- // d1
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)", 1577808000, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)", 1577808300, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)", 1577808600, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)", 1577809200, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)", 1577809500, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)", 1577809800, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)", 1577810100, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1) values(%d,%d)",
- 1577810400, 1)); // s2 == null
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)", 1577810700, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1,s2) values(%d,%d,%d)", 1577811000, 1, 1));
- // d2
- statement.execute(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)", 1577808000, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)", 1577808300, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)", 1577808600, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)", 1577809200, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)", 1577809500, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)", 1577809800, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)", 1577810100, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1) values(%d,%d)",
- 1577810400, 1)); // s2 == null
- statement.execute(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)", 1577810700, 1, 1));
- statement.execute(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1,s2) values(%d,%d,%d)", 1577811000, 1, 1));
-
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- private static void registerUDF() {
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- statement.execute(
- "create function ConsecutiveSequences as 'org.apache.iotdb.library.series.UDTFConsecutiveSequences'");
- statement.execute(
- "create function ConsecutiveWindows as 'org.apache.iotdb.library.series.UDTFConsecutiveWindows'");
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @AfterClass
- public static void tearDown() throws Exception {
- EnvFactory.getEnv().cleanAfterClass();
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(oldUdfCollectorMemoryBudgetInMB)
- .setUdfTransformerMemoryBudgetInMB(oldUdfTransformerMemoryBudgetInMB)
- .setUdfReaderMemoryBudgetInMB(oldUdfReaderMemoryBudgetInMB);
- }
-
- @Test
- public void testConsecutiveSequences1() {
- String sqlStr = "select ConsecutiveSequences(d1.s1,d1.s2) from root.vehicle";
- long timeStamp = 0;
- int value = 0;
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- int resultSetLength = resultSet.getRow();
- Assert.assertEquals(resultSetLength, 3);
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577808000);
- Assert.assertEquals(value, 3);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577809200);
- Assert.assertEquals(value, 4);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577810700);
- Assert.assertEquals(value, 2);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testConsecutiveSequences2() {
- String sqlStr = "select ConsecutiveSequences(d2.s1,d2.s2) from root.vehicle";
- long timeStamp = 0;
- int value = 0;
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- int resultSetLength = resultSet.getRow();
- Assert.assertEquals(resultSetLength, 3);
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577808000);
- Assert.assertEquals(value, 3);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577809200);
- Assert.assertEquals(value, 4);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577810700);
- Assert.assertEquals(value, 2);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testConsecutiveSequences3() {
- String sqlStr = "select ConsecutiveSequences(d1.s1,d1.s2,'gap'='5m') from root.vehicle";
- long timeStamp = 0;
- int value = 0;
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- int resultSetLength = resultSet.getRow();
- Assert.assertEquals(resultSetLength, 3);
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577808000);
- Assert.assertEquals(value, 3);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577809200);
- Assert.assertEquals(value, 4);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577810700);
- Assert.assertEquals(value, 2);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testConsecutiveSequences4() {
- String sqlStr = "select ConsecutiveSequences(d2.s1,d2.s2,'gap'='5m') from root.vehicle";
- long timeStamp = 0;
- int value = 0;
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- int resultSetLength = resultSet.getRow();
- Assert.assertEquals(resultSetLength, 3);
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577808000);
- Assert.assertEquals(value, 3);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577809200);
- Assert.assertEquals(value, 4);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577810700);
- Assert.assertEquals(value, 2);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testConsecutiveWindows1() {
- String sqlStr = "select ConsecutiveWindows(d1.s1,d1.s2,'length'='10m') from root.vehicle";
- long timeStamp = 0;
- int value = 0;
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- int resultSetLength = resultSet.getRow();
- Assert.assertEquals(resultSetLength, 3);
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577808000);
- Assert.assertEquals(value, 3);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577809200);
- Assert.assertEquals(value, 3);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577809500);
- Assert.assertEquals(value, 3);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testConsecutiveWindows2() {
- String sqlStr = "select ConsecutiveWindows(d2.s1,d2.s2,'length'='10m') from root.vehicle";
- long timeStamp = 0;
- int value = 0;
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- int resultSetLength = resultSet.getRow();
- Assert.assertEquals(resultSetLength, 3);
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577808000);
- Assert.assertEquals(value, 3);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577809200);
- Assert.assertEquals(value, 3);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577809500);
- Assert.assertEquals(value, 3);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testConsecutiveWindows3() {
- String sqlStr =
- "select ConsecutiveWindows(d1.s1,d1.s2,'length'='10m','gap'='5m') from root.vehicle";
- long timeStamp = 0;
- int value = 0;
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- int resultSetLength = resultSet.getRow();
- Assert.assertEquals(resultSetLength, 3);
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577808000);
- Assert.assertEquals(value, 3);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577809200);
- Assert.assertEquals(value, 3);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577809500);
- Assert.assertEquals(value, 3);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testConsecutiveWindows4() {
- String sqlStr =
- "select ConsecutiveWindows(d2.s1,d2.s2,'length'='10m','gap'='5m') from root.vehicle";
- long timeStamp = 0;
- int value = 0;
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- int resultSetLength = resultSet.getRow();
- Assert.assertEquals(resultSetLength, 3);
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577808000);
- Assert.assertEquals(value, 3);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577809200);
- Assert.assertEquals(value, 3);
-
- resultSet.next();
-
- timeStamp = Long.parseLong(resultSet.getString(0));
- value = Integer.parseInt(resultSet.getString(1));
- Assert.assertEquals(timeStamp, 1577809500);
- Assert.assertEquals(value, 3);
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-}
diff --git a/library-udf/src/test/java/org/apache/iotdb/library/string/StringTests.java b/library-udf/src/test/java/org/apache/iotdb/library/string/StringTests.java
deleted file mode 100644
index ad4b838297..0000000000
--- a/library-udf/src/test/java/org/apache/iotdb/library/string/StringTests.java
+++ /dev/null
@@ -1,260 +0,0 @@
-/*
- * 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.library.string;
-
-import org.apache.iotdb.commons.exception.MetadataException;
-import org.apache.iotdb.commons.path.PartialPath;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
-import org.apache.iotdb.db.metadata.LocalSchemaProcessor;
-import org.apache.iotdb.integration.env.ConfigFactory;
-import org.apache.iotdb.integration.env.EnvFactory;
-import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
-
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.sql.Connection;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
-
-import static org.junit.Assert.fail;
-
-public class StringTests {
- private static final float oldUdfCollectorMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfCollectorMemoryBudgetInMB();
- private static final float oldUdfTransformerMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfTransformerMemoryBudgetInMB();
- private static final float oldUdfReaderMemoryBudgetInMB =
- IoTDBDescriptor.getInstance().getConfig().getUdfReaderMemoryBudgetInMB();
-
- @BeforeClass
- public static void setUp() throws Exception {
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(5)
- .setUdfTransformerMemoryBudgetInMB(5)
- .setUdfReaderMemoryBudgetInMB(5);
- EnvFactory.getEnv().initBeforeClass();
- createTimeSeries();
- generateData();
- registerUDF();
- }
-
- private static void createTimeSeries() throws MetadataException {
- LocalSchemaProcessor.getInstance().setStorageGroup(new PartialPath("root.vehicle"));
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d1.s1"),
- TSDataType.TEXT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- LocalSchemaProcessor.getInstance()
- .createTimeseries(
- new PartialPath("root.vehicle.d2.s1"),
- TSDataType.TEXT,
- TSEncoding.PLAIN,
- CompressionType.UNCOMPRESSED,
- null);
- }
-
- private static void generateData() {
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1) values(%d,%s)",
- 100, "[192.168.0.1] [SUCCESS]"));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1) values(%d,%s)",
- 200, "[192.168.0.24] [SUCCESS]"));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1) values(%d,%s)",
- 300, "[192.168.0.2] [FAIL]"));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1) values(%d,%s)",
- 400, "[192.168.0.5] [SUCCESS]"));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d1(timestamp,s1) values(%d,%s)",
- 500, "[192.168.0.124] [SUCCESS]"));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1) values(%d,%s)", 100, "A,B,A+,B-"));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1) values(%d,%s)", 200, "A,A+,A,B+"));
- statement.addBatch(
- String.format("insert into root.vehicle.d2(timestamp,s1) values(%d,%s)", 300, "B+,B,B"));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1) values(%d,%s)", 400, "A+,A,A+,A"));
- statement.addBatch(
- String.format(
- "insert into root.vehicle.d2(timestamp,s1) values(%d,%s)", 500, "A,B-,B,B"));
- statement.executeBatch();
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- private static void registerUDF() {
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- statement.execute(
- "create function regexmatch as 'org.apache.iotdb.library.string.UDTFRegexMatch'");
- statement.execute(
- "create function regexreplace as 'org.apache.iotdb.library.string.UDTFRegexReplace'");
- statement.execute(
- "create function regexsplit as 'org.apache.iotdb.library.string.UDTFRegexSplit'");
- statement.execute(
- "create function strreplace as 'org.apache.iotdb.library.string.UDTFStrReplace'");
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @AfterClass
- public static void tearDown() throws Exception {
- EnvFactory.getEnv().cleanAfterClass();
- ConfigFactory.getConfig()
- .setUdfCollectorMemoryBudgetInMB(oldUdfCollectorMemoryBudgetInMB)
- .setUdfTransformerMemoryBudgetInMB(oldUdfTransformerMemoryBudgetInMB)
- .setUdfReaderMemoryBudgetInMB(oldUdfReaderMemoryBudgetInMB);
- }
-
- @Test
- public void testRegexMatch1() {
- String sqlStr =
- "select regexmatch(d1.s1,\"regex\"=\"\\d+\\.\\d+\\.\\d+\\.\\d+\", \"group\"=\"0\") from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- String result1 = resultSet.getString(1);
- resultSet.next();
- String result2 = resultSet.getString(1);
- resultSet.next();
- String result3 = resultSet.getString(1);
- resultSet.next();
- String result4 = resultSet.getString(1);
- resultSet.next();
- String result5 = resultSet.getString(1);
- Assert.assertEquals("192.168.0.1", result1);
- Assert.assertEquals("192.168.0.24", result2);
- Assert.assertEquals("192.168.0.2", result3);
- Assert.assertEquals("192.168.0.5", result4);
- Assert.assertEquals("192.168.0.124", result5);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testRegexReplace1() {
- String sqlStr =
- "select regexreplace(d1.s1,\"regex\"=\"192\\.168\\.0\\.(\\d+)\", \"replace\"=\"cluster-$1\") from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- String result1 = resultSet.getString(1);
- resultSet.next();
- String result2 = resultSet.getString(1);
- resultSet.next();
- String result3 = resultSet.getString(1);
- resultSet.next();
- String result4 = resultSet.getString(1);
- resultSet.next();
- String result5 = resultSet.getString(1);
- Assert.assertEquals("[cluster-1] [SUCCESS]", result1);
- Assert.assertEquals("[cluster-24] [SUCCESS]", result2);
- Assert.assertEquals("[cluster-2] [FAIL]", result3);
- Assert.assertEquals("[cluster-5] [SUCCESS]", result4);
- Assert.assertEquals("[cluster-124] [SUCCESS]", result5);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testRegexSplit1() {
- String sqlStr = "select regexsplit(d2.s1, \"regex\"=\",\", \"index\"=\"-1\") from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- int result1 = resultSet.getInt(1);
- resultSet.next();
- int result2 = resultSet.getInt(1);
- resultSet.next();
- int result3 = resultSet.getInt(1);
- resultSet.next();
- int result4 = resultSet.getInt(1);
- resultSet.next();
- int result5 = resultSet.getInt(1);
- Assert.assertEquals(4, result1);
- Assert.assertEquals(4, result2);
- Assert.assertEquals(3, result3);
- Assert.assertEquals(4, result4);
- Assert.assertEquals(4, result5);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-
- @Test
- public void testStrReplace1() {
- String sqlStr =
- "select strreplace(d2.s1,\"target\"=\",\", \"replace\"=\"/\", \"limit\"=\"2\") from root.vehicle";
- try (Connection connection = EnvFactory.getEnv().getConnection();
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery(sqlStr);
- resultSet.next();
- String result1 = resultSet.getString(1);
- resultSet.next();
- String result2 = resultSet.getString(1);
- resultSet.next();
- String result3 = resultSet.getString(1);
- resultSet.next();
- String result4 = resultSet.getString(1);
- resultSet.next();
- String result5 = resultSet.getString(1);
- Assert.assertEquals("A/B/A+,B-", result1);
- Assert.assertEquals("A/A+/A,B+", result2);
- Assert.assertEquals("B+/B/B", result3);
- Assert.assertEquals("A+/A/A+,A", result4);
- Assert.assertEquals("A/B-/B,B", result5);
- Assert.assertFalse(resultSet.next());
- } catch (SQLException throwable) {
- fail(throwable.getMessage());
- }
- }
-}