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:49 UTC
[iotdb] 02/02: [IOTDB-5190] Move Library-udf IT to integration-test
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());
+ }
+ }
+}