You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by ca...@apache.org on 2022/10/04 01:24:23 UTC
[iotdb] branch master updated: [IOTDB-4398][IOTDB-4416] Migrate some SessionIT (#7393)
This is an automated email from the ASF dual-hosted git repository.
caogaofei pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/master by this push:
new 53d6040351 [IOTDB-4398][IOTDB-4416] Migrate some SessionIT (#7393)
53d6040351 is described below
commit 53d6040351761440a37102a675b038797405f14f
Author: Itami Sho <42...@users.noreply.github.com>
AuthorDate: Tue Oct 4 09:24:15 2022 +0800
[IOTDB-4398][IOTDB-4416] Migrate some SessionIT (#7393)
---
.../iotdb/session/IoTDBSessionComplexIT.java | 2 +-
.../iotdb/session/IoTDBSessionInsertNulIT.java | 358 ++++
.../apache/iotdb/session/IoTDBSessionSimpleIT.java | 1633 +++++++++++++++++++
.../session/IoTDBSessionSyntaxConventionIT.java | 428 +++++
.../iotdb/session/IoTDBSessionComplexIT.java | 929 -----------
.../session/IoTDBSessionDisableMemControlIT.java | 202 ---
.../iotdb/session/IoTDBSessionInsertNullT.java | 298 ----
.../apache/iotdb/session/IoTDBSessionSimpleIT.java | 1704 --------------------
.../session/IoTDBSessionSyntaxConventionIT.java | 415 -----
.../db/mpp/plan/parser/StatementGenerator.java | 17 +-
.../metadata/DeleteTimeSeriesStatement.java | 5 +
.../service/thrift/impl/ClientRPCServiceImpl.java | 60 +-
12 files changed, 2489 insertions(+), 3562 deletions(-)
diff --git a/integration-test/src/test/java/org/apache/iotdb/session/IoTDBSessionComplexIT.java b/integration-test/src/test/java/org/apache/iotdb/session/IoTDBSessionComplexIT.java
index d88ff57b71..ef49cef0a7 100644
--- a/integration-test/src/test/java/org/apache/iotdb/session/IoTDBSessionComplexIT.java
+++ b/integration-test/src/test/java/org/apache/iotdb/session/IoTDBSessionComplexIT.java
@@ -81,7 +81,7 @@ public class IoTDBSessionComplexIT {
insertViaSQL(session);
queryByDevice(session, "root.sg1.d1");
- } catch (IoTDBConnectionException | StatementExecutionException e) {
+ } catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
diff --git a/integration-test/src/test/java/org/apache/iotdb/session/IoTDBSessionInsertNulIT.java b/integration-test/src/test/java/org/apache/iotdb/session/IoTDBSessionInsertNulIT.java
new file mode 100644
index 0000000000..1e475b32ec
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/session/IoTDBSessionInsertNulIT.java
@@ -0,0 +1,358 @@
+/*
+ * 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.session;
+
+import org.apache.iotdb.commons.conf.IoTDBConstant;
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.ClusterIT;
+import org.apache.iotdb.itbase.category.LocalStandaloneIT;
+import org.apache.iotdb.rpc.IoTDBConnectionException;
+import org.apache.iotdb.rpc.StatementExecutionException;
+import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
+import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
+import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
+import org.apache.iotdb.tsfile.read.common.Field;
+import org.apache.iotdb.tsfile.read.common.RowRecord;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({LocalStandaloneIT.class, ClusterIT.class})
+public class IoTDBSessionInsertNulIT {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(IoTDBSessionInsertNulIT.class);
+ private final int retry = 30;
+
+ @Before
+ public void setUp() throws Exception {
+ System.setProperty(IoTDBConstant.IOTDB_CONF, "src/test/resources/");
+ EnvFactory.getEnv().initBeforeTest();
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanAfterTest();
+ }
+
+ private void prepareData(ISession session)
+ throws IoTDBConnectionException, StatementExecutionException {
+ session.setStorageGroup("root.sg1");
+ session.createTimeseries(
+ "root.sg1.clsu.d1.s1", TSDataType.BOOLEAN, TSEncoding.PLAIN, CompressionType.SNAPPY);
+ session.createTimeseries(
+ "root.sg1.clsu.d1.s2", TSDataType.INT32, TSEncoding.PLAIN, CompressionType.SNAPPY);
+ session.createTimeseries(
+ "root.sg1.clsu.d1.s3", TSDataType.INT64, TSEncoding.PLAIN, CompressionType.SNAPPY);
+ session.createTimeseries(
+ "root.sg1.clsu.d1.s4", TSDataType.FLOAT, TSEncoding.PLAIN, CompressionType.SNAPPY);
+ session.createTimeseries(
+ "root.sg1.clsu.d1.s5", TSDataType.DOUBLE, TSEncoding.PLAIN, CompressionType.SNAPPY);
+ session.createTimeseries(
+ "root.sg1.clsu.d1.s6", TSDataType.TEXT, TSEncoding.PLAIN, CompressionType.SNAPPY);
+ session.createTimeseries(
+ "root.sg1.clsu.d2.s1", TSDataType.BOOLEAN, TSEncoding.PLAIN, CompressionType.SNAPPY);
+ }
+
+ private long queryCountRecords(ISession session, String sql)
+ throws StatementExecutionException, IoTDBConnectionException {
+ SessionDataSet dataSetWrapper = session.executeQueryStatement(sql, 1000);
+ long count = 0;
+ while (dataSetWrapper.hasNext()) {
+ RowRecord record = dataSetWrapper.next();
+ Field field = record.getFields().get(0);
+ switch (field.getDataType()) {
+ case INT32:
+ count = field.getIntV();
+ break;
+ case INT64:
+ count = field.getLongV();
+ break;
+ }
+ }
+ return count;
+ }
+
+ @Test
+ public void insertRecordNullTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ prepareData(session);
+
+ String deviceId = "root.sg1.clsu.d1";
+ session.insertRecord(deviceId, 100, Arrays.asList("s1"), Arrays.asList("true"));
+ List<String> t = new ArrayList<>();
+ t.add(null);
+ session.insertRecord(deviceId, 200, Arrays.asList("s1"), t);
+ session.insertRecord(
+ deviceId,
+ 300,
+ Arrays.asList("s1", "s2"),
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
+ Arrays.asList(true, 30));
+ session.insertRecord(
+ deviceId,
+ 400,
+ Arrays.asList("s1", "s2"),
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
+ Arrays.asList(true, null));
+ session.insertRecord(
+ deviceId,
+ 500,
+ Arrays.asList("s1", "s2"),
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
+ Arrays.asList(null, null));
+ long nums = queryCountRecords(session, "select count(s1) from " + deviceId);
+ assertEquals(3, nums);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void insertAlignedRecordNullTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ prepareData(session);
+
+ String deviceId = "root.sg1.clsu.aligned_d1";
+ session.insertAlignedRecord(deviceId, 100, Arrays.asList("s1"), Arrays.asList("true"));
+ List<String> t = new ArrayList<>();
+ t.add(null);
+ session.insertAlignedRecord(deviceId, 200, Arrays.asList("s1"), t);
+ session.insertAlignedRecord(
+ deviceId,
+ 300,
+ Arrays.asList("s1", "s2"),
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
+ Arrays.asList(true, 30));
+ session.insertAlignedRecord(
+ deviceId,
+ 400,
+ Arrays.asList("s1", "s2"),
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
+ Arrays.asList(true, null));
+ session.insertAlignedRecord(
+ deviceId,
+ 500,
+ Arrays.asList("s1", "s2"),
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
+ Arrays.asList(null, null));
+ for (int i = 0; i < retry; i++) {
+ try {
+ long nums = queryCountRecords(session, "select count(s1) from " + deviceId);
+ assertEquals(3, nums);
+ return;
+ } catch (Exception e) {
+ LOGGER.info("query records failed, retry: " + i);
+ Thread.sleep(1000);
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void insertRecordsNullTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ prepareData(session);
+
+ String deviceId1 = "root.sg1.clsu.d2";
+ String deviceId2 = "root.sg1.clsu.d3";
+ session.insertRecords(
+ Arrays.asList(deviceId1, deviceId2),
+ Arrays.asList(300L, 300L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
+ Arrays.asList(Arrays.asList(true, 101), Arrays.asList(false, 201)));
+ session.insertRecords(
+ Arrays.asList(deviceId1, deviceId2),
+ Arrays.asList(200L, 200L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(Arrays.asList("false", "101"), Arrays.asList("true", "201")));
+ session.insertRecords(
+ Arrays.asList(deviceId1, deviceId2),
+ Arrays.asList(400L, 400L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(Arrays.asList(null, "102"), Arrays.asList("false", "202")));
+ session.insertRecords(
+ Arrays.asList(deviceId1, deviceId2),
+ Arrays.asList(500L, 500L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
+ Arrays.asList(Arrays.asList(true, null), Arrays.asList(null, null)));
+
+ for (int i = 0; i < retry; i++) {
+ try {
+ long nums = queryCountRecords(session, "select count(s1) from " + deviceId1);
+ assertEquals(3, nums);
+ nums = queryCountRecords(session, "select count(s2) from " + deviceId2);
+ assertEquals(3, nums);
+ return;
+ } catch (Exception e) {
+ LOGGER.info("query records failed, retry: " + i);
+ Thread.sleep(1000);
+ }
+ }
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void insertAlignedRecordsNullTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ prepareData(session);
+ String deviceId1 = "root.sg1.clsu.aligned_d2";
+ String deviceId2 = "root.sg1.clsu.aligned_d3";
+ session.insertAlignedRecords(
+ Arrays.asList(deviceId1, deviceId2),
+ Arrays.asList(300L, 300L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
+ Arrays.asList(Arrays.asList(true, 101), Arrays.asList(false, 201)));
+ session.insertAlignedRecords(
+ Arrays.asList(deviceId1, deviceId2),
+ Arrays.asList(200L, 200L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(Arrays.asList("false", "101"), Arrays.asList("true", "201")));
+ session.insertAlignedRecords(
+ Arrays.asList(deviceId1, deviceId2),
+ Arrays.asList(400L, 400L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(Arrays.asList(null, "102"), Arrays.asList("false", "202")));
+ session.insertAlignedRecords(
+ Arrays.asList(deviceId1, deviceId2),
+ Arrays.asList(500L, 500L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
+ Arrays.asList(Arrays.asList(true, null), Arrays.asList(null, null)));
+ long nums = queryCountRecords(session, "select count(s1) from " + deviceId1);
+ assertEquals(3, nums);
+ nums = queryCountRecords(session, "select count(s2) from " + deviceId2);
+ assertEquals(3, nums);
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void insertRecordsOfOneDeviceNullTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ prepareData(session);
+ String deviceId1 = "root.sg1.clsu.InsertRecordsOfOneDevice";
+ session.insertRecordsOfOneDevice(
+ deviceId1,
+ Arrays.asList(300L, 301L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
+ Arrays.asList(Arrays.asList(true, 101), Arrays.asList(false, 201)));
+ session.insertStringRecordsOfOneDevice(
+ deviceId1,
+ Arrays.asList(200L, 201L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(Arrays.asList("false", "101"), Arrays.asList("true", "201")));
+ session.insertStringRecordsOfOneDevice(
+ deviceId1,
+ Arrays.asList(400L, 401L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(Arrays.asList(null, "102"), Arrays.asList("false", "202")));
+ session.insertRecordsOfOneDevice(
+ deviceId1,
+ Arrays.asList(500L, 501L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
+ Arrays.asList(Arrays.asList(true, null), Arrays.asList(null, null)));
+ long nums = queryCountRecords(session, "select count(s1) from " + deviceId1);
+ assertEquals(6, nums);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void insertAlignedRecordsOfOneDeviceNullTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ prepareData(session);
+ String deviceId1 = "root.sg1.clsu.InsertAlignedRecordsOfOneDevice";
+ session.insertAlignedRecordsOfOneDevice(
+ deviceId1,
+ Arrays.asList(300L, 301L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
+ Arrays.asList(Arrays.asList(true, 101), Arrays.asList(false, 201)));
+ session.insertAlignedStringRecordsOfOneDevice(
+ deviceId1,
+ Arrays.asList(200L, 201L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(Arrays.asList("false", "101"), Arrays.asList("true", "201")));
+ session.insertAlignedStringRecordsOfOneDevice(
+ deviceId1,
+ Arrays.asList(400L, 401L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(Arrays.asList(null, "102"), Arrays.asList("false", "202")));
+ session.insertAlignedRecordsOfOneDevice(
+ deviceId1,
+ Arrays.asList(500L, 501L),
+ Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
+ Arrays.asList(
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
+ Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
+ Arrays.asList(Arrays.asList(true, null), Arrays.asList(null, null)));
+ long nums = queryCountRecords(session, "select count(s1) from " + deviceId1);
+ assertEquals(6, nums);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/session/IoTDBSessionSimpleIT.java b/integration-test/src/test/java/org/apache/iotdb/session/IoTDBSessionSimpleIT.java
new file mode 100644
index 0000000000..9609b5c11d
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/session/IoTDBSessionSimpleIT.java
@@ -0,0 +1,1633 @@
+/*
+ * 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.session;
+
+import org.apache.iotdb.commons.conf.IoTDBConstant;
+import org.apache.iotdb.db.conf.IoTDBDescriptor;
+import org.apache.iotdb.db.conf.OperationType;
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.ClusterIT;
+import org.apache.iotdb.itbase.category.LocalStandaloneIT;
+import org.apache.iotdb.rpc.BatchExecutionException;
+import org.apache.iotdb.rpc.IoTDBConnectionException;
+import org.apache.iotdb.rpc.StatementExecutionException;
+import org.apache.iotdb.rpc.TSStatusCode;
+import org.apache.iotdb.session.template.InternalNode;
+import org.apache.iotdb.session.template.MeasurementNode;
+import org.apache.iotdb.session.template.Template;
+import org.apache.iotdb.session.template.TemplateNode;
+import org.apache.iotdb.tsfile.common.constant.TsFileConstant;
+import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
+import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
+import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
+import org.apache.iotdb.tsfile.read.common.Field;
+import org.apache.iotdb.tsfile.read.common.RowRecord;
+import org.apache.iotdb.tsfile.utils.Binary;
+import org.apache.iotdb.tsfile.utils.BitMap;
+import org.apache.iotdb.tsfile.write.record.Tablet;
+import org.apache.iotdb.tsfile.write.schema.MeasurementSchema;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+public class IoTDBSessionSimpleIT {
+
+ private static Logger LOGGER = LoggerFactory.getLogger(IoTDBSessionSimpleIT.class);
+
+ @Before
+ public void setUp() throws Exception {
+ System.setProperty(IoTDBConstant.IOTDB_CONF, "src/test/resources/");
+ EnvFactory.getEnv().initBeforeTest();
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanAfterTest();
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertPartialTabletTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ List<MeasurementSchema> schemaList = new ArrayList<>();
+ schemaList.add(new MeasurementSchema("s1", TSDataType.INT64));
+ schemaList.add(new MeasurementSchema("s2", TSDataType.DOUBLE));
+ schemaList.add(new MeasurementSchema("s3", TSDataType.TEXT));
+
+ Tablet tablet = new Tablet("root.sg.d", schemaList, 10);
+
+ long timestamp = System.currentTimeMillis();
+
+ for (long row = 0; row < 15; row++) {
+ int rowIndex = tablet.rowSize++;
+ tablet.addTimestamp(rowIndex, timestamp);
+ tablet.addValue("s1", rowIndex, 1L);
+ tablet.addValue("s2", rowIndex, 1D);
+ tablet.addValue("s3", rowIndex, new Binary("1"));
+ if (tablet.rowSize == tablet.getMaxRowNumber()) {
+ session.insertTablet(tablet, true);
+ tablet.reset();
+ }
+ timestamp++;
+ }
+
+ if (tablet.rowSize != 0) {
+ session.insertTablet(tablet);
+ tablet.reset();
+ }
+
+ SessionDataSet dataSet = session.executeQueryStatement("select count(*) from root");
+ while (dataSet.hasNext()) {
+ RowRecord rowRecord = dataSet.next();
+ assertEquals(15L, rowRecord.getFields().get(0).getLongV());
+ assertEquals(15L, rowRecord.getFields().get(1).getLongV());
+ assertEquals(15L, rowRecord.getFields().get(2).getLongV());
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertByStrAndInferTypeTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ String deviceId = "root.sg1.d1";
+ List<String> measurements = new ArrayList<>();
+ measurements.add("s1");
+ measurements.add("s2");
+ measurements.add("s3");
+ measurements.add("s4");
+
+ List<String> values = new ArrayList<>();
+ values.add("1");
+ values.add("1.2");
+ values.add("true");
+ values.add("dad");
+ session.insertRecord(deviceId, 1L, measurements, values);
+
+ Set<String> expected = new HashSet<>();
+ expected.add(IoTDBDescriptor.getInstance().getConfig().getIntegerStringInferType().name());
+ expected.add(IoTDBDescriptor.getInstance().getConfig().getFloatingStringInferType().name());
+ expected.add(IoTDBDescriptor.getInstance().getConfig().getBooleanStringInferType().name());
+ expected.add(TSDataType.TEXT.name());
+
+ Set<String> actual = new HashSet<>();
+ SessionDataSet dataSet = session.executeQueryStatement("show timeseries root.**");
+ while (dataSet.hasNext()) {
+ actual.add(dataSet.next().getFields().get(3).getStringValue());
+ }
+
+ assertEquals(expected, actual);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertWrongPathByStrAndInferTypeTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ String deviceId = "root.sg1..d1";
+ List<String> measurements = new ArrayList<>();
+ measurements.add("s1");
+ measurements.add("s2");
+ measurements.add("s3");
+ measurements.add("s4");
+
+ List<String> values = new ArrayList<>();
+ values.add("1");
+ values.add("1.2");
+ values.add("true");
+ values.add("dad");
+ try {
+ session.insertRecord(deviceId, 1L, measurements, values);
+ } catch (Exception e) {
+ LOGGER.error("", e);
+ }
+
+ SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
+ assertFalse(dataSet.hasNext());
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertIntoIllegalTimeseriesTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ String deviceId = "root.sg1.d1\n";
+ List<String> measurements = new ArrayList<>();
+ measurements.add("s1");
+ measurements.add("s2");
+ measurements.add("s3");
+ measurements.add("s4");
+
+ List<String> values = new ArrayList<>();
+ values.add("1");
+ values.add("1.2");
+ values.add("true");
+ values.add("dad");
+ try {
+ session.insertRecord(deviceId, 1L, measurements, values);
+ } catch (Exception e) {
+ LOGGER.error("", e);
+ }
+
+ SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
+ assertFalse(dataSet.hasNext());
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertByObjAndNotInferTypeTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ String deviceId = "root.sg1.d1";
+ List<String> measurements = new ArrayList<>();
+ measurements.add("s1");
+ measurements.add("s2");
+ measurements.add("s3");
+ measurements.add("s4");
+
+ List<TSDataType> dataTypes = new ArrayList<>();
+ dataTypes.add(TSDataType.INT64);
+ dataTypes.add(TSDataType.DOUBLE);
+ dataTypes.add(TSDataType.TEXT);
+ dataTypes.add(TSDataType.TEXT);
+
+ List<Object> values = new ArrayList<>();
+ values.add(1L);
+ values.add(1.2d);
+ values.add("true");
+ values.add("dad");
+ session.insertRecord(deviceId, 1L, measurements, dataTypes, values);
+
+ Set<String> expected = new HashSet<>();
+ expected.add(TSDataType.INT64.name());
+ expected.add(TSDataType.DOUBLE.name());
+ expected.add(TSDataType.TEXT.name());
+ expected.add(TSDataType.TEXT.name());
+
+ Set<String> actual = new HashSet<>();
+ SessionDataSet dataSet = session.executeQueryStatement("show timeseries root.**");
+ while (dataSet.hasNext()) {
+ actual.add(dataSet.next().getFields().get(3).getStringValue());
+ }
+
+ assertEquals(expected, actual);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void createMultiTimeseriesTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ List<String> paths = new ArrayList<>();
+ paths.add("root.sg1.d1.s1");
+ paths.add("root.sg1.d1.s2");
+ List<TSDataType> tsDataTypes = new ArrayList<>();
+ tsDataTypes.add(TSDataType.DOUBLE);
+ tsDataTypes.add(TSDataType.DOUBLE);
+ List<TSEncoding> tsEncodings = new ArrayList<>();
+ tsEncodings.add(TSEncoding.RLE);
+ tsEncodings.add(TSEncoding.RLE);
+ List<CompressionType> compressionTypes = new ArrayList<>();
+ compressionTypes.add(CompressionType.SNAPPY);
+ compressionTypes.add(CompressionType.SNAPPY);
+
+ List<Map<String, String>> tagsList = new ArrayList<>();
+ Map<String, String> tags = new HashMap<>();
+ tags.put("tag1", "v1");
+ tagsList.add(tags);
+ tagsList.add(tags);
+
+ session.createMultiTimeseries(
+ paths, tsDataTypes, tsEncodings, compressionTypes, null, tagsList, null, null);
+
+ assertTrue(session.checkTimeseriesExists("root.sg1.d1.s1"));
+ assertTrue(session.checkTimeseriesExists("root.sg1.d1.s2"));
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void chineseCharacterTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ if (!System.getProperty("sun.jnu.encoding").contains("UTF-8")) {
+ LOGGER.error("The system does not support UTF-8, so skip Chinese test...");
+ session.close();
+ return;
+ }
+ String storageGroup = "root.存储组1";
+ String[] devices = new String[] {"设备1.指标1", "设备1.s2", "d2.s1", "d2.指标2"};
+ session.setStorageGroup(storageGroup);
+ for (String path : devices) {
+ String fullPath = storageGroup + TsFileConstant.PATH_SEPARATOR + path;
+ session.createTimeseries(
+ fullPath, TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
+ }
+
+ for (String path : devices) {
+ for (int i = 0; i < 10; i++) {
+ String[] ss = path.split("\\.");
+ StringBuilder deviceId = new StringBuilder(storageGroup);
+ for (int j = 0; j < ss.length - 1; j++) {
+ deviceId.append(TsFileConstant.PATH_SEPARATOR).append(ss[j]);
+ }
+ String sensorId = ss[ss.length - 1];
+ List<String> measurements = new ArrayList<>();
+ List<Object> values = new ArrayList<>();
+ List<TSDataType> types = new ArrayList<>();
+
+ measurements.add(sensorId);
+ types.add(TSDataType.INT64);
+ values.add(100L);
+ session.insertRecord(deviceId.toString(), i, measurements, types, values);
+ }
+ }
+
+ SessionDataSet dataSet = session.executeQueryStatement("select * from root.存储组1.*");
+ int count = 0;
+ while (dataSet.hasNext()) {
+ count++;
+ }
+ assertEquals(10, count);
+ session.deleteStorageGroup(storageGroup);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertTabletWithAlignedTimeseriesTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ List<MeasurementSchema> schemaList = new ArrayList<>();
+ schemaList.add(new MeasurementSchema("s1", TSDataType.INT64));
+ schemaList.add(new MeasurementSchema("s2", TSDataType.INT32));
+ schemaList.add(new MeasurementSchema("s3", TSDataType.TEXT));
+
+ Tablet tablet = new Tablet("root.sg1.d1", schemaList);
+ long timestamp = System.currentTimeMillis();
+
+ for (long row = 0; row < 10; row++) {
+ int rowIndex = tablet.rowSize++;
+ tablet.addTimestamp(rowIndex, timestamp);
+ tablet.addValue(
+ schemaList.get(0).getMeasurementId(), rowIndex, new SecureRandom().nextLong());
+ tablet.addValue(
+ schemaList.get(1).getMeasurementId(), rowIndex, new SecureRandom().nextInt());
+ tablet.addValue(schemaList.get(2).getMeasurementId(), rowIndex, new Binary("test"));
+ timestamp++;
+ }
+
+ if (tablet.rowSize != 0) {
+ session.insertAlignedTablet(tablet);
+ tablet.reset();
+ }
+
+ SessionDataSet dataSet = session.executeQueryStatement("select count(*) from root");
+ while (dataSet.hasNext()) {
+ RowRecord rowRecord = dataSet.next();
+ assertEquals(10L, rowRecord.getFields().get(0).getLongV());
+ assertEquals(10L, rowRecord.getFields().get(1).getLongV());
+ assertEquals(10L, rowRecord.getFields().get(2).getLongV());
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertTabletWithNullValuesTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ List<MeasurementSchema> schemaList = new ArrayList<>();
+ schemaList.add(new MeasurementSchema("s0", TSDataType.DOUBLE, TSEncoding.RLE));
+ schemaList.add(new MeasurementSchema("s1", TSDataType.FLOAT, TSEncoding.RLE));
+ schemaList.add(new MeasurementSchema("s2", TSDataType.INT64, TSEncoding.RLE));
+ schemaList.add(new MeasurementSchema("s3", TSDataType.INT32, TSEncoding.RLE));
+ schemaList.add(new MeasurementSchema("s4", TSDataType.BOOLEAN, TSEncoding.RLE));
+ schemaList.add(new MeasurementSchema("s5", TSDataType.TEXT, TSEncoding.RLE));
+
+ Tablet tablet = new Tablet("root.sg1.d1", schemaList);
+ for (long time = 0; time < 10; time++) {
+ int rowIndex = tablet.rowSize++;
+ tablet.addTimestamp(rowIndex, time);
+
+ tablet.addValue(schemaList.get(0).getMeasurementId(), rowIndex, (double) time);
+ tablet.addValue(schemaList.get(1).getMeasurementId(), rowIndex, (float) time);
+ tablet.addValue(schemaList.get(2).getMeasurementId(), rowIndex, time);
+ tablet.addValue(schemaList.get(3).getMeasurementId(), rowIndex, (int) time);
+ tablet.addValue(schemaList.get(4).getMeasurementId(), rowIndex, time % 2 == 0);
+ tablet.addValue(
+ schemaList.get(5).getMeasurementId(), rowIndex, new Binary(String.valueOf(time)));
+ }
+
+ BitMap[] bitMaps = new BitMap[schemaList.size()];
+ for (int i = 0; i < schemaList.size(); i++) {
+ if (bitMaps[i] == null) {
+ bitMaps[i] = new BitMap(10);
+ }
+ bitMaps[i].mark(i);
+ }
+ tablet.bitMaps = bitMaps;
+
+ if (tablet.rowSize != 0) {
+ session.insertTablet(tablet);
+ tablet.reset();
+ }
+
+ SessionDataSet dataSet = session.executeQueryStatement("select count(*) from root");
+ while (dataSet.hasNext()) {
+ RowRecord rowRecord = dataSet.next();
+ assertEquals(6L, rowRecord.getFields().size());
+ for (Field field : rowRecord.getFields()) {
+ assertEquals(9L, field.getLongV());
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertTabletWithStringValuesTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ List<MeasurementSchema> schemaList = new ArrayList<>();
+ schemaList.add(new MeasurementSchema("s0", TSDataType.DOUBLE, TSEncoding.RLE));
+ schemaList.add(new MeasurementSchema("s1", TSDataType.FLOAT, TSEncoding.RLE));
+ schemaList.add(new MeasurementSchema("s2", TSDataType.INT64, TSEncoding.RLE));
+ schemaList.add(new MeasurementSchema("s3", TSDataType.INT32, TSEncoding.RLE));
+ schemaList.add(new MeasurementSchema("s4", TSDataType.BOOLEAN, TSEncoding.RLE));
+ schemaList.add(new MeasurementSchema("s5", TSDataType.TEXT, TSEncoding.RLE));
+ schemaList.add(new MeasurementSchema("s6", TSDataType.TEXT, TSEncoding.RLE));
+
+ Tablet tablet = new Tablet("root.sg1.d1", schemaList);
+ for (long time = 0; time < 10; time++) {
+ int rowIndex = tablet.rowSize++;
+ tablet.addTimestamp(rowIndex, time);
+
+ tablet.addValue(schemaList.get(0).getMeasurementId(), rowIndex, (double) time);
+ tablet.addValue(schemaList.get(1).getMeasurementId(), rowIndex, (float) time);
+ tablet.addValue(schemaList.get(2).getMeasurementId(), rowIndex, time);
+ tablet.addValue(schemaList.get(3).getMeasurementId(), rowIndex, (int) time);
+ tablet.addValue(schemaList.get(4).getMeasurementId(), rowIndex, time % 2 == 0);
+ tablet.addValue(schemaList.get(5).getMeasurementId(), rowIndex, new Binary("Text" + time));
+ tablet.addValue(schemaList.get(6).getMeasurementId(), rowIndex, "Text" + time);
+ }
+
+ if (tablet.rowSize != 0) {
+ session.insertTablet(tablet);
+ tablet.reset();
+ }
+
+ SessionDataSet dataSet = session.executeQueryStatement("select * from root.sg1.d1");
+ while (dataSet.hasNext()) {
+ RowRecord rowRecord = dataSet.next();
+ List<Field> fields = rowRecord.getFields();
+ assertEquals(fields.get(5).getBinaryV(), fields.get(6).getBinaryV());
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void createTimeSeriesWithDoubleTicksTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ if (!System.getProperty("sun.jnu.encoding").contains("UTF-8")) {
+ LOGGER.error("The system does not support UTF-8, so skip Chinese test...");
+ session.close();
+ return;
+ }
+ String storageGroup = "root.sg";
+ session.setStorageGroup(storageGroup);
+
+ session.createTimeseries(
+ "root.sg.`my.device.with.colon:`.s",
+ TSDataType.INT64,
+ TSEncoding.RLE,
+ CompressionType.SNAPPY);
+
+ final SessionDataSet dataSet = session.executeQueryStatement("SHOW TIMESERIES");
+ assertTrue(dataSet.hasNext());
+
+ session.deleteStorageGroup(storageGroup);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void createWrongTimeSeriesTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ if (!System.getProperty("sun.jnu.encoding").contains("UTF-8")) {
+ LOGGER.error("The system does not support UTF-8, so skip Chinese test...");
+ session.close();
+ return;
+ }
+ String storageGroup = "root.sg";
+ session.setStorageGroup(storageGroup);
+
+ try {
+ session.createTimeseries(
+ "root.sg.d1..s1", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
+ } catch (IoTDBConnectionException | StatementExecutionException e) {
+ LOGGER.error("", e);
+ }
+
+ try {
+ session.createTimeseries("", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
+ } catch (IoTDBConnectionException | StatementExecutionException e) {
+ LOGGER.error("", e);
+ }
+
+ final SessionDataSet dataSet = session.executeQueryStatement("SHOW TIMESERIES");
+ assertFalse(dataSet.hasNext());
+
+ session.deleteStorageGroup(storageGroup);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({ClusterIT.class})
+ public void deleteNonExistTimeSeriesTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ session.insertRecord(
+ "root.sg1.d1", 0, Arrays.asList("t1", "t2", "t3"), Arrays.asList("123", "333", "444"));
+ try {
+ session.deleteTimeseries(
+ Arrays.asList("root.sg1.d1.t6", "root.sg1.d1.t2", "root.sg1.d1.t3"));
+ } catch (BatchExecutionException e) {
+ assertTrue(e.getMessage().contains("Path [root.sg1.d1.t6] does not exist;"));
+ }
+ assertTrue(session.checkTimeseriesExists("root.sg1.d1.t1"));
+ assertFalse(session.checkTimeseriesExists("root.sg1.d1.t2"));
+ assertFalse(session.checkTimeseriesExists("root.sg1.d1.t3"));
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertOneDeviceRecordsTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ List<Long> times = new ArrayList<>();
+ List<List<String>> measurements = new ArrayList<>();
+ List<List<TSDataType>> datatypes = new ArrayList<>();
+ List<List<Object>> values = new ArrayList<>();
+
+ addLine(
+ times,
+ measurements,
+ datatypes,
+ values,
+ 3L,
+ "s1",
+ "s2",
+ TSDataType.INT32,
+ TSDataType.INT32,
+ 1,
+ 2);
+ addLine(
+ times,
+ measurements,
+ datatypes,
+ values,
+ 2L,
+ "s2",
+ "s3",
+ TSDataType.INT32,
+ TSDataType.INT64,
+ 3,
+ 4L);
+ addLine(
+ times,
+ measurements,
+ datatypes,
+ values,
+ 1L,
+ "s4",
+ "s5",
+ TSDataType.FLOAT,
+ TSDataType.BOOLEAN,
+ 5.0f,
+ Boolean.TRUE);
+ session.insertRecordsOfOneDevice("root.sg.d1", times, measurements, datatypes, values);
+ checkResult(session);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ private void addLine(
+ List<Long> times,
+ List<List<String>> measurements,
+ List<List<TSDataType>> datatypes,
+ List<List<Object>> values,
+ long time,
+ String s1,
+ String s2,
+ TSDataType s1type,
+ TSDataType s2type,
+ Object value1,
+ Object value2) {
+ List<String> tmpMeasurements = new ArrayList<>();
+ List<TSDataType> tmpDataTypes = new ArrayList<>();
+ List<Object> tmpValues = new ArrayList<>();
+ tmpMeasurements.add(s1);
+ tmpMeasurements.add(s2);
+ tmpDataTypes.add(s1type);
+ tmpDataTypes.add(s2type);
+ tmpValues.add(value1);
+ tmpValues.add(value2);
+ times.add(time);
+ measurements.add(tmpMeasurements);
+ datatypes.add(tmpDataTypes);
+ values.add(tmpValues);
+ }
+
+ private void checkResult(ISession session)
+ throws StatementExecutionException, IoTDBConnectionException {
+ SessionDataSet dataSet = session.executeQueryStatement("select * from root.sg.d1");
+ dataSet.getColumnNames();
+ assertArrayEquals(
+ dataSet.getColumnNames().toArray(new String[0]),
+ new String[] {
+ "Time",
+ "root.sg.d1.s3",
+ "root.sg.d1.s4",
+ "root.sg.d1.s5",
+ "root.sg.d1.s1",
+ "root.sg.d1.s2"
+ });
+ assertArrayEquals(
+ dataSet.getColumnTypes().toArray(new String[0]),
+ new String[] {
+ String.valueOf(TSDataType.INT64),
+ String.valueOf(TSDataType.INT64),
+ String.valueOf(TSDataType.FLOAT),
+ String.valueOf(TSDataType.BOOLEAN),
+ String.valueOf(TSDataType.INT32),
+ String.valueOf(TSDataType.INT32)
+ });
+ long time = 1L;
+ //
+ assertTrue(dataSet.hasNext());
+ RowRecord record = dataSet.next();
+ assertEquals(time, record.getTimestamp());
+ time++;
+ assertNulls(record, new int[] {0, 3, 4});
+ assertEquals(5.0f, record.getFields().get(1).getFloatV(), 0.01);
+ assertEquals(Boolean.TRUE, record.getFields().get(2).getBoolV());
+
+ assertTrue(dataSet.hasNext());
+ record = dataSet.next();
+ assertEquals(time, record.getTimestamp());
+ time++;
+ assertNulls(record, new int[] {1, 2, 3});
+ assertEquals(4L, record.getFields().get(0).getLongV());
+ assertEquals(3, record.getFields().get(4).getIntV());
+
+ assertTrue(dataSet.hasNext());
+ record = dataSet.next();
+ assertEquals(time, record.getTimestamp());
+ assertNulls(record, new int[] {0, 1, 2});
+ assertEquals(1, record.getFields().get(3).getIntV());
+ assertEquals(2, record.getFields().get(4).getIntV());
+
+ assertFalse(dataSet.hasNext());
+ dataSet.closeOperationHandle();
+ }
+
+ private void assertNulls(RowRecord record, int[] index) {
+ for (int i : index) {
+ assertNull(record.getFields().get(i).getDataType());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertOneDeviceRecordsWithOrderTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ List<Long> times = new ArrayList<>();
+ List<List<String>> measurements = new ArrayList<>();
+ List<List<TSDataType>> datatypes = new ArrayList<>();
+ List<List<Object>> values = new ArrayList<>();
+
+ addLine(
+ times,
+ measurements,
+ datatypes,
+ values,
+ 1L,
+ "s4",
+ "s5",
+ TSDataType.FLOAT,
+ TSDataType.BOOLEAN,
+ 5.0f,
+ Boolean.TRUE);
+ addLine(
+ times,
+ measurements,
+ datatypes,
+ values,
+ 2L,
+ "s2",
+ "s3",
+ TSDataType.INT32,
+ TSDataType.INT64,
+ 3,
+ 4L);
+ addLine(
+ times,
+ measurements,
+ datatypes,
+ values,
+ 3L,
+ "s1",
+ "s2",
+ TSDataType.INT32,
+ TSDataType.INT32,
+ 1,
+ 2);
+
+ session.insertRecordsOfOneDevice("root.sg.d1", times, measurements, datatypes, values, true);
+ checkResult(session);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertOneDeviceRecordsWithIncorrectOrderTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ List<Long> times = new ArrayList<>();
+ List<List<String>> measurements = new ArrayList<>();
+ List<List<TSDataType>> datatypes = new ArrayList<>();
+ List<List<Object>> values = new ArrayList<>();
+
+ addLine(
+ times,
+ measurements,
+ datatypes,
+ values,
+ 2L,
+ "s2",
+ "s3",
+ TSDataType.INT32,
+ TSDataType.INT64,
+ 3,
+ 4L);
+ addLine(
+ times,
+ measurements,
+ datatypes,
+ values,
+ 3L,
+ "s1",
+ "s2",
+ TSDataType.INT32,
+ TSDataType.INT32,
+ 1,
+ 2);
+ addLine(
+ times,
+ measurements,
+ datatypes,
+ values,
+ 1L,
+ "s4",
+ "s5",
+ TSDataType.FLOAT,
+ TSDataType.BOOLEAN,
+ 5.0f,
+ Boolean.TRUE);
+
+ session.insertRecordsOfOneDevice("root.sg.d1", times, measurements, datatypes, values, true);
+ checkResult(session);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertStringRecordsOfOneDeviceWithOrderTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ List<Long> times = new ArrayList<>();
+ List<List<String>> measurements = new ArrayList<>();
+ List<List<String>> values = new ArrayList<>();
+
+ addStringLine(times, measurements, values, 1L, "s4", "s5", "5.0", "true");
+ addStringLine(times, measurements, values, 2L, "s2", "s3", "3", "4");
+ addStringLine(times, measurements, values, 3L, "s1", "s2", "false", "6");
+
+ session.insertStringRecordsOfOneDevice("root.sg.d1", times, measurements, values, true);
+ checkResultForInsertStringRecordsOfOneDevice(session);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ private void checkResultForInsertStringRecordsOfOneDevice(ISession session)
+ throws StatementExecutionException, IoTDBConnectionException {
+ SessionDataSet dataSet = session.executeQueryStatement("select * from root.sg.d1");
+ dataSet.getColumnNames();
+ assertArrayEquals(
+ dataSet.getColumnNames().toArray(new String[0]),
+ new String[] {
+ "Time",
+ "root.sg.d1.s3",
+ "root.sg.d1.s4",
+ "root.sg.d1.s5",
+ "root.sg.d1.s1",
+ "root.sg.d1.s2"
+ });
+ assertArrayEquals(
+ dataSet.getColumnTypes().toArray(new String[0]),
+ new String[] {
+ String.valueOf(TSDataType.INT64),
+ String.valueOf(TSDataType.FLOAT),
+ String.valueOf(TSDataType.FLOAT),
+ String.valueOf(TSDataType.BOOLEAN),
+ String.valueOf(TSDataType.BOOLEAN),
+ String.valueOf(TSDataType.FLOAT)
+ });
+ long time = 1L;
+
+ assertTrue(dataSet.hasNext());
+ RowRecord record = dataSet.next();
+ assertEquals(time, record.getTimestamp());
+ time++;
+
+ assertNulls(record, new int[] {0, 3, 4});
+ assertEquals(5.0f, record.getFields().get(1).getFloatV(), 0.01);
+ assertEquals(Boolean.TRUE, record.getFields().get(2).getBoolV());
+
+ assertTrue(dataSet.hasNext());
+ record = dataSet.next();
+ assertEquals(time, record.getTimestamp());
+ time++;
+
+ assertNulls(record, new int[] {1, 2, 3});
+ assertEquals(4, record.getFields().get(0).getFloatV(), 0.01);
+ assertEquals(3, record.getFields().get(4).getFloatV(), 0.01);
+
+ assertTrue(dataSet.hasNext());
+ record = dataSet.next();
+ assertEquals(time, record.getTimestamp());
+
+ assertNulls(record, new int[] {0, 1, 2});
+ assertFalse(record.getFields().get(3).getBoolV());
+ assertEquals(6, record.getFields().get(4).getFloatV(), 0.01);
+
+ assertFalse(dataSet.hasNext());
+ dataSet.closeOperationHandle();
+ }
+
+ private void addStringLine(
+ List<Long> times,
+ List<List<String>> measurements,
+ List<List<String>> values,
+ long time,
+ String s1,
+ String s2,
+ String value1,
+ String value2) {
+ List<String> tmpMeasurements = new ArrayList<>();
+ List<String> tmpValues = new ArrayList<>();
+ tmpMeasurements.add(s1);
+ tmpMeasurements.add(s2);
+ tmpValues.add(value1);
+ tmpValues.add(value2);
+ times.add(time);
+ measurements.add(tmpMeasurements);
+ values.add(tmpValues);
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertStringRecordsOfOneDeviceWithIncorrectOrderTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ List<Long> times = new ArrayList<>();
+ List<List<String>> measurements = new ArrayList<>();
+ List<List<String>> values = new ArrayList<>();
+
+ addStringLine(times, measurements, values, 2L, "s2", "s3", "3", "4");
+ addStringLine(times, measurements, values, 1L, "s4", "s5", "5.0", "true");
+ addStringLine(times, measurements, values, 3L, "s1", "s2", "false", "6");
+
+ session.insertStringRecordsOfOneDevice("root.sg.d1", times, measurements, values);
+ checkResultForInsertStringRecordsOfOneDevice(session);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertAlignedStringRecordsOfOneDeviceWithOrderTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ List<Long> times = new ArrayList<>();
+ List<List<String>> measurements = new ArrayList<>();
+ List<List<String>> values = new ArrayList<>();
+
+ addStringLine(times, measurements, values, 1L, "s4", "s5", "5.0", "true");
+ addStringLine(times, measurements, values, 2L, "s2", "s3", "3", "4");
+ addStringLine(times, measurements, values, 3L, "s1", "s2", "false", "6");
+
+ session.insertAlignedStringRecordsOfOneDevice(
+ "root.sg.d1", times, measurements, values, true);
+ checkResultForInsertStringRecordsOfOneDevice(session);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertAlignedStringRecordsOfOneDeviceWithIncorrectOrderTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ List<Long> times = new ArrayList<>();
+ List<List<String>> measurements = new ArrayList<>();
+ List<List<String>> values = new ArrayList<>();
+
+ addStringLine(times, measurements, values, 2L, "s2", "s3", "3", "4");
+ addStringLine(times, measurements, values, 1L, "s4", "s5", "5.0", "true");
+ addStringLine(times, measurements, values, 3L, "s1", "s2", "false", "6");
+
+ session.insertAlignedStringRecordsOfOneDevice("root.sg.d1", times, measurements, values);
+ checkResultForInsertStringRecordsOfOneDevice(session);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertIlligalPathTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ String msg = "[%s] Exception occurred: %s failed. %s is not a legal path";
+ String deviceId = "root.sg..d1";
+ List<String> deviceIds = Arrays.asList("root.sg..d1", "root.sg.d2");
+ List<Long> timestamps = Arrays.asList(1L, 1L);
+ List<String> measurements = Arrays.asList("s1", "s2", "s3");
+ List<List<String>> allMeasurements = Arrays.asList(measurements, measurements);
+ List<TSDataType> tsDataTypes =
+ Arrays.asList(TSDataType.INT32, TSDataType.FLOAT, TSDataType.TEXT);
+ List<List<TSDataType>> allTsDataTypes = Arrays.asList(tsDataTypes, tsDataTypes);
+ List<TSEncoding> tsEncodings =
+ Arrays.asList(TSEncoding.PLAIN, TSEncoding.PLAIN, TSEncoding.PLAIN);
+ List<CompressionType> compressionTypes =
+ Arrays.asList(CompressionType.SNAPPY, CompressionType.SNAPPY, CompressionType.SNAPPY);
+ List<Object> values = Arrays.asList(1, 2f, "3");
+ List<List<Object>> allValues = Arrays.asList(values, values);
+ List<String> stringValues = Arrays.asList("1", "2", "3");
+ List<List<String>> allstringValues = Arrays.asList(stringValues, stringValues);
+
+ try {
+ session.insertRecords(deviceIds, timestamps, allMeasurements, allTsDataTypes, allValues);
+ fail("Exception expected");
+ } catch (StatementExecutionException e) {
+ assertTrue(
+ e.getMessage()
+ .contains(
+ String.format(
+ msg, TSStatusCode.PATH_ILLEGAL, OperationType.INSERT_RECORDS, deviceId)));
+ }
+
+ try {
+ session.insertRecords(deviceIds, Arrays.asList(2L, 2L), allMeasurements, allstringValues);
+ fail("Exception expected");
+ } catch (StatementExecutionException e) {
+ assertTrue(
+ e.getMessage()
+ .contains(
+ String.format(
+ msg,
+ TSStatusCode.PATH_ILLEGAL,
+ OperationType.INSERT_STRING_RECORDS,
+ deviceIds.get(0))));
+ }
+
+ try {
+ session.insertRecord(deviceId, 3L, measurements, tsDataTypes, values);
+ fail("Exception expected");
+ } catch (StatementExecutionException e) {
+ assertTrue(
+ e.getMessage()
+ .contains(
+ String.format(
+ msg, TSStatusCode.PATH_ILLEGAL, OperationType.INSERT_RECORD, deviceId)));
+ }
+
+ try {
+ session.insertRecord(deviceId, 4L, measurements, stringValues);
+ fail("Exception expected");
+ } catch (StatementExecutionException e) {
+ assertTrue(
+ e.getMessage()
+ .contains(
+ String.format(
+ msg,
+ TSStatusCode.PATH_ILLEGAL,
+ OperationType.INSERT_STRING_RECORD,
+ deviceId)));
+ }
+
+ try {
+ session.insertRecordsOfOneDevice(
+ deviceId, Arrays.asList(5L, 6L), allMeasurements, allTsDataTypes, allValues);
+ fail("Exception expected");
+ } catch (StatementExecutionException e) {
+ assertTrue(
+ e.getMessage()
+ .contains(
+ String.format(
+ msg,
+ TSStatusCode.PATH_ILLEGAL,
+ OperationType.INSERT_RECORDS_OF_ONE_DEVICE,
+ deviceId)));
+ }
+
+ try {
+ session.deleteData(deviceId + ".s1", 6L);
+ fail("Exception expected");
+ } catch (StatementExecutionException e) {
+ assertTrue(
+ e.getMessage()
+ .contains(
+ String.format(
+ msg,
+ TSStatusCode.PATH_ILLEGAL,
+ OperationType.DELETE_DATA,
+ deviceId + ".s1")));
+ }
+
+ try {
+ Tablet tablet =
+ new Tablet(
+ deviceId,
+ Arrays.asList(
+ new MeasurementSchema("s1", TSDataType.INT32),
+ new MeasurementSchema("s2", TSDataType.FLOAT)),
+ 5);
+ long ts = 7L;
+ for (long row = 0; row < 8; row++) {
+ int rowIndex = tablet.rowSize++;
+ tablet.addTimestamp(rowIndex, ts);
+ tablet.addValue("s1", rowIndex, 1);
+ tablet.addValue("s2", rowIndex, 1.0F);
+ if (tablet.rowSize == tablet.getMaxRowNumber()) {
+ session.insertTablet(tablet, true);
+ tablet.reset();
+ }
+ ts++;
+ }
+ fail("Exception expected");
+ } catch (StatementExecutionException e) {
+ assertTrue(
+ e.getMessage()
+ .contains(
+ String.format(
+ msg, TSStatusCode.PATH_ILLEGAL, OperationType.INSERT_TABLET, deviceId)));
+ }
+
+ try {
+ Tablet tablet1 =
+ new Tablet(
+ deviceId,
+ Arrays.asList(
+ new MeasurementSchema("s1", TSDataType.INT32),
+ new MeasurementSchema("s2", TSDataType.FLOAT)),
+ 5);
+ Tablet tablet2 =
+ new Tablet(
+ "root.sg.d2",
+ Arrays.asList(
+ new MeasurementSchema("s1", TSDataType.INT32),
+ new MeasurementSchema("s2", TSDataType.FLOAT)),
+ 5);
+ HashMap<String, Tablet> tablets = new HashMap<>();
+ tablets.put(deviceId, tablet1);
+ tablets.put("root.sg.d2", tablet2);
+ long ts = 16L;
+ for (long row = 0; row < 8; row++) {
+ int row1 = tablet1.rowSize++;
+ int row2 = tablet2.rowSize++;
+ tablet1.addTimestamp(row1, ts);
+ tablet2.addTimestamp(row2, ts);
+ tablet1.addValue("s1", row1, 1);
+ tablet1.addValue("s2", row1, 1.0F);
+ tablet2.addValue("s1", row2, 1);
+ tablet2.addValue("s2", row2, 1.0F);
+ if (tablet1.rowSize == tablet1.getMaxRowNumber()) {
+ session.insertTablets(tablets, true);
+ tablet1.reset();
+ tablet2.reset();
+ }
+ ts++;
+ }
+ fail("Exception expected");
+ } catch (StatementExecutionException e) {
+ assertTrue(
+ e.getMessage()
+ .contains(
+ String.format(
+ msg, TSStatusCode.PATH_ILLEGAL, OperationType.INSERT_TABLETS, deviceId)));
+ }
+
+ try {
+ session.setStorageGroup("root..sg");
+ fail("Exception expected");
+ } catch (StatementExecutionException e) {
+ assertTrue(
+ e.getMessage()
+ .contains(
+ String.format(
+ msg,
+ TSStatusCode.PATH_ILLEGAL,
+ OperationType.SET_STORAGE_GROUP,
+ "root..sg")));
+ }
+
+ try {
+ session.createTimeseries(
+ "root.sg..d1.s1", TSDataType.INT32, TSEncoding.PLAIN, CompressionType.SNAPPY);
+ fail("Exception expected");
+ } catch (StatementExecutionException e) {
+ assertTrue(
+ e.getMessage()
+ .contains(
+ String.format(
+ msg,
+ TSStatusCode.PATH_ILLEGAL,
+ OperationType.CREATE_TIMESERIES,
+ "root.sg..d1.s1")));
+ }
+
+ try {
+ session.createAlignedTimeseries(
+ deviceId,
+ measurements,
+ tsDataTypes,
+ tsEncodings,
+ compressionTypes,
+ Arrays.asList("alias1", "alias2", "alias3"),
+ null,
+ null);
+
+ fail("Exception expected");
+ } catch (StatementExecutionException e) {
+ assertTrue(
+ e.getMessage()
+ .contains(
+ String.format(
+ msg,
+ TSStatusCode.PATH_ILLEGAL,
+ OperationType.CREATE_ALIGNED_TIMESERIES,
+ deviceId)));
+ }
+
+ try {
+ session.createMultiTimeseries(
+ Arrays.asList("root.sg.d1..s1", "root.sg.d1.s2", "root.sg.d1.s3"),
+ tsDataTypes,
+ tsEncodings,
+ compressionTypes,
+ null,
+ null,
+ null,
+ null);
+ fail("Exception expected");
+ } catch (StatementExecutionException e) {
+ assertTrue(
+ e.getMessage()
+ .contains(
+ String.format(
+ msg,
+ TSStatusCode.PATH_ILLEGAL,
+ OperationType.CREATE_MULTI_TIMESERIES,
+ "root.sg.d1..s1")));
+ }
+
+ try {
+ session.deleteTimeseries("root.sg.d1..s1");
+ fail("Exception expected");
+ } catch (StatementExecutionException e) {
+ assertTrue(
+ e.getMessage()
+ .contains(
+ String.format(
+ msg,
+ TSStatusCode.PATH_ILLEGAL,
+ OperationType.DELETE_TIMESERIES,
+ "root.sg.d1..s1")));
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void conversionFunctionTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ // prepare data
+ String deviceId = "root.sg.d1";
+ List<Long> times = new ArrayList<>();
+ List<List<String>> measurementsList = new ArrayList<>();
+ List<List<TSDataType>> typesList = new ArrayList<>();
+ List<List<Object>> valuesList = new ArrayList<>();
+
+ for (int i = 0; i <= 4; i++) {
+ times.add((long) i * 2);
+ measurementsList.add(Arrays.asList("s1", "s2", "s3", "s4", "s5", "s6"));
+ typesList.add(
+ Arrays.asList(
+ TSDataType.INT32,
+ TSDataType.INT64,
+ TSDataType.FLOAT,
+ TSDataType.DOUBLE,
+ TSDataType.BOOLEAN,
+ TSDataType.TEXT));
+ valuesList.add(
+ Arrays.asList(
+ i,
+ (long) i + 1,
+ (float) i,
+ (double) i * 2,
+ new boolean[] {true, false}[i % 2],
+ String.valueOf(i)));
+ }
+ // insert data
+ session.insertRecordsOfOneDevice(deviceId, times, measurementsList, typesList, valuesList);
+
+ // excepted
+ String[] targetTypes = {"INT64", "INT32", "DOUBLE", "FLOAT", "TEXT", "BOOLEAN"};
+ String[] excepted = {
+ "0\t0\t1\t0.0\t0.0\ttrue\ttrue",
+ "2\t1\t2\t1.0\t2.0\tfalse\ttrue",
+ "4\t2\t3\t2.0\t4.0\ttrue\ttrue",
+ "6\t3\t4\t3.0\t6.0\tfalse\ttrue",
+ "8\t4\t5\t4.0\t8.0\ttrue\ttrue"
+ };
+
+ // query
+ String[] casts = new String[targetTypes.length];
+ StringBuffer buffer = new StringBuffer();
+ buffer.append("select ");
+ for (int i = 0; i < targetTypes.length; i++) {
+ casts[i] = String.format("cast(s%s, 'type'='%s')", i + 1, targetTypes[i]);
+ }
+ buffer.append(StringUtils.join(casts, ","));
+ buffer.append(" from root.sg.d1");
+ String sql = buffer.toString();
+ SessionDataSet sessionDataSet = session.executeQueryStatement(sql);
+
+ // compare types
+ List<String> columnTypes = sessionDataSet.getColumnTypes();
+ columnTypes.remove(0);
+ for (int i = 0; i < columnTypes.size(); i++) {
+ assertEquals(targetTypes[i], columnTypes.get(i));
+ }
+
+ // compare results
+ int index = 0;
+ while (sessionDataSet.hasNext()) {
+ RowRecord next = sessionDataSet.next();
+ assertEquals(excepted[index], next.toString());
+ index++;
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Ignore
+ public void insertDeleteWithTemplateTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ initTreeTemplate(session, "root.sg.loc1");
+ List<String> measurements = new ArrayList<>();
+ List<String> values = new ArrayList<>();
+ String deviceId = "root.sg.loc1.sector.GPS";
+ Set<String> checkSet = new HashSet<>();
+ SessionDataSet dataSet;
+
+ // insert record set using template
+ measurements.add("x");
+ measurements.add("y");
+ values.add("1.0");
+ values.add("2.0");
+
+ checkSet.add("root.sg.loc1.sector.GPS.x");
+ checkSet.add("root.sg.loc1.sector.GPS.y");
+ checkSet.add("root.sg.loc1.sector.y");
+ checkSet.add("root.sg.loc1.sector.x");
+ checkSet.add("root.sg.loc1.sector.vehicle.x");
+ checkSet.add("root.sg.loc1.sector.vehicle.y");
+ checkSet.add("root.sg.loc1.sector.vehicle.GPS.x");
+ checkSet.add("root.sg.loc1.sector.vehicle.GPS.y");
+
+ session.insertRecord(deviceId, 1L, measurements, values);
+ dataSet = session.executeQueryStatement("show timeseries");
+ while (dataSet.hasNext()) {
+ checkSet.remove(dataSet.next().getFields().get(0).toString());
+ }
+ assertTrue(checkSet.isEmpty());
+
+ // insert aligned under unaligned node
+ try {
+ session.insertAlignedRecord("root.sg.loc1.sector.GPS", 3L, measurements, values);
+ } catch (StatementExecutionException e) {
+ assertEquals(
+ "303: Timeseries under path [root.sg.loc1.sector.GPS] is not aligned , please set InsertPlan.isAligned() = false",
+ e.getMessage());
+ }
+
+ // insert overlap unmatched series
+ measurements.set(1, "speed");
+ try {
+ session.insertRecord(deviceId, 5L, measurements, values);
+ fail();
+ } catch (StatementExecutionException e) {
+ assertEquals(
+ "327: Path [root.sg.loc1.sector.GPS.speed] overlaps with [treeTemplate] on [GPS]",
+ e.getMessage());
+ }
+
+ // insert tablets
+ List<MeasurementSchema> schemaList = new ArrayList<>();
+ schemaList.add(new MeasurementSchema("x", TSDataType.FLOAT));
+ schemaList.add(new MeasurementSchema("y", TSDataType.FLOAT));
+ Tablet tablet = new Tablet("root.sg.loc1.sector", schemaList);
+
+ long timestamp = System.currentTimeMillis();
+
+ for (long row = 0; row < 10; row++) {
+ int rowIndex = tablet.rowSize++;
+ tablet.addTimestamp(rowIndex, timestamp);
+ tablet.addValue(
+ schemaList.get(0).getMeasurementId(), rowIndex, new SecureRandom().nextFloat());
+ tablet.addValue(
+ schemaList.get(1).getMeasurementId(), rowIndex, new SecureRandom().nextFloat());
+ timestamp++;
+ }
+
+ if (tablet.rowSize != 0) {
+ session.insertAlignedTablet(tablet);
+ tablet.reset();
+ }
+
+ dataSet = session.executeQueryStatement("select count(*) from root");
+
+ while (dataSet.hasNext()) {
+ RowRecord rowRecord = dataSet.next();
+ assertEquals(10L, rowRecord.getFields().get(0).getLongV());
+ assertEquals(10L, rowRecord.getFields().get(1).getLongV());
+ }
+
+ // delete series inside template
+ try {
+ session.deleteTimeseries("root.sg.loc1.sector.x");
+ fail();
+ } catch (StatementExecutionException e) {
+ assertTrue(
+ e.getMessage()
+ .contains("Cannot delete a timeseries inside a template: root.sg.loc1.sector.x;"));
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ private void initTreeTemplate(ISession session, String path)
+ throws IoTDBConnectionException, StatementExecutionException, IOException {
+ Template sessionTemplate = new Template("treeTemplate", true);
+ TemplateNode iNodeGPS = new InternalNode("GPS", false);
+ TemplateNode iNodeV = new InternalNode("vehicle", true);
+ TemplateNode mNodeX =
+ new MeasurementNode("x", TSDataType.FLOAT, TSEncoding.RLE, CompressionType.SNAPPY);
+ TemplateNode mNodeY =
+ new MeasurementNode("y", TSDataType.FLOAT, TSEncoding.RLE, CompressionType.SNAPPY);
+
+ iNodeGPS.addChild(mNodeX);
+ iNodeGPS.addChild(mNodeY);
+
+ iNodeV.addChild(mNodeX);
+ iNodeV.addChild(mNodeY);
+ iNodeV.addChild(iNodeGPS);
+
+ sessionTemplate.addToTemplate(iNodeGPS);
+ sessionTemplate.addToTemplate(iNodeV);
+ sessionTemplate.addToTemplate(mNodeX);
+ sessionTemplate.addToTemplate(mNodeY);
+
+ session.setStorageGroup(path);
+ session.createSchemaTemplate(sessionTemplate);
+ session.setSchemaTemplate("treeTemplate", path);
+ }
+
+ @Test
+ @Category({ClusterIT.class})
+ public void countWithTemplateTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ initTreeTemplate(session, "root.sg.loc");
+
+ List<String> measurements = new ArrayList<>();
+ List<String> values = new ArrayList<>();
+ Set<String> checkSet = new HashSet<>();
+ SessionDataSet dataSet;
+
+ // invoke template template
+
+ measurements.add("x");
+ measurements.add("y");
+ values.add("1.0");
+ values.add("2.0");
+
+ session.insertAlignedRecord("root.sg.loc.area", 1L, measurements, values);
+ session.insertAlignedRecord("root.sg.loc", 1L, measurements, values);
+
+ dataSet = session.executeQueryStatement("show timeseries");
+
+ checkSet.add("root.sg.loc.x");
+ checkSet.add("root.sg.loc.y");
+ checkSet.add("root.sg.loc.GPS.x");
+ checkSet.add("root.sg.loc.GPS.y");
+ checkSet.add("root.sg.loc.vehicle.GPS.x");
+ checkSet.add("root.sg.loc.vehicle.GPS.y");
+ checkSet.add("root.sg.loc.vehicle.x");
+ checkSet.add("root.sg.loc.vehicle.x");
+
+ checkSet.add("root.sg.loc.area.x");
+ checkSet.add("root.sg.loc.area.y");
+ checkSet.add("root.sg.loc.area.GPS.x");
+ checkSet.add("root.sg.loc.area.GPS.y");
+ checkSet.add("root.sg.loc.area.vehicle.GPS.x");
+ checkSet.add("root.sg.loc.area.vehicle.GPS.y");
+ checkSet.add("root.sg.loc.area.vehicle.x");
+ checkSet.add("root.sg.loc.area.vehicle.x");
+
+ while (dataSet.hasNext()) {
+ checkSet.remove(dataSet.next().getFields().get(0).toString());
+ }
+
+ assertTrue(checkSet.isEmpty());
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertPartialTablet2Test() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ if (!session.checkTimeseriesExists("root.sg.d.s1")) {
+ session.createTimeseries(
+ "root.sg.d.s1", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
+ }
+ if (!session.checkTimeseriesExists("root.sg.d.s2")) {
+ session.createTimeseries(
+ "root.sg.d.s2", TSDataType.DOUBLE, TSEncoding.GORILLA, CompressionType.SNAPPY);
+ }
+ if (!session.checkTimeseriesExists("root.sg.d.s3")) {
+ session.createTimeseries(
+ "root.sg.d.s3", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
+ }
+ List<MeasurementSchema> schemaList = new ArrayList<>();
+ schemaList.add(new MeasurementSchema("s1", TSDataType.INT64));
+ schemaList.add(new MeasurementSchema("s2", TSDataType.DOUBLE));
+ schemaList.add(new MeasurementSchema("s3", TSDataType.TEXT));
+
+ Tablet tablet = new Tablet("root.sg.d", schemaList, 10);
+
+ long timestamp = System.currentTimeMillis();
+
+ for (long row = 0; row < 15; row++) {
+ int rowIndex = tablet.rowSize++;
+ tablet.addTimestamp(rowIndex, timestamp);
+ tablet.addValue("s1", rowIndex, 1L);
+ tablet.addValue("s2", rowIndex, 1D);
+ tablet.addValue("s3", rowIndex, new Binary("1"));
+ if (tablet.rowSize == tablet.getMaxRowNumber()) {
+ try {
+ session.insertTablet(tablet, true);
+ } catch (StatementExecutionException e) {
+ assertTrue(e.getMessage().contains("insert measurements [s3] caused by"));
+ assertTrue(e.getMessage().contains("data type of root.sg.d.s3 is not consistent"));
+ }
+ tablet.reset();
+ }
+ timestamp++;
+ }
+
+ if (tablet.rowSize != 0) {
+ try {
+ session.insertTablet(tablet);
+ } catch (StatementExecutionException e) {
+ assertTrue(e.getMessage().contains("insert measurements [s3] caused by"));
+ assertTrue(e.getMessage().contains("data type of root.sg.d.s3 is not consistent"));
+ }
+ tablet.reset();
+ }
+
+ SessionDataSet dataSet =
+ session.executeQueryStatement("select count(s1), count(s2), count(s3) from root.sg.d");
+ while (dataSet.hasNext()) {
+ RowRecord rowRecord = dataSet.next();
+ assertEquals(15L, rowRecord.getFields().get(0).getLongV());
+ assertEquals(15L, rowRecord.getFields().get(1).getLongV());
+ assertEquals(0L, rowRecord.getFields().get(2).getLongV());
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ @Category({LocalStandaloneIT.class, ClusterIT.class})
+ public void insertBinaryAsTextTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ // prepare binary data
+ List<Object> bytesData = new ArrayList<>();
+ for (int i = 0; i < 3; i++) {
+ byte[] bytes = new byte[128];
+ for (int j = 0; j < 128; j++) {
+ bytes[j] = Byte.valueOf("" + (j - i), 10);
+ }
+ bytesData.add(bytes);
+ }
+ // insert data using insertRecord
+ for (int i = 0; i < bytesData.size(); i++) {
+ byte[] data = (byte[]) bytesData.get(i);
+ Binary dataBinary = new Binary(data);
+ session.insertRecord(
+ "root.sg1.d1",
+ i,
+ Collections.singletonList("s0"),
+ Collections.singletonList(TSDataType.TEXT),
+ dataBinary);
+ }
+ // insert data using insertTablet
+ List<MeasurementSchema> schemaList = new ArrayList<>();
+ schemaList.add(new MeasurementSchema("s1", TSDataType.TEXT));
+ Tablet tablet = new Tablet("root.sg1.d1", schemaList, 100);
+ for (int i = 0; i < bytesData.size(); i++) {
+ byte[] data = (byte[]) bytesData.get(i);
+ int rowIndex = tablet.rowSize++;
+ tablet.addTimestamp(rowIndex, i);
+ Binary dataBinary = new Binary(data);
+ tablet.addValue(schemaList.get(0).getMeasurementId(), rowIndex, dataBinary);
+ }
+ session.insertTablet(tablet);
+ // check result
+ SessionDataSet dataSet = session.executeQueryStatement("select ** from root.sg1.d1");
+ assertArrayEquals(
+ dataSet.getColumnNames().toArray(new String[0]),
+ new String[] {"Time", "root.sg1.d1.s0", "root.sg1.d1.s1"});
+ while (dataSet.hasNext()) {
+ RowRecord rowRecord = dataSet.next();
+ for (int i = 0; i < 2; i++) {
+ // get Binary value from SessionDataSet
+ byte[] actualBytes = rowRecord.getFields().get(i).getBinaryV().getValues();
+ // compare Binary value to origin bytesData
+ byte[] expectedBytes = (byte[]) bytesData.get((int) rowRecord.getTimestamp());
+ assertArrayEquals(expectedBytes, actualBytes);
+ }
+ }
+ dataSet.closeOperationHandle();
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+}
diff --git a/integration-test/src/test/java/org/apache/iotdb/session/IoTDBSessionSyntaxConventionIT.java b/integration-test/src/test/java/org/apache/iotdb/session/IoTDBSessionSyntaxConventionIT.java
new file mode 100644
index 0000000000..57f834b932
--- /dev/null
+++ b/integration-test/src/test/java/org/apache/iotdb/session/IoTDBSessionSyntaxConventionIT.java
@@ -0,0 +1,428 @@
+/*
+ * 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.session;
+
+import org.apache.iotdb.commons.conf.IoTDBConstant;
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.ClusterIT;
+import org.apache.iotdb.itbase.category.LocalStandaloneIT;
+import org.apache.iotdb.rpc.StatementExecutionException;
+import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
+import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
+import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
+import org.apache.iotdb.tsfile.utils.Binary;
+import org.apache.iotdb.tsfile.write.record.Tablet;
+import org.apache.iotdb.tsfile.write.schema.MeasurementSchema;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({LocalStandaloneIT.class, ClusterIT.class})
+public class IoTDBSessionSyntaxConventionIT {
+
+ @Before
+ public void setUp() throws Exception {
+ System.setProperty(IoTDBConstant.IOTDB_CONF, "src/test/resources/");
+ EnvFactory.getEnv().initBeforeTest();
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ EnvFactory.getEnv().cleanAfterTest();
+ }
+
+ @Test
+ public void createTimeSeriesTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ String storageGroup = "root.sg";
+ session.setStorageGroup(storageGroup);
+
+ try {
+ session.createTimeseries(
+ "root.sg.d1.`a.s1", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
+ fail();
+ } catch (Exception e) {
+ assertTrue(e.getMessage().contains("is not a legal path"));
+ }
+
+ try {
+ session.createTimeseries(
+ "root.sg.d1.a`.s1", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
+ fail();
+ } catch (Exception e) {
+ assertTrue(e.getMessage().contains("is not a legal path"));
+ }
+
+ final SessionDataSet dataSet = session.executeQueryStatement("SHOW TIMESERIES");
+ assertFalse(dataSet.hasNext());
+
+ session.deleteStorageGroup(storageGroup);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void insertTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ String deviceId = "root.sg1.d1";
+ List<String> measurements = new ArrayList<>();
+
+ measurements.add("`\"a“（Φ）”b\"`");
+ measurements.add("`\"a>b\"`");
+ measurements.add("```a.b```");
+ measurements.add("`'a“（Φ）”b'`");
+ measurements.add("`'a>b'`");
+ measurements.add("`a“（Φ）”b`");
+ measurements.add("`a>b`");
+ measurements.add("`\\\"a`");
+ List<String> values = new ArrayList<>();
+
+ for (int i = 0; i < measurements.size(); i++) {
+ values.add("1");
+ }
+
+ session.insertRecord(deviceId, 1L, measurements, values);
+
+ assertTrue(session.checkTimeseriesExists("root.sg1.d1.`\"a“（Φ）”b\"`"));
+ assertTrue(session.checkTimeseriesExists("root.sg1.d1.`\"a>b\"`"));
+ assertTrue(session.checkTimeseriesExists("root.sg1.d1.```a.b```"));
+ assertTrue(session.checkTimeseriesExists("root.sg1.d1.`'a“（Φ）”b'`"));
+ assertTrue(session.checkTimeseriesExists("root.sg1.d1.`'a>b'`"));
+ assertTrue(session.checkTimeseriesExists("root.sg1.d1.`a“（Φ）”b`"));
+ assertTrue(session.checkTimeseriesExists("root.sg1.d1.`a>b`"));
+ assertTrue(session.checkTimeseriesExists("root.sg1.d1.`\\\"a`"));
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void inserRecordWithIllegalMeasurementTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ String deviceId = "root.sg1.d1";
+ List<String> measurements = new ArrayList<>();
+ List<String> values = new ArrayList<>();
+ measurements.add("a.b");
+ values.add("1");
+ try {
+ session.insertRecord(deviceId, 1L, measurements, values);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ measurements.clear();
+ values.clear();
+ measurements.add("111");
+ values.add("1.2");
+ try {
+ session.insertRecord(deviceId, 1L, measurements, values);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ measurements.clear();
+ values.clear();
+ measurements.add("`a");
+ values.add("1.2");
+ try {
+ session.insertRecord(deviceId, 1L, measurements, values);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ measurements.clear();
+ values.clear();
+ measurements.add("a..b");
+ values.add("1.2");
+ try {
+ session.insertRecord(deviceId, 1L, measurements, values);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ measurements.clear();
+ values.clear();
+ measurements.add("");
+ values.add("1.2");
+ try {
+ session.insertRecord(deviceId, 1L, measurements, values);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ measurements.clear();
+ values.clear();
+ measurements.add("`a``");
+ values.add("1.2");
+ try {
+ session.insertRecord(deviceId, 1L, measurements, values);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ measurements.clear();
+ values.clear();
+ measurements.add("`ab````");
+ values.add("1.2");
+ try {
+ session.insertRecord(deviceId, 1L, measurements, values);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
+ assertFalse(dataSet.hasNext());
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void insertRecordsWithIllegalMeasurementTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ String deviceId = "root.sg1.d1";
+ List<String> measurements = new ArrayList<>();
+ measurements.add("a.b");
+ measurements.add("111");
+ measurements.add("`a");
+ measurements.add("a..b");
+
+ List<String> values = new ArrayList<>();
+ values.add("1");
+ values.add("1.2");
+ values.add("true");
+ values.add("dad");
+
+ List<Long> times = new ArrayList<>();
+ times.add(1L);
+ try {
+ session.insertRecords(
+ Collections.singletonList(deviceId),
+ times,
+ Collections.singletonList(measurements),
+ Collections.singletonList(values));
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
+ assertFalse(dataSet.hasNext());
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void insertTabletWithIllegalMeasurementTest() {
+ String deviceId = "root.sg1.d1";
+ List<MeasurementSchema> schemaList = new ArrayList<>();
+ schemaList.add(new MeasurementSchema("wrong`", TSDataType.INT64, TSEncoding.RLE));
+ schemaList.add(new MeasurementSchema("s2", TSDataType.DOUBLE, TSEncoding.RLE));
+ schemaList.add(new MeasurementSchema("s3", TSDataType.TEXT, TSEncoding.PLAIN));
+ schemaList.add(new MeasurementSchema("s4", TSDataType.INT64, TSEncoding.PLAIN));
+
+ Tablet tablet = new Tablet(deviceId, schemaList, 10);
+
+ long[] timestamps = tablet.timestamps;
+ Object[] values = tablet.values;
+
+ for (long time = 0; time < 10; time++) {
+ int row = tablet.rowSize++;
+ timestamps[row] = time;
+ long[] sensor = (long[]) values[0];
+ sensor[row] = time;
+ double[] sensor2 = (double[]) values[1];
+ sensor2[row] = 0.1 + time;
+ Binary[] sensor3 = (Binary[]) values[2];
+ sensor3[row] = Binary.valueOf("ha" + time);
+ long[] sensor4 = (long[]) values[3];
+ sensor4[row] = time;
+ }
+
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ try {
+ session.insertTablet(tablet);
+ fail();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
+ assertFalse(dataSet.hasNext());
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void createAlignedTimeseriesWithIllegalMeasurementTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ String deviceId = "root.sg1.d1";
+ List<String> measurements = new ArrayList<>();
+ measurements.add("111");
+ measurements.add("a.b");
+ List<TSDataType> dataTypes = new ArrayList<>();
+ dataTypes.add(TSDataType.INT64);
+ dataTypes.add(TSDataType.INT64);
+ List<TSEncoding> encodings = new ArrayList<>();
+ List<CompressionType> compressors = new ArrayList<>();
+ for (int i = 1; i <= 2; i++) {
+ encodings.add(TSEncoding.RLE);
+ compressors.add(CompressionType.SNAPPY);
+ }
+ try {
+ session.createAlignedTimeseries(
+ deviceId, measurements, dataTypes, encodings, compressors, null, null, null);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
+ assertFalse(dataSet.hasNext());
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void createAlignedTimeseriesWithIllegalMeasurementAliasTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ String deviceId = "root.sg1.d1";
+ List<String> measurements = new ArrayList<>();
+ measurements.add("s1");
+ measurements.add("s2");
+ List<String> measurementAliasList = new ArrayList<>();
+ measurementAliasList.add("s3");
+ measurementAliasList.add("111");
+ List<TSDataType> dataTypes = new ArrayList<>();
+ dataTypes.add(TSDataType.INT64);
+ dataTypes.add(TSDataType.INT64);
+ List<TSEncoding> encodings = new ArrayList<>();
+ List<CompressionType> compressors = new ArrayList<>();
+ for (int i = 1; i <= 2; i++) {
+ encodings.add(TSEncoding.RLE);
+ compressors.add(CompressionType.SNAPPY);
+ }
+ try {
+ session.createAlignedTimeseries(
+ deviceId,
+ measurements,
+ dataTypes,
+ encodings,
+ compressors,
+ measurementAliasList,
+ null,
+ null);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
+ assertFalse(dataSet.hasNext());
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void createMultiTimeseriesWithIllegalMeasurementAliasTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ List<String> paths = new ArrayList<>();
+ paths.add("root.sg1.d1.s1");
+ paths.add("root.sg1.d1.s2");
+ List<TSDataType> tsDataTypes = new ArrayList<>();
+ tsDataTypes.add(TSDataType.DOUBLE);
+ tsDataTypes.add(TSDataType.DOUBLE);
+ List<TSEncoding> tsEncodings = new ArrayList<>();
+ tsEncodings.add(TSEncoding.RLE);
+ tsEncodings.add(TSEncoding.RLE);
+ List<CompressionType> compressionTypes = new ArrayList<>();
+ compressionTypes.add(CompressionType.SNAPPY);
+ compressionTypes.add(CompressionType.SNAPPY);
+ List<String> measurementAliasList = new ArrayList<>();
+ measurementAliasList.add("s3");
+ measurementAliasList.add("111");
+
+ try {
+ session.createMultiTimeseries(
+ paths,
+ tsDataTypes,
+ tsEncodings,
+ compressionTypes,
+ null,
+ null,
+ null,
+ measurementAliasList);
+ } catch (StatementExecutionException e) {
+ e.printStackTrace();
+ }
+ SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
+ assertFalse(dataSet.hasNext());
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+
+ @Test
+ public void createSchemaTemplateWithIllegalMeasurementTest() {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ String tempName = "flatTemplate";
+ List<String> measurements = Arrays.asList("1", "2", "a.b");
+ List<TSDataType> dataTypes =
+ Arrays.asList(TSDataType.FLOAT, TSDataType.FLOAT, TSDataType.DOUBLE);
+ List<TSEncoding> encodings =
+ Arrays.asList(TSEncoding.RLE, TSEncoding.RLE, TSEncoding.GORILLA);
+ List<CompressionType> compressors =
+ Arrays.asList(CompressionType.SNAPPY, CompressionType.SNAPPY, CompressionType.LZ4);
+
+ try {
+ session.createSchemaTemplate(
+ tempName, measurements, dataTypes, encodings, compressors, true);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
+ assertFalse(dataSet.hasNext());
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail(e.getMessage());
+ }
+ }
+}
diff --git a/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionComplexIT.java b/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionComplexIT.java
deleted file mode 100644
index 114508878a..0000000000
--- a/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionComplexIT.java
+++ /dev/null
@@ -1,929 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.iotdb.session;
-
-import org.apache.iotdb.commons.conf.IoTDBConstant;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
-import org.apache.iotdb.db.engine.trigger.example.Counter;
-import org.apache.iotdb.db.engine.trigger.service.TriggerRegistrationService;
-import org.apache.iotdb.db.exception.TriggerManagementException;
-import org.apache.iotdb.db.utils.EnvironmentUtils;
-import org.apache.iotdb.db.wal.utils.WALMode;
-import org.apache.iotdb.itbase.category.LocalStandaloneTest;
-import org.apache.iotdb.jdbc.Config;
-import org.apache.iotdb.rpc.IoTDBConnectionException;
-import org.apache.iotdb.rpc.StatementExecutionException;
-import org.apache.iotdb.rpc.TSStatusCode;
-import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
-import org.apache.iotdb.tsfile.read.common.Field;
-import org.apache.iotdb.tsfile.write.record.Tablet;
-import org.apache.iotdb.tsfile.write.schema.MeasurementSchema;
-
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
-
-import java.io.File;
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.ResultSet;
-import java.sql.ResultSetMetaData;
-import java.sql.SQLException;
-import java.sql.Statement;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-@Category({LocalStandaloneTest.class})
-public class IoTDBSessionComplexIT {
-
- private Session session;
-
- @Before
- public void setUp() {
- System.setProperty(IoTDBConstant.IOTDB_CONF, "src/test/resources/");
- EnvironmentUtils.envSetUp();
- }
-
- @After
- public void tearDown() throws Exception {
- session.close();
- EnvironmentUtils.cleanEnv();
- }
-
- @Test
- public void testInsertByStr() throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- session.setStorageGroup("root.sg1");
-
- createTimeseries();
- insertByStr();
-
- insertViaSQL();
- queryByDevice("root.sg1.d1");
-
- session.close();
- }
-
- private void insertByStr() throws IoTDBConnectionException, StatementExecutionException {
- String deviceId = "root.sg1.d1";
- List<String> measurements = new ArrayList<>();
- measurements.add("s1");
- measurements.add("s2");
- measurements.add("s3");
-
- for (long time = 0; time < 100; time++) {
- List<String> values = new ArrayList<>();
- values.add("1");
- values.add("2");
- values.add("3");
- session.insertRecord(deviceId, time, measurements, values);
- }
- }
-
- @Test
- public void testInsertByObject() throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- session.setStorageGroup("root.sg1");
-
- createTimeseries();
-
- String deviceId = "root.sg1.d1";
- List<String> measurements = new ArrayList<>();
- List<TSDataType> types = new ArrayList<>();
- measurements.add("s1");
- measurements.add("s2");
- measurements.add("s3");
- types.add(TSDataType.INT64);
- types.add(TSDataType.INT64);
- types.add(TSDataType.INT64);
-
- for (long time = 0; time < 100; time++) {
- session.insertRecord(deviceId, time, measurements, types, 1L, 2L, 3L);
- }
-
- insertViaSQL();
- queryByDevice("root.sg1.d1");
-
- session.close();
- }
-
- @Test
- public void testAlignByDevice() throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- session.setStorageGroup("root.sg1");
-
- createTimeseries();
-
- insertTablet("root.sg1.d1");
-
- SessionDataSet sessionDataSet =
- session.executeQueryStatement("select s1 from root.sg1.d1 align by device");
- sessionDataSet.setFetchSize(1024);
- int count = 0;
- while (sessionDataSet.hasNext()) {
- count++;
- StringBuilder sb = new StringBuilder();
- List<Field> fields = sessionDataSet.next().getFields();
- for (Field f : fields) {
- sb.append(f.getStringValue()).append(",");
- }
- Assert.assertEquals("root.sg1.d1,0,", sb.toString());
- }
- Assert.assertEquals(100, count);
- sessionDataSet.closeOperationHandle();
-
- session.close();
- }
-
- @Test
- public void testBatchInsertSeqAndUnseq()
- throws SQLException, ClassNotFoundException, IoTDBConnectionException,
- StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- session.setStorageGroup("root.sg1");
-
- createTimeseries();
-
- insertTablet("root.sg1.d1");
-
- session.executeNonQueryStatement("FLUSH");
- session.executeNonQueryStatement("FLUSH root.sg1");
- session.executeNonQueryStatement("MERGE");
- session.executeNonQueryStatement("FULL MERGE");
-
- queryForBatch();
-
- session.close();
- }
-
- @Test
- public void testBatchInsert()
- throws StatementExecutionException, SQLException, ClassNotFoundException,
- IoTDBConnectionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- session.setStorageGroup("root.sg1");
-
- createTimeseries();
-
- insertTablet("root.sg1.d1");
-
- queryForBatch();
-
- session.close();
- }
-
- @Test
- public void testTestMethod() throws StatementExecutionException, IoTDBConnectionException {
-
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- session.setStorageGroup("root.sg1");
- String deviceId = "root.sg1.d1";
-
- createTimeseries();
-
- List<MeasurementSchema> schemaList = new ArrayList<>();
- schemaList.add(new MeasurementSchema("s1", TSDataType.INT64, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s2", TSDataType.INT64, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s3", TSDataType.INT64, TSEncoding.RLE));
-
- Tablet tablet = new Tablet("root.sg1.d1", schemaList, 100);
-
- session.testInsertTablet(tablet);
-
- List<String> measurements = new ArrayList<>();
- measurements.add("s1");
- measurements.add("s2");
- measurements.add("s3");
- for (long time = 0; time < 100; time++) {
- List<String> values = new ArrayList<>();
- values.add("1");
- values.add("2");
- values.add("3");
- session.testInsertRecord(deviceId, time, measurements, values);
- }
-
- measurements = new ArrayList<>();
- measurements.add("s1");
- measurements.add("s2");
- measurements.add("s3");
- List<String> deviceIds = new ArrayList<>();
- List<List<String>> measurementsList = new ArrayList<>();
- List<List<String>> valuesList = new ArrayList<>();
- List<Long> timestamps = new ArrayList<>();
-
- for (long time = 0; time < 500; time++) {
- List<String> values = new ArrayList<>();
- values.add("1");
- values.add("2");
- values.add("3");
-
- deviceIds.add(deviceId);
- measurementsList.add(measurements);
- valuesList.add(values);
- timestamps.add(time);
- if (time != 0 && time % 100 == 0) {
- session.testInsertRecords(deviceIds, timestamps, measurementsList, valuesList);
- deviceIds.clear();
- measurementsList.clear();
- valuesList.clear();
- timestamps.clear();
- }
- }
-
- session.testInsertRecords(deviceIds, timestamps, measurementsList, valuesList);
-
- SessionDataSet dataSet = session.executeQueryStatement("show timeseries root.sg1.**");
- int count = 0;
- while (dataSet.hasNext()) {
- count++;
- }
- Assert.assertEquals(6, count);
- session.close();
- }
-
- @Test
- public void testRawDataQuery() throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- session.setStorageGroup("root.sg1");
-
- createTimeseries();
-
- insertRecords();
-
- rawDataQuery();
- }
-
- @Test
- public void testLastDataQuery() throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- session.setStorageGroup("root.sg1");
-
- createTimeseries();
-
- insertRecords();
-
- lastDataQuery();
- }
-
- @Test
- public void test()
- throws ClassNotFoundException, SQLException, IoTDBConnectionException,
- StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- try {
- session.open();
- } catch (IoTDBConnectionException e) {
- e.printStackTrace();
- }
- List<String> standard =
- Arrays.asList(
- "Time",
- "root.sg1.d1.s1",
- "root.sg1.d1.s2",
- "root.sg1.d1.s3",
- "root.sg1.d2.s1",
- "root.sg1.d2.s2",
- "root.sg1.d2.s3");
- List<String> standardAfterDelete =
- Arrays.asList(
- "Time",
- "root.sg1.d1.s2",
- "root.sg1.d1.s3",
- "root.sg1.d2.s1",
- "root.sg1.d2.s2",
- "root.sg1.d2.s3");
-
- session.setStorageGroup("root.sg1");
-
- createTimeseries();
-
- String deviceId1 = "root.sg1.d1";
- List<String> measurements1 = new ArrayList<>();
- List<TSDataType> types = new ArrayList<>();
- measurements1.add("s1");
- measurements1.add("s2");
- measurements1.add("s3");
- types.add(TSDataType.INT64);
- types.add(TSDataType.INT64);
- types.add(TSDataType.INT64);
-
- for (long time = 0; time < 100; time++) {
- List<Object> values = new ArrayList<>();
- values.add(1L);
- values.add(2L);
- values.add(3L);
- session.insertRecord(deviceId1, time, measurements1, types, values);
- }
-
- insertViaSQL();
-
- queryByDevice("root.sg1.d1");
-
- deleteData();
-
- insertByStr();
-
- insertViaSQL();
-
- queryByDevice("root.sg1.d1");
-
- deleteData();
-
- queryAll(standard);
-
- deleteTimeseries();
-
- queryAll(standardAfterDelete);
-
- insertRecords();
-
- queryByDevice("root.sg1.d2");
-
- deleteData();
-
- String deviceId2 = "root.sg1.d2";
- List<String> measurements2 = new ArrayList<>();
- measurements2.add("s1");
- measurements2.add("s2");
- measurements2.add("s3");
- List<String> deviceIds2 = new ArrayList<>();
- List<List<String>> measurementsList2 = new ArrayList<>();
- List<List<String>> valuesList = new ArrayList<>();
- List<Long> timestamps = new ArrayList<>();
-
- for (long time = 0; time < 500; time++) {
- List<String> values = new ArrayList<>();
- values.add("1");
- values.add("2");
- values.add("3");
-
- deviceIds2.add(deviceId2);
- measurementsList2.add(measurements2);
- valuesList.add(values);
- timestamps.add(time);
- if (time != 0 && time % 100 == 0) {
- session.insertRecords(deviceIds2, timestamps, measurementsList2, valuesList);
- deviceIds2.clear();
- measurementsList2.clear();
- valuesList.clear();
- timestamps.clear();
- }
- }
-
- session.insertRecords(deviceIds2, timestamps, measurementsList2, valuesList);
-
- queryByDevice("root.sg1.d2");
-
- session.createTimeseries(
- "root.sg1.d1.1_2", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg1.d1.`1+2+3`", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg1.d1.`1+2+4`", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
-
- Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.1_2"));
- Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.`1+2+3`"));
- Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.`1+2+4`"));
-
- session.setStorageGroup("root.`1`");
- session.createTimeseries(
- "root.`1`.`2`.`3`", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- session.setStorageGroup("root.sg2");
- session.createTimeseries(
- "root.sg2.d1.s1", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
-
- deleteStorageGroupTest();
-
- session.setStorageGroup("root.sg3");
- insertTablet("root.sg3.d1");
-
- session.createTimeseries(
- "root.sg4.d1.s1", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg4.d1.s2", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg4.d1.s3", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- insertTablet("root.sg4.d1");
-
- insertTablet("root.sg5.d1");
-
- SessionDataSet dataSet = session.executeQueryStatement("select * from root.** group by device");
- int count = 0;
- while (dataSet.hasNext()) {
- count++;
- }
- Assert.assertEquals(300, count);
-
- session.close();
- }
-
- @Test
- public void TestSessionInterfacesWithDisabledWAL()
- throws StatementExecutionException, IoTDBConnectionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- try {
- session.open();
- } catch (IoTDBConnectionException e) {
- e.printStackTrace();
- }
-
- session.setStorageGroup("root.sg1");
- String deviceId = "root.sg1.d1";
-
- WALMode prevWalMode = IoTDBDescriptor.getInstance().getConfig().getWalMode();
- IoTDBDescriptor.getInstance().getConfig().setWalMode(WALMode.DISABLE);
- createTimeseries();
-
- List<String> measurements = new ArrayList<>();
- List<TSDataType> types = new ArrayList<>();
- measurements.add("s1");
- measurements.add("s2");
- measurements.add("s3");
- types.add(TSDataType.INT64);
- types.add(TSDataType.INT64);
- types.add(TSDataType.INT64);
- for (long time = 0; time < 100; time++) {
- List<Object> values = new ArrayList<>();
- values.add(1L);
- values.add(2L);
- values.add(3L);
- session.insertRecord(deviceId, time, measurements, types, values);
- }
-
- List<MeasurementSchema> schemaList = new ArrayList<>();
- schemaList.add(new MeasurementSchema("s1", TSDataType.INT64, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s2", TSDataType.INT64, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s3", TSDataType.INT64, TSEncoding.RLE));
-
- Tablet tablet = new Tablet(deviceId, schemaList, 200);
- long[] timestamps = tablet.timestamps;
- Object[] values = tablet.values;
- for (int time = 1; time <= 100; time++) {
- timestamps[time - 1] = time;
- for (int i = 0; i < 3; i++) {
- long[] sensor = (long[]) values[i];
- sensor[time - 1] = i;
- }
- tablet.rowSize++;
- }
-
- for (int time = 101; time <= 200; time++) {
- int rowIndex = time - 1;
- tablet.addTimestamp(rowIndex, time);
- long value = 0;
- for (int s = 0; s < 3; s++) {
- tablet.addValue(schemaList.get(s).getMeasurementId(), rowIndex, value);
- value++;
- }
- tablet.rowSize++;
- }
-
- session.insertTablet(tablet);
-
- SessionDataSet dataSet = session.executeQueryStatement("select * from root.sg1.d1");
- int count = 0;
- while (dataSet.hasNext()) {
- count++;
- }
- Assert.assertEquals(201, count);
-
- IoTDBDescriptor.getInstance().getConfig().setWalMode(prevWalMode);
- session.close();
- }
-
- private void createTimeseries() throws StatementExecutionException, IoTDBConnectionException {
- session.createTimeseries(
- "root.sg1.d1.s1", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg1.d1.s2", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg1.d1.s3", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg1.d2.s1", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg1.d2.s2", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg1.d2.s3", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- }
-
- private void insertRecords() throws IoTDBConnectionException, StatementExecutionException {
- String deviceId = "root.sg1.d2";
- List<String> measurements = new ArrayList<>();
- measurements.add("s1");
- measurements.add("s2");
- measurements.add("s3");
- List<String> deviceIds = new ArrayList<>();
- List<List<String>> measurementsList = new ArrayList<>();
- List<List<Object>> valuesList = new ArrayList<>();
- List<Long> timestamps = new ArrayList<>();
- List<List<TSDataType>> typesList = new ArrayList<>();
-
- for (long time = 0; time < 500; time++) {
- List<Object> values = new ArrayList<>();
- List<TSDataType> types = new ArrayList<>();
- values.add(1L);
- values.add(2L);
- values.add(3L);
- types.add(TSDataType.INT64);
- types.add(TSDataType.INT64);
- types.add(TSDataType.INT64);
-
- deviceIds.add(deviceId);
- measurementsList.add(measurements);
- valuesList.add(values);
- typesList.add(types);
- timestamps.add(time);
- if (time != 0 && time % 100 == 0) {
- session.insertRecords(deviceIds, timestamps, measurementsList, typesList, valuesList);
- deviceIds.clear();
- measurementsList.clear();
- valuesList.clear();
- timestamps.clear();
- }
- }
-
- session.insertRecords(deviceIds, timestamps, measurementsList, typesList, valuesList);
- }
-
- private void rawDataQuery() throws StatementExecutionException, IoTDBConnectionException {
- List<String> paths = new ArrayList<>();
- paths.add("root.sg1.d2.*");
- paths.add("root.sg1.d2.s1");
- paths.add("root.sg1.d2.s2");
-
- SessionDataSet sessionDataSet = session.executeRawDataQuery(paths, 450L, 600L, 60000);
- sessionDataSet.setFetchSize(1024);
-
- int count = 0;
- while (sessionDataSet.hasNext()) {
- count++;
- StringBuilder sb = new StringBuilder();
- List<Field> fields = sessionDataSet.next().getFields();
- for (Field f : fields) {
- sb.append(f.getStringValue()).append(",");
- }
- Assert.assertEquals("3,1,2,1,2,", sb.toString());
- }
- Assert.assertEquals(50, count);
- sessionDataSet.closeOperationHandle();
- }
-
- private void lastDataQuery() throws StatementExecutionException, IoTDBConnectionException {
- List<String> paths = new ArrayList<>();
-
- paths.add("root.sg1.d1.s1");
- paths.add("root.sg1.d2.s1");
-
- SessionDataSet sessionDataSet = session.executeLastDataQuery(paths);
- sessionDataSet.setFetchSize(1024);
-
- int count = 0;
- while (sessionDataSet.hasNext()) {
- count++;
- List<Field> fields = sessionDataSet.next().getFields();
- Assert.assertEquals("[root.sg1.d2.s1,1,INT64]", fields.toString().replace(" ", ""));
- }
- Assert.assertEquals(1, count);
- sessionDataSet.closeOperationHandle();
- }
-
- private void insertTablet(String deviceId)
- throws IoTDBConnectionException, StatementExecutionException {
-
- List<MeasurementSchema> schemaList = new ArrayList<>();
- schemaList.add(new MeasurementSchema("s1", TSDataType.INT64, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s2", TSDataType.INT64, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s3", TSDataType.INT64, TSEncoding.RLE));
-
- Tablet tablet = new Tablet(deviceId, schemaList, 100);
-
- for (long time = 0; time < 100; time++) {
- int rowIndex = tablet.rowSize++;
- long value = 0;
- tablet.addTimestamp(rowIndex, time);
- for (int s = 0; s < 3; s++) {
- tablet.addValue(schemaList.get(s).getMeasurementId(), rowIndex, value);
- value++;
- }
- if (tablet.rowSize == tablet.getMaxRowNumber()) {
- session.insertTablet(tablet);
- tablet.reset();
- }
- }
-
- if (tablet.rowSize != 0) {
- session.insertTablet(tablet);
- tablet.reset();
- }
-
- long[] timestamps = tablet.timestamps;
- Object[] values = tablet.values;
-
- for (long time = 0; time < 100; time++) {
- int row = tablet.rowSize++;
- timestamps[row] = time;
- for (int i = 0; i < 3; i++) {
- long[] sensor = (long[]) values[i];
- sensor[row] = i;
- }
- if (tablet.rowSize == tablet.getMaxRowNumber()) {
- session.insertTablet(tablet);
- tablet.reset();
- }
- }
-
- if (tablet.rowSize != 0) {
- session.insertTablet(tablet);
- tablet.reset();
- }
- }
-
- private void deleteData() throws IoTDBConnectionException, StatementExecutionException {
- String path1 = "root.sg1.d1.s1";
- String path2 = "root.sg1.d1.s2";
- String path3 = "root.sg1.d1.s3";
- String path4 = "root.sg1.d2.s1";
- String path5 = "root.sg1.d2.s2";
- String path6 = "root.sg1.d2.s3";
- long deleteTime = 500;
-
- List<String> paths = new ArrayList<>();
- paths.add(path1);
- paths.add(path2);
- paths.add(path3);
- paths.add(path4);
- paths.add(path5);
- paths.add(path6);
- try {
- session.deleteData(paths, deleteTime);
- } catch (StatementExecutionException e) {
- if (e.getStatusCode() != TSStatusCode.QUERY_PROCESS_ERROR.getStatusCode()) {
- throw e;
- }
- }
- }
-
- private void deleteTimeseries() throws IoTDBConnectionException, StatementExecutionException {
- session.deleteTimeseries("root.sg1.d1.s1");
- }
-
- private void queryAll(List<String> standard) throws ClassNotFoundException, SQLException {
- Class.forName(Config.JDBC_DRIVER_NAME);
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery("SELECT * FROM root");
- final ResultSetMetaData metaData = resultSet.getMetaData();
- final int colCount = metaData.getColumnCount();
- for (int i = 0; i < colCount; i++) {
- Assert.assertTrue(standard.contains(metaData.getColumnLabel(i + 1)));
- }
- while (resultSet.next()) {
- fail();
- }
- }
- }
-
- private void deleteStorageGroupTest()
- throws ClassNotFoundException, SQLException, IoTDBConnectionException,
- StatementExecutionException {
- try {
- session.deleteStorageGroup("root.sg1.d1.s1");
- } catch (StatementExecutionException e) {
- assertTrue(e.getMessage().contains("Path [root.sg1.d1.s1] does not exist"));
- }
- session.deleteStorageGroup("root.sg1");
- File folder = new File("data/system/storage_groups/root.sg1/");
- assertFalse(folder.exists());
- session.setStorageGroup("root.sg1.d1");
- session.createTimeseries(
- "root.sg1.d1.s1", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
-
- Class.forName(Config.JDBC_DRIVER_NAME);
- List<String> standards =
- Arrays.asList("Time", "root.1.2.3", "root.sg2.d1.s1", "root.sg1.d1.s1");
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery("SELECT * FROM root");
- final ResultSetMetaData metaData = resultSet.getMetaData();
- final int colCount = metaData.getColumnCount();
- for (int i = 0; i < colCount; i++) {
- Assert.assertTrue(standards.contains(metaData.getColumnLabel(i + 1)));
- }
- while (resultSet.next()) {
- fail();
- }
- List<String> storageGroups = new ArrayList<>();
- storageGroups.add("root.sg1.d1");
- storageGroups.add("root.sg2");
- session.deleteStorageGroups(storageGroups);
- }
- }
-
- private void queryByDevice(String deviceId)
- throws IoTDBConnectionException, StatementExecutionException {
- SessionDataSet sessionDataSet = session.executeQueryStatement("select * from " + deviceId);
- sessionDataSet.setFetchSize(1024);
- int count = 0;
- long expectedSum = 1 + 2 + 3;
- while (sessionDataSet.hasNext()) {
- count++;
- long actualSum = 0;
- for (Field f : sessionDataSet.next().getFields()) {
- actualSum += f.getLongV();
- }
- Assert.assertEquals(expectedSum, actualSum);
- }
-
- switch (deviceId) {
- case "root.sg1.d1":
- Assert.assertEquals(101, count);
- break;
- case "root.sg1.d2":
- Assert.assertEquals(500, count);
- break;
- }
-
- sessionDataSet.closeOperationHandle();
- }
-
- private void insertViaSQL() throws IoTDBConnectionException, StatementExecutionException {
- session.executeNonQueryStatement(
- "insert into root.sg1.d1(timestamp,s1, s2, s3) values(100, 1,2,3)");
- }
-
- private void checkSetSG(Session session, String sg, boolean correctStatus)
- throws IoTDBConnectionException {
- boolean status = true;
- try {
- session.setStorageGroup(sg);
- } catch (StatementExecutionException e) {
- status = false;
- }
- assertEquals(correctStatus, status);
- }
-
- private void queryForBatch() throws ClassNotFoundException, SQLException {
- Class.forName(Config.JDBC_DRIVER_NAME);
- List<String> standards =
- Arrays.asList(
- "Time",
- "root.sg1.d1.s1",
- "root.sg1.d1.s2",
- "root.sg1.d1.s3",
- "root.sg1.d2.s1",
- "root.sg1.d2.s2",
- "root.sg1.d2.s3");
- try (Connection connection =
- DriverManager.getConnection(
- Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
- Statement statement = connection.createStatement()) {
- ResultSet resultSet = statement.executeQuery("SELECT * FROM root.**");
- final ResultSetMetaData metaData = resultSet.getMetaData();
- final int colCount = metaData.getColumnCount();
- for (int i = 0; i < colCount; i++) {
- Assert.assertTrue(standards.contains(metaData.getColumnLabel(i + 1)));
- }
-
- int count = 0;
- while (resultSet.next()) {
- for (int i = 1; i <= colCount; i++) {
- count++;
- }
- }
- Assert.assertEquals(700, count);
- }
- }
-
- @Test
- public void testInsertTabletWithTriggers()
- throws StatementExecutionException, IoTDBConnectionException, TriggerManagementException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- session.setStorageGroup("root.sg1");
- createTimeseries();
-
- session.executeNonQueryStatement(
- "create trigger d1s1 after insert on root.sg1.d1.s1 as 'org.apache.iotdb.db.engine.trigger.example.Counter'");
- session.executeNonQueryStatement(
- "create trigger d1s2 before insert on root.sg1.d1.s2 as 'org.apache.iotdb.db.engine.trigger.example.Counter'");
-
- assertEquals(
- Counter.BASE,
- ((Counter) TriggerRegistrationService.getInstance().getTriggerInstance("d1s1"))
- .getCounter());
- assertEquals(
- Counter.BASE,
- ((Counter) TriggerRegistrationService.getInstance().getTriggerInstance("d1s2"))
- .getCounter());
- try {
- int counter =
- ((Counter) TriggerRegistrationService.getInstance().getTriggerInstance("d1s3"))
- .getCounter();
- fail(String.valueOf(counter - Counter.BASE));
- } catch (TriggerManagementException e) {
- assertEquals("Trigger d1s3 does not exist.", e.getMessage());
- }
-
- insertTablet("root.sg1.d1");
-
- assertEquals(
- Counter.BASE + 200,
- ((Counter) TriggerRegistrationService.getInstance().getTriggerInstance("d1s1"))
- .getCounter());
- assertEquals(
- Counter.BASE + 200,
- ((Counter) TriggerRegistrationService.getInstance().getTriggerInstance("d1s2"))
- .getCounter());
- try {
- int counter =
- ((Counter) TriggerRegistrationService.getInstance().getTriggerInstance("d1s3"))
- .getCounter();
- fail(String.valueOf(counter - Counter.BASE));
- } catch (TriggerManagementException e) {
- assertEquals("Trigger d1s3 does not exist.", e.getMessage());
- }
-
- session.close();
- }
-
- @Test
- public void testSessionCluster() throws IoTDBConnectionException, StatementExecutionException {
- ArrayList<String> nodeList = new ArrayList<>();
- nodeList.add("127.0.0.1:6669");
- nodeList.add("127.0.0.1:6667");
- nodeList.add("127.0.0.1:6668");
- session = new Session(nodeList, "root", "root");
- session.open();
-
- session.setStorageGroup("root.sg1");
-
- createTimeseries();
- insertByStr();
-
- insertViaSQL();
- queryByDevice("root.sg1.d1");
-
- session.close();
- }
-
- @Test
- public void testErrorSessionCluster() throws IoTDBConnectionException {
- ArrayList<String> nodeList = new ArrayList<>();
- // test Format error
- nodeList.add("127.0.0.16669");
- nodeList.add("127.0.0.1:6667");
- session = new Session(nodeList, "root", "root");
- try {
- session.open();
- } catch (Exception e) {
- Assert.assertEquals("NodeUrl Incorrect format", e.getMessage());
- }
- session.close();
- }
-}
diff --git a/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionDisableMemControlIT.java b/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionDisableMemControlIT.java
deleted file mode 100644
index 13c7d7cf8f..0000000000
--- a/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionDisableMemControlIT.java
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.iotdb.session;
-
-import org.apache.iotdb.commons.conf.IoTDBConstant;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
-import org.apache.iotdb.db.utils.EnvironmentUtils;
-import org.apache.iotdb.rpc.IoTDBConnectionException;
-import org.apache.iotdb.rpc.StatementExecutionException;
-import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
-import org.apache.iotdb.tsfile.read.common.RowRecord;
-import org.apache.iotdb.tsfile.utils.Binary;
-import org.apache.iotdb.tsfile.write.record.Tablet;
-import org.apache.iotdb.tsfile.write.schema.MeasurementSchema;
-
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class IoTDBSessionDisableMemControlIT {
-
- private static Logger logger = LoggerFactory.getLogger(IoTDBSessionDisableMemControlIT.class);
-
- private Session session;
-
- @Before
- public void setUp() {
- System.setProperty(IoTDBConstant.IOTDB_CONF, "src/test/resources/");
- IoTDBDescriptor.getInstance().getConfig().setEnableMemControl(false);
- EnvironmentUtils.envSetUp();
- }
-
- @After
- public void tearDown() throws Exception {
- session.close();
- EnvironmentUtils.cleanEnv();
- IoTDBDescriptor.getInstance().getConfig().setEnableMemControl(true);
- }
-
- @Test
- public void testInsertPartialTablet()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- if (!session.checkTimeseriesExists("root.sg.d.s1")) {
- session.createTimeseries(
- "root.sg.d.s1", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- }
- if (!session.checkTimeseriesExists("root.sg.d.s2")) {
- session.createTimeseries(
- "root.sg.d.s2", TSDataType.DOUBLE, TSEncoding.GORILLA, CompressionType.SNAPPY);
- }
- if (!session.checkTimeseriesExists("root.sg.d.s3")) {
- session.createTimeseries(
- "root.sg.d.s3", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- }
- List<MeasurementSchema> schemaList = new ArrayList<>();
- schemaList.add(new MeasurementSchema("s1", TSDataType.INT64));
- schemaList.add(new MeasurementSchema("s2", TSDataType.DOUBLE));
- schemaList.add(new MeasurementSchema("s3", TSDataType.TEXT));
-
- Tablet tablet = new Tablet("root.sg.d", schemaList, 10);
-
- long timestamp = System.currentTimeMillis();
-
- for (long row = 0; row < 15; row++) {
- int rowIndex = tablet.rowSize++;
- tablet.addTimestamp(rowIndex, timestamp);
- tablet.addValue("s1", rowIndex, 1L);
- tablet.addValue("s2", rowIndex, 1D);
- tablet.addValue("s3", rowIndex, new Binary("1"));
- if (tablet.rowSize == tablet.getMaxRowNumber()) {
- try {
- session.insertTablet(tablet, true);
- } catch (StatementExecutionException e) {
- Assert.assertEquals(313, e.getStatusCode());
- }
- tablet.reset();
- }
- timestamp++;
- }
-
- if (tablet.rowSize != 0) {
- try {
- session.insertTablet(tablet);
- } catch (StatementExecutionException e) {
- Assert.assertEquals(313, e.getStatusCode());
- }
- tablet.reset();
- }
-
- SessionDataSet dataSet =
- session.executeQueryStatement("select count(s1), count(s2), count(s3) from root.sg.d");
- while (dataSet.hasNext()) {
- RowRecord rowRecord = dataSet.next();
- Assert.assertEquals(15L, rowRecord.getFields().get(0).getLongV());
- Assert.assertEquals(15L, rowRecord.getFields().get(1).getLongV());
- Assert.assertEquals(0L, rowRecord.getFields().get(2).getLongV());
- }
- session.close();
- }
-
- @Test
- public void testInsertPartialAlignedTablet()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- List<String> multiMeasurementComponents = new ArrayList<>();
- for (int i = 1; i <= 3; i++) {
- multiMeasurementComponents.add("s" + i);
- }
- List<TSDataType> dataTypes = new ArrayList<>();
- dataTypes.add(TSDataType.INT64);
- dataTypes.add(TSDataType.DOUBLE);
- dataTypes.add(TSDataType.INT64);
- List<TSEncoding> encodings = new ArrayList<>();
- List<CompressionType> compressors = new ArrayList<>();
- for (int i = 1; i <= 3; i++) {
- encodings.add(TSEncoding.PLAIN);
- compressors.add(CompressionType.SNAPPY);
- }
- session.createAlignedTimeseries(
- "root.sg.d",
- multiMeasurementComponents,
- dataTypes,
- encodings,
- compressors,
- null,
- null,
- null);
- List<MeasurementSchema> schemaList = new ArrayList<>();
- schemaList.add(new MeasurementSchema("s1", TSDataType.INT64));
- schemaList.add(new MeasurementSchema("s2", TSDataType.DOUBLE));
- schemaList.add(new MeasurementSchema("s3", TSDataType.TEXT));
-
- Tablet tablet = new Tablet("root.sg.d", schemaList, 10);
-
- long timestamp = System.currentTimeMillis();
-
- for (long row = 0; row < 15; row++) {
- int rowIndex = tablet.rowSize++;
- tablet.addTimestamp(rowIndex, timestamp);
- tablet.addValue("s1", rowIndex, 1L);
- tablet.addValue("s2", rowIndex, 1D);
- tablet.addValue("s3", rowIndex, new Binary("1"));
- if (tablet.rowSize == tablet.getMaxRowNumber()) {
- try {
- session.insertAlignedTablet(tablet, true);
- } catch (StatementExecutionException e) {
- Assert.assertEquals(313, e.getStatusCode());
- }
- tablet.reset();
- }
- timestamp++;
- }
-
- if (tablet.rowSize != 0) {
- try {
- session.insertAlignedTablet(tablet);
- } catch (StatementExecutionException e) {
- Assert.assertEquals(313, e.getStatusCode());
- }
- tablet.reset();
- }
-
- SessionDataSet dataSet = session.executeQueryStatement("select s1, s2, s3 from root.sg.d");
- while (dataSet.hasNext()) {
- RowRecord rowRecord = dataSet.next();
- Assert.assertEquals(1, rowRecord.getFields().get(0).getLongV());
- Assert.assertEquals(1.0, rowRecord.getFields().get(1).getDoubleV(), 0.01);
- Assert.assertEquals(null, rowRecord.getFields().get(2).getObjectValue(TSDataType.TEXT));
- }
- session.close();
- }
-}
diff --git a/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionInsertNullT.java b/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionInsertNullT.java
deleted file mode 100644
index 62d9ee39cf..0000000000
--- a/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionInsertNullT.java
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.iotdb.session;
-
-import org.apache.iotdb.commons.conf.IoTDBConstant;
-import org.apache.iotdb.db.utils.EnvironmentUtils;
-import org.apache.iotdb.itbase.category.LocalStandaloneTest;
-import org.apache.iotdb.rpc.IoTDBConnectionException;
-import org.apache.iotdb.rpc.StatementExecutionException;
-import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
-import org.apache.iotdb.tsfile.read.common.Field;
-import org.apache.iotdb.tsfile.read.common.RowRecord;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import static org.junit.Assert.assertEquals;
-
-@Category({LocalStandaloneTest.class})
-public class IoTDBSessionInsertNullT {
- private Session session;
-
- @Before
- public void setUp() throws Exception {
- System.setProperty(IoTDBConstant.IOTDB_CONF, "src/test/resources/");
- EnvironmentUtils.envSetUp();
- prepareData();
- }
-
- @After
- public void tearDown() throws Exception {
- session.close();
- EnvironmentUtils.cleanEnv();
- }
-
- @Test
- public void testInsertRecordNull() throws StatementExecutionException, IoTDBConnectionException {
- String deviceId = "root.sg1.clsu.d1";
- session.insertRecord(deviceId, 100, Arrays.asList("s1"), Arrays.asList("true"));
- List<String> t = new ArrayList<>();
- t.add(null);
- session.insertRecord(deviceId, 200, Arrays.asList("s1"), t);
- session.insertRecord(
- deviceId,
- 300,
- Arrays.asList("s1", "s2"),
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
- Arrays.asList(true, 30));
- session.insertRecord(
- deviceId,
- 400,
- Arrays.asList("s1", "s2"),
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
- Arrays.asList(true, null));
- session.insertRecord(
- deviceId,
- 500,
- Arrays.asList("s1", "s2"),
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
- Arrays.asList(null, null));
- long nums = queryCountRecords("select count(s1) from " + deviceId);
- assertEquals(3, nums);
- }
-
- @Test
- public void testInsertAlignedRecordNull()
- throws StatementExecutionException, IoTDBConnectionException {
- String deviceId = "root.sg1.clsu.aligned_d1";
- session.insertAlignedRecord(deviceId, 100, Arrays.asList("s1"), Arrays.asList("true"));
- List<String> t = new ArrayList<>();
- t.add(null);
- session.insertAlignedRecord(deviceId, 200, Arrays.asList("s1"), t);
- session.insertAlignedRecord(
- deviceId,
- 300,
- Arrays.asList("s1", "s2"),
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
- Arrays.asList(true, 30));
- session.insertAlignedRecord(
- deviceId,
- 400,
- Arrays.asList("s1", "s2"),
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
- Arrays.asList(true, null));
- session.insertAlignedRecord(
- deviceId,
- 500,
- Arrays.asList("s1", "s2"),
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
- Arrays.asList(null, null));
- long nums = queryCountRecords("select count(s1) from " + deviceId);
- assertEquals(3, nums);
- }
-
- @Test
- public void testInsertRecordsNull() throws StatementExecutionException, IoTDBConnectionException {
- String deviceId1 = "root.sg1.clsu.d2";
- String deviceId2 = "root.sg1.clsu.d3";
- session.insertRecords(
- Arrays.asList(deviceId1, deviceId2),
- Arrays.asList(300L, 300L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
- Arrays.asList(Arrays.asList(true, 101), Arrays.asList(false, 201)));
- session.insertRecords(
- Arrays.asList(deviceId1, deviceId2),
- Arrays.asList(200L, 200L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(Arrays.asList("false", "101"), Arrays.asList("true", "201")));
- session.insertRecords(
- Arrays.asList(deviceId1, deviceId2),
- Arrays.asList(400L, 400L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(Arrays.asList(null, "102"), Arrays.asList("false", "202")));
- session.insertRecords(
- Arrays.asList(deviceId1, deviceId2),
- Arrays.asList(500L, 500L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
- Arrays.asList(Arrays.asList(true, null), Arrays.asList(null, null)));
- long nums = queryCountRecords("select count(s1) from " + deviceId1);
- assertEquals(3, nums);
- nums = queryCountRecords("select count(s2) from " + deviceId2);
- assertEquals(3, nums);
- }
-
- @Test
- public void testInsertAlignedRecordsNull()
- throws StatementExecutionException, IoTDBConnectionException {
- String deviceId1 = "root.sg1.clsu.aligned_d2";
- String deviceId2 = "root.sg1.clsu.aligned_d3";
- session.insertAlignedRecords(
- Arrays.asList(deviceId1, deviceId2),
- Arrays.asList(300L, 300L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
- Arrays.asList(Arrays.asList(true, 101), Arrays.asList(false, 201)));
- session.insertAlignedRecords(
- Arrays.asList(deviceId1, deviceId2),
- Arrays.asList(200L, 200L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(Arrays.asList("false", "101"), Arrays.asList("true", "201")));
- session.insertAlignedRecords(
- Arrays.asList(deviceId1, deviceId2),
- Arrays.asList(400L, 400L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(Arrays.asList(null, "102"), Arrays.asList("false", "202")));
- session.insertAlignedRecords(
- Arrays.asList(deviceId1, deviceId2),
- Arrays.asList(500L, 500L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
- Arrays.asList(Arrays.asList(true, null), Arrays.asList(null, null)));
- long nums = queryCountRecords("select count(s1) from " + deviceId1);
- assertEquals(3, nums);
- nums = queryCountRecords("select count(s2) from " + deviceId2);
- assertEquals(3, nums);
- }
-
- @Test
- public void testInsertRecordsOfOneDeviceNull()
- throws StatementExecutionException, IoTDBConnectionException {
- String deviceId1 = "root.sg1.clsu.InsertRecordsOfOneDevice";
- session.insertRecordsOfOneDevice(
- deviceId1,
- Arrays.asList(300L, 301L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
- Arrays.asList(Arrays.asList(true, 101), Arrays.asList(false, 201)));
- session.insertStringRecordsOfOneDevice(
- deviceId1,
- Arrays.asList(200L, 201L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(Arrays.asList("false", "101"), Arrays.asList("true", "201")));
- session.insertStringRecordsOfOneDevice(
- deviceId1,
- Arrays.asList(400L, 401L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(Arrays.asList(null, "102"), Arrays.asList("false", "202")));
- session.insertRecordsOfOneDevice(
- deviceId1,
- Arrays.asList(500L, 501L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
- Arrays.asList(Arrays.asList(true, null), Arrays.asList(null, null)));
- long nums = queryCountRecords("select count(s1) from " + deviceId1);
- assertEquals(6, nums);
- }
-
- @Test
- public void testInsertAlignedRecordsOfOneDeviceNull()
- throws StatementExecutionException, IoTDBConnectionException {
- String deviceId1 = "root.sg1.clsu.InsertAlignedRecordsOfOneDevice";
- session.insertAlignedRecordsOfOneDevice(
- deviceId1,
- Arrays.asList(300L, 301L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
- Arrays.asList(Arrays.asList(true, 101), Arrays.asList(false, 201)));
- session.insertAlignedStringRecordsOfOneDevice(
- deviceId1,
- Arrays.asList(200L, 201L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(Arrays.asList("false", "101"), Arrays.asList("true", "201")));
- session.insertAlignedStringRecordsOfOneDevice(
- deviceId1,
- Arrays.asList(400L, 401L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(Arrays.asList(null, "102"), Arrays.asList("false", "202")));
- session.insertAlignedRecordsOfOneDevice(
- deviceId1,
- Arrays.asList(500L, 501L),
- Arrays.asList(Arrays.asList("s1", "s2"), Arrays.asList("s1", "s2")),
- Arrays.asList(
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32),
- Arrays.asList(TSDataType.BOOLEAN, TSDataType.INT32)),
- Arrays.asList(Arrays.asList(true, null), Arrays.asList(null, null)));
- long nums = queryCountRecords("select count(s1) from " + deviceId1);
- assertEquals(6, nums);
- }
-
- private void prepareData() throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- session.setStorageGroup("root.sg1");
- session.createTimeseries(
- "root.sg1.clsu.d1.s1", TSDataType.BOOLEAN, TSEncoding.PLAIN, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg1.clsu.d1.s2", TSDataType.INT32, TSEncoding.PLAIN, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg1.clsu.d1.s3", TSDataType.INT64, TSEncoding.PLAIN, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg1.clsu.d1.s4", TSDataType.FLOAT, TSEncoding.PLAIN, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg1.clsu.d1.s5", TSDataType.DOUBLE, TSEncoding.PLAIN, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg1.clsu.d1.s6", TSDataType.TEXT, TSEncoding.PLAIN, CompressionType.SNAPPY);
- session.createTimeseries(
- "root.sg1.clsu.d2.s1", TSDataType.BOOLEAN, TSEncoding.PLAIN, CompressionType.SNAPPY);
- }
-
- public long queryCountRecords(String sql)
- throws StatementExecutionException, IoTDBConnectionException {
- SessionDataSet dataSetWrapper = session.executeQueryStatement(sql, 1000);
- long count = 0;
- while (dataSetWrapper.hasNext()) {
- RowRecord record = dataSetWrapper.next();
- Field field = record.getFields().get(0);
- switch (field.getDataType()) {
- case INT32:
- count = field.getIntV();
- break;
- case INT64:
- count = field.getLongV();
- break;
- }
- }
- return count;
- }
-}
diff --git a/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionSimpleIT.java b/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionSimpleIT.java
deleted file mode 100644
index 0e7c445b61..0000000000
--- a/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionSimpleIT.java
+++ /dev/null
@@ -1,1704 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.iotdb.session;
-
-import org.apache.iotdb.commons.conf.IoTDBConstant;
-import org.apache.iotdb.commons.exception.MetadataException;
-import org.apache.iotdb.commons.path.PartialPath;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
-import org.apache.iotdb.db.conf.OperationType;
-import org.apache.iotdb.db.metadata.LocalSchemaProcessor;
-import org.apache.iotdb.db.metadata.mnode.IMeasurementMNode;
-import org.apache.iotdb.db.utils.EnvironmentUtils;
-import org.apache.iotdb.itbase.category.LocalStandaloneTest;
-import org.apache.iotdb.rpc.BatchExecutionException;
-import org.apache.iotdb.rpc.IoTDBConnectionException;
-import org.apache.iotdb.rpc.StatementExecutionException;
-import org.apache.iotdb.rpc.TSStatusCode;
-import org.apache.iotdb.session.template.InternalNode;
-import org.apache.iotdb.session.template.MeasurementNode;
-import org.apache.iotdb.session.template.Template;
-import org.apache.iotdb.session.template.TemplateNode;
-import org.apache.iotdb.tsfile.common.constant.TsFileConstant;
-import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
-import org.apache.iotdb.tsfile.read.common.Field;
-import org.apache.iotdb.tsfile.read.common.RowRecord;
-import org.apache.iotdb.tsfile.utils.Binary;
-import org.apache.iotdb.tsfile.utils.BitMap;
-import org.apache.iotdb.tsfile.write.record.Tablet;
-import org.apache.iotdb.tsfile.write.schema.MeasurementSchema;
-
-import org.apache.commons.lang3.StringUtils;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.security.SecureRandom;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-@Category({LocalStandaloneTest.class})
-public class IoTDBSessionSimpleIT {
-
- private static Logger logger = LoggerFactory.getLogger(IoTDBSessionSimpleIT.class);
-
- private Session session;
-
- @Before
- public void setUp() {
- System.setProperty(IoTDBConstant.IOTDB_CONF, "src/test/resources/");
- EnvironmentUtils.envSetUp();
- }
-
- @After
- public void tearDown() throws Exception {
- session.close();
- EnvironmentUtils.cleanEnv();
- }
-
- @Test
- public void testInsertPartialTablet()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- session.createTimeseries(
- "root.sg.d.s1", TSDataType.INT64, TSEncoding.PLAIN, CompressionType.LZ4);
- session.createTimeseries(
- "root.sg.d.s2", TSDataType.FLOAT, TSEncoding.PLAIN, CompressionType.LZ4);
- session.createTimeseries(
- "root.sg.d.s3", TSDataType.TEXT, TSEncoding.PLAIN, CompressionType.LZ4);
- List<MeasurementSchema> schemaList = new ArrayList<>();
- schemaList.add(new MeasurementSchema("s1", TSDataType.INT64));
- schemaList.add(new MeasurementSchema("s2", TSDataType.DOUBLE));
- schemaList.add(new MeasurementSchema("s3", TSDataType.TEXT));
-
- Tablet tablet = new Tablet("root.sg.d", schemaList, 10);
-
- for (long row = 0; row < 15; row++) {
- int rowIndex = tablet.rowSize++;
- tablet.addTimestamp(rowIndex, row);
- tablet.addValue("s1", rowIndex, 1L);
- tablet.addValue("s2", rowIndex, 1D);
- tablet.addValue("s3", rowIndex, new Binary("1"));
- if (tablet.rowSize == tablet.getMaxRowNumber()) {
- try {
- session.insertTablet(tablet, true);
- } catch (StatementExecutionException e) {
- Assert.assertTrue(e.getMessage().contains("is not consistent"));
- }
- tablet.reset();
- }
- }
-
- if (tablet.rowSize != 0) {
- try {
- session.insertTablet(tablet);
- } catch (StatementExecutionException e) {
- Assert.assertTrue(e.getMessage().contains("is not consistent"));
- }
- tablet.reset();
- }
-
- SessionDataSet dataSet = session.executeQueryStatement("select count(*) from root.**");
- while (dataSet.hasNext()) {
- RowRecord rowRecord = dataSet.next();
- Assert.assertEquals(15L, rowRecord.getFields().get(0).getLongV());
- Assert.assertEquals(15L, rowRecord.getFields().get(1).getLongV());
- Assert.assertEquals(0, rowRecord.getFields().get(2).getLongV());
- }
- dataSet.close();
- session.close();
- }
-
- @Test
- public void testInsertByStrAndInferType()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- String deviceId = "root.sg1.d1";
- List<String> measurements = new ArrayList<>();
- measurements.add("s1");
- measurements.add("s2");
- measurements.add("s3");
- measurements.add("s4");
-
- List<String> values = new ArrayList<>();
- values.add("1");
- values.add("1.2");
- values.add("true");
- values.add("dad");
- session.insertRecord(deviceId, 1L, measurements, values);
-
- Set<String> expected = new HashSet<>();
- expected.add(IoTDBDescriptor.getInstance().getConfig().getIntegerStringInferType().name());
- expected.add(IoTDBDescriptor.getInstance().getConfig().getFloatingStringInferType().name());
- expected.add(IoTDBDescriptor.getInstance().getConfig().getBooleanStringInferType().name());
- expected.add(TSDataType.TEXT.name());
-
- Set<String> actual = new HashSet<>();
- SessionDataSet dataSet = session.executeQueryStatement("show timeseries root.**");
- while (dataSet.hasNext()) {
- actual.add(dataSet.next().getFields().get(3).getStringValue());
- }
-
- Assert.assertEquals(expected, actual);
-
- session.close();
- }
-
- @Test
- public void testInsertWrongPathByStrAndInferType()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- String deviceId = "root.sg1..d1";
- List<String> measurements = new ArrayList<>();
- measurements.add("s1");
- measurements.add("s2");
- measurements.add("s3");
- measurements.add("s4");
-
- List<String> values = new ArrayList<>();
- values.add("1");
- values.add("1.2");
- values.add("true");
- values.add("dad");
- try {
- session.insertRecord(deviceId, 1L, measurements, values);
- } catch (Exception e) {
- logger.error("", e);
- }
-
- SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
- Assert.assertFalse(dataSet.hasNext());
-
- session.close();
- }
-
- @Test
- public void testInsertIntoIllegalTimeseries()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- String deviceId = "root.sg1.d1\n";
- List<String> measurements = new ArrayList<>();
- measurements.add("s1");
- measurements.add("s2");
- measurements.add("s3");
- measurements.add("s4");
-
- List<String> values = new ArrayList<>();
- values.add("1");
- values.add("1.2");
- values.add("true");
- values.add("dad");
- try {
- session.insertRecord(deviceId, 1L, measurements, values);
- } catch (Exception e) {
- logger.error("", e);
- }
-
- SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
- Assert.assertFalse(dataSet.hasNext());
-
- session.close();
- }
-
- @Test
- public void testInsertByObjAndNotInferType()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- String deviceId = "root.sg1.d1";
- List<String> measurements = new ArrayList<>();
- measurements.add("s1");
- measurements.add("s2");
- measurements.add("s3");
- measurements.add("s4");
-
- List<TSDataType> dataTypes = new ArrayList<>();
- dataTypes.add(TSDataType.INT64);
- dataTypes.add(TSDataType.DOUBLE);
- dataTypes.add(TSDataType.TEXT);
- dataTypes.add(TSDataType.TEXT);
-
- List<Object> values = new ArrayList<>();
- values.add(1L);
- values.add(1.2d);
- values.add("true");
- values.add("dad");
- session.insertRecord(deviceId, 1L, measurements, dataTypes, values);
-
- Set<String> expected = new HashSet<>();
- expected.add(TSDataType.INT64.name());
- expected.add(TSDataType.DOUBLE.name());
- expected.add(TSDataType.TEXT.name());
- expected.add(TSDataType.TEXT.name());
-
- Set<String> actual = new HashSet<>();
- SessionDataSet dataSet = session.executeQueryStatement("show timeseries root.**");
- while (dataSet.hasNext()) {
- actual.add(dataSet.next().getFields().get(3).getStringValue());
- }
-
- Assert.assertEquals(expected, actual);
-
- session.close();
- }
-
- @Test
- public void testCreateMultiTimeseries()
- throws IoTDBConnectionException, StatementExecutionException, MetadataException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- List<String> paths = new ArrayList<>();
- paths.add("root.sg1.d1.s1");
- paths.add("root.sg1.d1.s2");
- List<TSDataType> tsDataTypes = new ArrayList<>();
- tsDataTypes.add(TSDataType.DOUBLE);
- tsDataTypes.add(TSDataType.DOUBLE);
- List<TSEncoding> tsEncodings = new ArrayList<>();
- tsEncodings.add(TSEncoding.RLE);
- tsEncodings.add(TSEncoding.RLE);
- List<CompressionType> compressionTypes = new ArrayList<>();
- compressionTypes.add(CompressionType.SNAPPY);
- compressionTypes.add(CompressionType.SNAPPY);
-
- List<Map<String, String>> tagsList = new ArrayList<>();
- Map<String, String> tags = new HashMap<>();
- tags.put("tag1", "v1");
- tagsList.add(tags);
- tagsList.add(tags);
-
- session.createMultiTimeseries(
- paths, tsDataTypes, tsEncodings, compressionTypes, null, tagsList, null, null);
-
- assertTrue(session.checkTimeseriesExists("root.sg1.d1.s1"));
- assertTrue(session.checkTimeseriesExists("root.sg1.d1.s2"));
- IMeasurementMNode mNode =
- LocalSchemaProcessor.getInstance().getMeasurementMNode(new PartialPath("root.sg1.d1.s1"));
- assertNull(mNode.getSchema().getProps());
-
- session.close();
- }
-
- @Test
- public void testChineseCharacter() throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- if (!System.getProperty("sun.jnu.encoding").contains("UTF-8")) {
- logger.error("The system does not support UTF-8, so skip Chinese test...");
- session.close();
- return;
- }
- String storageGroup = "root.存储组1";
- String[] devices = new String[] {"设备1.指标1", "设备1.s2", "d2.s1", "d2.指标2"};
- session.setStorageGroup(storageGroup);
- for (String path : devices) {
- String fullPath = storageGroup + TsFileConstant.PATH_SEPARATOR + path;
- session.createTimeseries(fullPath, TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- }
-
- for (String path : devices) {
- for (int i = 0; i < 10; i++) {
- String[] ss = path.split("\\.");
- StringBuilder deviceId = new StringBuilder(storageGroup);
- for (int j = 0; j < ss.length - 1; j++) {
- deviceId.append(TsFileConstant.PATH_SEPARATOR).append(ss[j]);
- }
- String sensorId = ss[ss.length - 1];
- List<String> measurements = new ArrayList<>();
- List<Object> values = new ArrayList<>();
- List<TSDataType> types = new ArrayList<>();
-
- measurements.add(sensorId);
- types.add(TSDataType.INT64);
- values.add(100L);
- session.insertRecord(deviceId.toString(), i, measurements, types, values);
- }
- }
-
- SessionDataSet dataSet = session.executeQueryStatement("select * from root.存储组1.*");
- int count = 0;
- while (dataSet.hasNext()) {
- count++;
- }
- Assert.assertEquals(10, count);
- session.deleteStorageGroup(storageGroup);
- session.close();
- }
-
- @Test
- public void testInsertTabletWithAlignedTimeseries()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- List<MeasurementSchema> schemaList = new ArrayList<>();
- schemaList.add(new MeasurementSchema("s1", TSDataType.INT64));
- schemaList.add(new MeasurementSchema("s2", TSDataType.INT32));
- schemaList.add(new MeasurementSchema("s3", TSDataType.TEXT));
-
- Tablet tablet = new Tablet("root.sg1.d1", schemaList);
- long timestamp = System.currentTimeMillis();
-
- for (long row = 0; row < 10; row++) {
- int rowIndex = tablet.rowSize++;
- tablet.addTimestamp(rowIndex, timestamp);
- tablet.addValue(
- schemaList.get(0).getMeasurementId(), rowIndex, new SecureRandom().nextLong());
- tablet.addValue(schemaList.get(1).getMeasurementId(), rowIndex, new SecureRandom().nextInt());
- tablet.addValue(schemaList.get(2).getMeasurementId(), rowIndex, new Binary("test"));
- timestamp++;
- }
-
- if (tablet.rowSize != 0) {
- session.insertAlignedTablet(tablet);
- tablet.reset();
- }
-
- SessionDataSet dataSet = session.executeQueryStatement("select count(*) from root");
- while (dataSet.hasNext()) {
- RowRecord rowRecord = dataSet.next();
- Assert.assertEquals(10L, rowRecord.getFields().get(0).getLongV());
- Assert.assertEquals(10L, rowRecord.getFields().get(1).getLongV());
- Assert.assertEquals(10L, rowRecord.getFields().get(2).getLongV());
- }
- session.close();
- }
-
- @Test
- public void testInsertTabletWithNullValues()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- List<MeasurementSchema> schemaList = new ArrayList<>();
- schemaList.add(new MeasurementSchema("s0", TSDataType.DOUBLE, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s1", TSDataType.FLOAT, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s2", TSDataType.INT64, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s3", TSDataType.INT32, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s4", TSDataType.BOOLEAN, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s5", TSDataType.TEXT, TSEncoding.RLE));
-
- Tablet tablet = new Tablet("root.sg1.d1", schemaList);
- for (long time = 0; time < 10; time++) {
- int rowIndex = tablet.rowSize++;
- tablet.addTimestamp(rowIndex, time);
-
- tablet.addValue(schemaList.get(0).getMeasurementId(), rowIndex, (double) time);
- tablet.addValue(schemaList.get(1).getMeasurementId(), rowIndex, (float) time);
- tablet.addValue(schemaList.get(2).getMeasurementId(), rowIndex, time);
- tablet.addValue(schemaList.get(3).getMeasurementId(), rowIndex, (int) time);
- tablet.addValue(schemaList.get(4).getMeasurementId(), rowIndex, time % 2 == 0);
- tablet.addValue(
- schemaList.get(5).getMeasurementId(), rowIndex, new Binary(String.valueOf(time)));
- }
-
- BitMap[] bitMaps = new BitMap[schemaList.size()];
- for (int i = 0; i < schemaList.size(); i++) {
- if (bitMaps[i] == null) {
- bitMaps[i] = new BitMap(10);
- }
- bitMaps[i].mark(i);
- }
- tablet.bitMaps = bitMaps;
-
- if (tablet.rowSize != 0) {
- session.insertTablet(tablet);
- tablet.reset();
- }
-
- SessionDataSet dataSet = session.executeQueryStatement("select count(*) from root");
- while (dataSet.hasNext()) {
- RowRecord rowRecord = dataSet.next();
- Assert.assertEquals(6L, rowRecord.getFields().size());
- for (Field field : rowRecord.getFields()) {
- Assert.assertEquals(9L, field.getLongV());
- }
- }
- session.close();
- }
-
- @Test
- public void testInsertTabletWithStringValues()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- List<MeasurementSchema> schemaList = new ArrayList<>();
- schemaList.add(new MeasurementSchema("s0", TSDataType.DOUBLE, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s1", TSDataType.FLOAT, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s2", TSDataType.INT64, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s3", TSDataType.INT32, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s4", TSDataType.BOOLEAN, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s5", TSDataType.TEXT, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s6", TSDataType.TEXT, TSEncoding.RLE));
-
- Tablet tablet = new Tablet("root.sg1.d1", schemaList);
- for (long time = 0; time < 10; time++) {
- int rowIndex = tablet.rowSize++;
- tablet.addTimestamp(rowIndex, time);
-
- tablet.addValue(schemaList.get(0).getMeasurementId(), rowIndex, (double) time);
- tablet.addValue(schemaList.get(1).getMeasurementId(), rowIndex, (float) time);
- tablet.addValue(schemaList.get(2).getMeasurementId(), rowIndex, time);
- tablet.addValue(schemaList.get(3).getMeasurementId(), rowIndex, (int) time);
- tablet.addValue(schemaList.get(4).getMeasurementId(), rowIndex, time % 2 == 0);
- tablet.addValue(schemaList.get(5).getMeasurementId(), rowIndex, new Binary("Text" + time));
- tablet.addValue(schemaList.get(6).getMeasurementId(), rowIndex, "Text" + time);
- }
-
- if (tablet.rowSize != 0) {
- session.insertTablet(tablet);
- tablet.reset();
- }
-
- SessionDataSet dataSet = session.executeQueryStatement("select * from root.sg1.d1");
- while (dataSet.hasNext()) {
- RowRecord rowRecord = dataSet.next();
- List<Field> fields = rowRecord.getFields();
- Assert.assertEquals(fields.get(5).getBinaryV(), fields.get(6).getBinaryV());
- }
- session.close();
- }
-
- @Test
- public void createTimeSeriesWithDoubleTicks()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- if (!System.getProperty("sun.jnu.encoding").contains("UTF-8")) {
- logger.error("The system does not support UTF-8, so skip Chinese test...");
- session.close();
- return;
- }
- String storageGroup = "root.sg";
- session.setStorageGroup(storageGroup);
-
- session.createTimeseries(
- "root.sg.`my.device.with.colon:`.s",
- TSDataType.INT64,
- TSEncoding.RLE,
- CompressionType.SNAPPY);
-
- final SessionDataSet dataSet = session.executeQueryStatement("SHOW TIMESERIES");
- assertTrue(dataSet.hasNext());
-
- session.deleteStorageGroup(storageGroup);
- session.close();
- }
-
- @Test
- public void createWrongTimeSeries() throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- if (!System.getProperty("sun.jnu.encoding").contains("UTF-8")) {
- logger.error("The system does not support UTF-8, so skip Chinese test...");
- session.close();
- return;
- }
- String storageGroup = "root.sg";
- session.setStorageGroup(storageGroup);
-
- try {
- session.createTimeseries(
- "root.sg.d1..s1", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- } catch (IoTDBConnectionException | StatementExecutionException e) {
- logger.error("", e);
- }
-
- try {
- session.createTimeseries("", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- } catch (IoTDBConnectionException | StatementExecutionException e) {
- logger.error("", e);
- }
-
- final SessionDataSet dataSet = session.executeQueryStatement("SHOW TIMESERIES");
- assertFalse(dataSet.hasNext());
-
- session.deleteStorageGroup(storageGroup);
- session.close();
- }
-
- @Test
- public void testDeleteNonExistTimeSeries()
- throws StatementExecutionException, IoTDBConnectionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- session.insertRecord(
- "root.sg1.d1", 0, Arrays.asList("t1", "t2", "t3"), Arrays.asList("123", "333", "444"));
- try {
- session.deleteTimeseries(Arrays.asList("root.sg1.d1.t6", "root.sg1.d1.t2", "root.sg1.d1.t3"));
- } catch (BatchExecutionException e) {
- assertTrue(e.getMessage().contains("Path [root.sg1.d1.t6] does not exist;"));
- }
- assertTrue(session.checkTimeseriesExists("root.sg1.d1.t1"));
- assertFalse(session.checkTimeseriesExists("root.sg1.d1.t2"));
- assertFalse(session.checkTimeseriesExists("root.sg1.d1.t3"));
-
- session.close();
- }
-
- @Test
- public void testInsertOneDeviceRecords()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- List<Long> times = new ArrayList<>();
- List<List<String>> measurements = new ArrayList<>();
- List<List<TSDataType>> datatypes = new ArrayList<>();
- List<List<Object>> values = new ArrayList<>();
-
- addLine(
- times,
- measurements,
- datatypes,
- values,
- 3L,
- "s1",
- "s2",
- TSDataType.INT32,
- TSDataType.INT32,
- 1,
- 2);
- addLine(
- times,
- measurements,
- datatypes,
- values,
- 2L,
- "s2",
- "s3",
- TSDataType.INT32,
- TSDataType.INT64,
- 3,
- 4L);
- addLine(
- times,
- measurements,
- datatypes,
- values,
- 1L,
- "s4",
- "s5",
- TSDataType.FLOAT,
- TSDataType.BOOLEAN,
- 5.0f,
- Boolean.TRUE);
- session.insertRecordsOfOneDevice("root.sg.d1", times, measurements, datatypes, values);
- checkResult(session);
- session.close();
- }
-
- @Test
- public void testFillAll() throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- List<String> paths = new ArrayList<>();
- paths.add("root.sg.d.s1");
- paths.add("root.sg.d.s2");
- paths.add("root.sg.d.s3");
- paths.add("root.sg.d.s4");
- paths.add("root.sg.d.s5");
- paths.add("root.sg.d.s6");
- List<TSDataType> tsDataTypes = new ArrayList<>();
- tsDataTypes.add(TSDataType.BOOLEAN);
- tsDataTypes.add(TSDataType.INT32);
- tsDataTypes.add(TSDataType.INT64);
- tsDataTypes.add(TSDataType.FLOAT);
- tsDataTypes.add(TSDataType.DOUBLE);
- tsDataTypes.add(TSDataType.TEXT);
- List<TSEncoding> tsEncodings = new ArrayList<>();
- tsEncodings.add(TSEncoding.RLE);
- tsEncodings.add(TSEncoding.RLE);
- tsEncodings.add(TSEncoding.RLE);
- tsEncodings.add(TSEncoding.RLE);
- tsEncodings.add(TSEncoding.RLE);
- tsEncodings.add(TSEncoding.PLAIN);
- List<CompressionType> compressionTypes = new ArrayList<>();
- compressionTypes.add(CompressionType.SNAPPY);
- compressionTypes.add(CompressionType.SNAPPY);
- compressionTypes.add(CompressionType.SNAPPY);
- compressionTypes.add(CompressionType.SNAPPY);
- compressionTypes.add(CompressionType.SNAPPY);
- compressionTypes.add(CompressionType.SNAPPY);
- session.createMultiTimeseries(
- paths, tsDataTypes, tsEncodings, compressionTypes, null, null, null, null);
-
- List<String> measurements = new ArrayList<>();
- measurements.add("s1");
- measurements.add("s2");
- measurements.add("s3");
- measurements.add("s4");
- measurements.add("s5");
- measurements.add("s6");
- List<Object> values = new ArrayList<>();
- values.add(false);
- values.add(1);
- values.add((long) 1);
- values.add((float) 1.0);
- values.add(1.0);
- values.add("1");
- session.insertRecord("root.sg.d", 1, measurements, tsDataTypes, values);
-
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select * from root.sg.d where time=70 fill(all[previous, 1m])");
- RowRecord record = dataSet.next();
- assertEquals(70, record.getTimestamp());
- for (Field field : record.getFields()) {
- switch (field.getDataType()) {
- case TEXT:
- break;
- case FLOAT:
- assertEquals(1.0, field.getFloatV(), 0);
- break;
- case INT32:
- assertEquals(1, field.getIntV());
- break;
- case INT64:
- assertEquals(1, field.getLongV());
- break;
- case DOUBLE:
- assertEquals(1.0, field.getDoubleV(), 0);
- break;
- case BOOLEAN:
- assertEquals(false, field.getBoolV());
- break;
- }
- }
- session.close();
- }
-
- @Test
- public void testInsertOneDeviceRecordsWithOrder()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- List<Long> times = new ArrayList<>();
- List<List<String>> measurements = new ArrayList<>();
- List<List<TSDataType>> datatypes = new ArrayList<>();
- List<List<Object>> values = new ArrayList<>();
-
- addLine(
- times,
- measurements,
- datatypes,
- values,
- 1L,
- "s4",
- "s5",
- TSDataType.FLOAT,
- TSDataType.BOOLEAN,
- 5.0f,
- Boolean.TRUE);
- addLine(
- times,
- measurements,
- datatypes,
- values,
- 2L,
- "s2",
- "s3",
- TSDataType.INT32,
- TSDataType.INT64,
- 3,
- 4L);
- addLine(
- times,
- measurements,
- datatypes,
- values,
- 3L,
- "s1",
- "s2",
- TSDataType.INT32,
- TSDataType.INT32,
- 1,
- 2);
-
- session.insertRecordsOfOneDevice("root.sg.d1", times, measurements, datatypes, values, true);
- checkResult(session);
- session.close();
- }
-
- @Test
- public void testInsertOneDeviceRecordsWithIncorrectOrder()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- List<Long> times = new ArrayList<>();
- List<List<String>> measurements = new ArrayList<>();
- List<List<TSDataType>> datatypes = new ArrayList<>();
- List<List<Object>> values = new ArrayList<>();
-
- addLine(
- times,
- measurements,
- datatypes,
- values,
- 2L,
- "s2",
- "s3",
- TSDataType.INT32,
- TSDataType.INT64,
- 3,
- 4L);
- addLine(
- times,
- measurements,
- datatypes,
- values,
- 3L,
- "s1",
- "s2",
- TSDataType.INT32,
- TSDataType.INT32,
- 1,
- 2);
- addLine(
- times,
- measurements,
- datatypes,
- values,
- 1L,
- "s4",
- "s5",
- TSDataType.FLOAT,
- TSDataType.BOOLEAN,
- 5.0f,
- Boolean.TRUE);
-
- session.insertRecordsOfOneDevice("root.sg.d1", times, measurements, datatypes, values, true);
- checkResult(session);
- session.close();
- }
-
- @Test
- public void testInsertStringRecordsOfOneDeviceWithOrder()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- List<Long> times = new ArrayList<>();
- List<List<String>> measurements = new ArrayList<>();
- List<List<String>> values = new ArrayList<>();
-
- addStringLine(times, measurements, values, 1L, "s4", "s5", "5.0", "true");
- addStringLine(times, measurements, values, 2L, "s2", "s3", "3", "4");
- addStringLine(times, measurements, values, 3L, "s1", "s2", "false", "6");
-
- session.insertStringRecordsOfOneDevice("root.sg.d1", times, measurements, values, true);
- checkResultForInsertStringRecordsOfOneDevice(session);
- session.close();
- }
-
- @Test
- public void testInsertStringRecordsOfOneDeviceWithIncorrectOrder()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- List<Long> times = new ArrayList<>();
- List<List<String>> measurements = new ArrayList<>();
- List<List<String>> values = new ArrayList<>();
-
- addStringLine(times, measurements, values, 2L, "s2", "s3", "3", "4");
- addStringLine(times, measurements, values, 1L, "s4", "s5", "5.0", "true");
- addStringLine(times, measurements, values, 3L, "s1", "s2", "false", "6");
-
- session.insertStringRecordsOfOneDevice("root.sg.d1", times, measurements, values);
- checkResultForInsertStringRecordsOfOneDevice(session);
- session.close();
- }
-
- @Test
- public void testInsertAlignedStringRecordsOfOneDeviceWithOrder()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- List<Long> times = new ArrayList<>();
- List<List<String>> measurements = new ArrayList<>();
- List<List<String>> values = new ArrayList<>();
-
- addStringLine(times, measurements, values, 1L, "s4", "s5", "5.0", "true");
- addStringLine(times, measurements, values, 2L, "s2", "s3", "3", "4");
- addStringLine(times, measurements, values, 3L, "s1", "s2", "false", "6");
-
- session.insertAlignedStringRecordsOfOneDevice("root.sg.d1", times, measurements, values, true);
- checkResultForInsertStringRecordsOfOneDevice(session);
- session.close();
- }
-
- @Test
- public void testInsertAlignedStringRecordsOfOneDeviceWithIncorrectOrder()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- List<Long> times = new ArrayList<>();
- List<List<String>> measurements = new ArrayList<>();
- List<List<String>> values = new ArrayList<>();
-
- addStringLine(times, measurements, values, 2L, "s2", "s3", "3", "4");
- addStringLine(times, measurements, values, 1L, "s4", "s5", "5.0", "true");
- addStringLine(times, measurements, values, 3L, "s1", "s2", "false", "6");
-
- session.insertAlignedStringRecordsOfOneDevice("root.sg.d1", times, measurements, values);
- checkResultForInsertStringRecordsOfOneDevice(session);
- session.close();
- }
-
- @Test
- public void testInsertIlligalPath() throws IoTDBConnectionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- String msg = "[%s] Exception occurred: %s failed. %s is not a legal path";
- String deviceId = "root.sg..d1";
- List<String> deviceIds = Arrays.asList("root.sg..d1", "root.sg.d2");
- List<Long> timestamps = Arrays.asList(1L, 1L);
- List<String> measurements = Arrays.asList("s1", "s2", "s3");
- List<List<String>> allMeasurements = Arrays.asList(measurements, measurements);
- List<TSDataType> tsDataTypes =
- Arrays.asList(TSDataType.INT32, TSDataType.FLOAT, TSDataType.TEXT);
- List<List<TSDataType>> allTsDataTypes = Arrays.asList(tsDataTypes, tsDataTypes);
- List<TSEncoding> tsEncodings =
- Arrays.asList(TSEncoding.PLAIN, TSEncoding.PLAIN, TSEncoding.PLAIN);
- List<CompressionType> compressionTypes =
- Arrays.asList(CompressionType.SNAPPY, CompressionType.SNAPPY, CompressionType.SNAPPY);
- List<Object> values = Arrays.asList(1, 2f, "3");
- List<List<Object>> allValues = Arrays.asList(values, values);
- List<String> stringValues = Arrays.asList("1", "2", "3");
- List<List<String>> allstringValues = Arrays.asList(stringValues, stringValues);
-
- try {
- session.insertRecords(deviceIds, timestamps, allMeasurements, allTsDataTypes, allValues);
- fail("Exception expected");
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains(
- String.format(
- msg, TSStatusCode.PATH_ILLEGAL, OperationType.INSERT_RECORDS, deviceId)));
- }
-
- try {
- session.insertRecords(deviceIds, Arrays.asList(2L, 2L), allMeasurements, allstringValues);
- fail("Exception expected");
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains(
- String.format(
- msg,
- TSStatusCode.PATH_ILLEGAL,
- OperationType.INSERT_STRING_RECORDS,
- deviceIds.get(0))));
- }
-
- try {
- session.insertRecord(deviceId, 3L, measurements, tsDataTypes, values);
- fail("Exception expected");
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains(
- String.format(
- msg, TSStatusCode.PATH_ILLEGAL, OperationType.INSERT_RECORD, deviceId)));
- }
-
- try {
- session.insertRecord(deviceId, 4L, measurements, stringValues);
- fail("Exception expected");
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains(
- String.format(
- msg,
- TSStatusCode.PATH_ILLEGAL,
- OperationType.INSERT_STRING_RECORD,
- deviceId)));
- }
-
- try {
- session.insertRecordsOfOneDevice(
- deviceId, Arrays.asList(5L, 6L), allMeasurements, allTsDataTypes, allValues);
- fail("Exception expected");
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains(
- String.format(
- msg,
- TSStatusCode.PATH_ILLEGAL,
- OperationType.INSERT_RECORDS_OF_ONE_DEVICE,
- deviceId)));
- }
-
- try {
- session.deleteData(deviceId + ".s1", 6L);
- fail("Exception expected");
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains(
- String.format(
- msg,
- TSStatusCode.PATH_ILLEGAL,
- OperationType.DELETE_DATA,
- deviceId + ".s1")));
- }
-
- try {
- Tablet tablet =
- new Tablet(
- deviceId,
- Arrays.asList(
- new MeasurementSchema("s1", TSDataType.INT32),
- new MeasurementSchema("s2", TSDataType.FLOAT)),
- 5);
- long ts = 7L;
- for (long row = 0; row < 8; row++) {
- int rowIndex = tablet.rowSize++;
- tablet.addTimestamp(rowIndex, ts);
- tablet.addValue("s1", rowIndex, 1);
- tablet.addValue("s2", rowIndex, 1.0F);
- if (tablet.rowSize == tablet.getMaxRowNumber()) {
- session.insertTablet(tablet, true);
- tablet.reset();
- }
- ts++;
- }
- fail("Exception expected");
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains(
- String.format(
- msg, TSStatusCode.PATH_ILLEGAL, OperationType.INSERT_TABLET, deviceId)));
- }
-
- try {
- Tablet tablet1 =
- new Tablet(
- deviceId,
- Arrays.asList(
- new MeasurementSchema("s1", TSDataType.INT32),
- new MeasurementSchema("s2", TSDataType.FLOAT)),
- 5);
- Tablet tablet2 =
- new Tablet(
- "root.sg.d2",
- Arrays.asList(
- new MeasurementSchema("s1", TSDataType.INT32),
- new MeasurementSchema("s2", TSDataType.FLOAT)),
- 5);
- HashMap<String, Tablet> tablets = new HashMap<>();
- tablets.put(deviceId, tablet1);
- tablets.put("root.sg.d2", tablet2);
- long ts = 16L;
- for (long row = 0; row < 8; row++) {
- int row1 = tablet1.rowSize++;
- int row2 = tablet2.rowSize++;
- tablet1.addTimestamp(row1, ts);
- tablet2.addTimestamp(row2, ts);
- tablet1.addValue("s1", row1, 1);
- tablet1.addValue("s2", row1, 1.0F);
- tablet2.addValue("s1", row2, 1);
- tablet2.addValue("s2", row2, 1.0F);
- if (tablet1.rowSize == tablet1.getMaxRowNumber()) {
- session.insertTablets(tablets, true);
- tablet1.reset();
- tablet2.reset();
- }
- ts++;
- }
- fail("Exception expected");
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains(
- String.format(
- msg, TSStatusCode.PATH_ILLEGAL, OperationType.INSERT_TABLETS, deviceId)));
- }
-
- try {
- session.setStorageGroup("root..sg");
- fail("Exception expected");
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains(
- String.format(
- msg,
- TSStatusCode.PATH_ILLEGAL,
- OperationType.SET_STORAGE_GROUP,
- "root..sg")));
- }
-
- try {
- session.createTimeseries(
- "root.sg..d1.s1", TSDataType.INT32, TSEncoding.PLAIN, CompressionType.SNAPPY);
- fail("Exception expected");
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains(
- String.format(
- msg,
- TSStatusCode.PATH_ILLEGAL,
- OperationType.CREATE_TIMESERIES,
- "root.sg..d1.s1")));
- }
-
- try {
- session.createAlignedTimeseries(
- deviceId,
- measurements,
- tsDataTypes,
- tsEncodings,
- compressionTypes,
- Arrays.asList("alias1", "alias2", "alias3"),
- null,
- null);
-
- fail("Exception expected");
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains(
- String.format(
- msg,
- TSStatusCode.PATH_ILLEGAL,
- OperationType.CREATE_ALIGNED_TIMESERIES,
- deviceId)));
- }
-
- try {
- session.createMultiTimeseries(
- Arrays.asList("root.sg.d1..s1", "root.sg.d1.s2", "root.sg.d1.s3"),
- tsDataTypes,
- tsEncodings,
- compressionTypes,
- null,
- null,
- null,
- null);
- fail("Exception expected");
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains(
- String.format(
- msg,
- TSStatusCode.PATH_ILLEGAL,
- OperationType.CREATE_MULTI_TIMESERIES,
- "root.sg.d1..s1")));
- }
-
- try {
- session.deleteTimeseries("root.sg.d1..s1");
- fail("Exception expected");
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains(
- String.format(
- msg,
- TSStatusCode.PATH_ILLEGAL,
- OperationType.DELETE_TIMESERIES,
- "root.sg.d1..s1")));
- }
-
- try {
- session.deleteStorageGroup("root..sg");
- fail("Exception expected");
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains(
- String.format(
- msg,
- TSStatusCode.PATH_ILLEGAL,
- OperationType.DELETE_STORAGE_GROUPS,
- "root..sg")));
- }
-
- session.close();
- }
-
- @Test
- public void testConversionFunction()
- throws IoTDBConnectionException, StatementExecutionException {
- // connect
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- // prepare data
- String deviceId = "root.sg.d1";
- List<Long> times = new ArrayList<>();
- List<List<String>> measurementsList = new ArrayList<>();
- List<List<TSDataType>> typesList = new ArrayList<>();
- List<List<Object>> valuesList = new ArrayList<>();
-
- for (int i = 0; i <= 4; i++) {
- times.add((long) i * 2);
- measurementsList.add(Arrays.asList("s1", "s2", "s3", "s4", "s5", "s6"));
- typesList.add(
- Arrays.asList(
- TSDataType.INT32,
- TSDataType.INT64,
- TSDataType.FLOAT,
- TSDataType.DOUBLE,
- TSDataType.BOOLEAN,
- TSDataType.TEXT));
- valuesList.add(
- Arrays.asList(
- i,
- (long) i + 1,
- (float) i,
- (double) i * 2,
- new boolean[] {true, false}[i % 2],
- String.valueOf(i)));
- }
- // insert data
- session.insertRecordsOfOneDevice(deviceId, times, measurementsList, typesList, valuesList);
-
- // excepted
- String[] targetTypes = {"INT64", "INT32", "DOUBLE", "FLOAT", "TEXT", "BOOLEAN"};
- String[] excepted = {
- "0\t0\t1\t0.0\t0.0\ttrue\ttrue",
- "2\t1\t2\t1.0\t2.0\tfalse\ttrue",
- "4\t2\t3\t2.0\t4.0\ttrue\ttrue",
- "6\t3\t4\t3.0\t6.0\tfalse\ttrue",
- "8\t4\t5\t4.0\t8.0\ttrue\ttrue"
- };
-
- // query
- String[] casts = new String[targetTypes.length];
- StringBuffer buffer = new StringBuffer();
- buffer.append("select ");
- for (int i = 0; i < targetTypes.length; i++) {
- casts[i] = String.format("cast(s%s, 'type'='%s')", i + 1, targetTypes[i]);
- }
- buffer.append(StringUtils.join(casts, ","));
- buffer.append(" from root.sg.d1");
- String sql = buffer.toString();
- SessionDataSet sessionDataSet = session.executeQueryStatement(sql);
-
- // compare types
- List<String> columnTypes = sessionDataSet.getColumnTypes();
- columnTypes.remove(0);
- for (int i = 0; i < columnTypes.size(); i++) {
- assertEquals(targetTypes[i], columnTypes.get(i));
- }
-
- // compare results
- int index = 0;
- while (sessionDataSet.hasNext()) {
- RowRecord next = sessionDataSet.next();
- assertEquals(excepted[index], next.toString());
- index++;
- }
- session.close();
- }
-
- @Test
- public void testInsertDeleteWithTemplate()
- throws IoTDBConnectionException, StatementExecutionException, IOException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- initTreeTemplate("root.sg.loc1");
- List<String> measurements = new ArrayList<>();
- List<String> values = new ArrayList<>();
- String deviceId = "root.sg.loc1.sector.GPS";
- Set<String> checkSet = new HashSet<>();
- SessionDataSet dataSet;
-
- // insert record set using template
-
- measurements.add("x");
- measurements.add("y");
- values.add("1.0");
- values.add("2.0");
-
- checkSet.add("root.sg.loc1.sector.GPS.x");
- checkSet.add("root.sg.loc1.sector.GPS.y");
- checkSet.add("root.sg.loc1.sector.y");
- checkSet.add("root.sg.loc1.sector.x");
- checkSet.add("root.sg.loc1.sector.vehicle.x");
- checkSet.add("root.sg.loc1.sector.vehicle.y");
- checkSet.add("root.sg.loc1.sector.vehicle.GPS.x");
- checkSet.add("root.sg.loc1.sector.vehicle.GPS.y");
-
- session.insertRecord(deviceId, 1L, measurements, values);
- dataSet = session.executeQueryStatement("show timeseries");
- while (dataSet.hasNext()) {
- checkSet.remove(dataSet.next().getFields().get(0).toString());
- }
- assertTrue(checkSet.isEmpty());
-
- // insert aligned under unaligned node
- try {
- session.insertAlignedRecord("root.sg.loc1.sector.GPS", 3L, measurements, values);
- } catch (StatementExecutionException e) {
- assertEquals(
- "319: timeseries under this device are not aligned, please use non-aligned interface (Path: root.sg.loc1.sector.GPS)",
- e.getMessage());
- }
-
- // insert overlap unmatched series
- measurements.set(1, "speed");
- try {
- session.insertRecord(deviceId, 5L, measurements, values);
- fail();
- } catch (StatementExecutionException e) {
- assertEquals(
- "327: Path [root.sg.loc1.sector.GPS.speed] overlaps with [treeTemplate] on [GPS]",
- e.getMessage());
- }
-
- // insert tablets
- List<MeasurementSchema> schemaList = new ArrayList<>();
- schemaList.add(new MeasurementSchema("x", TSDataType.FLOAT));
- schemaList.add(new MeasurementSchema("y", TSDataType.FLOAT));
- Tablet tablet = new Tablet("root.sg.loc1.sector", schemaList);
-
- long timestamp = System.currentTimeMillis();
-
- for (long row = 0; row < 10; row++) {
- int rowIndex = tablet.rowSize++;
- tablet.addTimestamp(rowIndex, timestamp);
- tablet.addValue(
- schemaList.get(0).getMeasurementId(), rowIndex, new SecureRandom().nextFloat());
- tablet.addValue(
- schemaList.get(1).getMeasurementId(), rowIndex, new SecureRandom().nextFloat());
- timestamp++;
- }
-
- if (tablet.rowSize != 0) {
- session.insertAlignedTablet(tablet);
- tablet.reset();
- }
-
- dataSet = session.executeQueryStatement("select count(*) from root");
-
- while (dataSet.hasNext()) {
- RowRecord rowRecord = dataSet.next();
- Assert.assertEquals(10L, rowRecord.getFields().get(0).getLongV());
- Assert.assertEquals(10L, rowRecord.getFields().get(1).getLongV());
- }
-
- // delete series inside template
- try {
- session.deleteTimeseries("root.sg.loc1.sector.x");
- fail();
- } catch (StatementExecutionException e) {
- assertTrue(
- e.getMessage()
- .contains("Cannot delete a timeseries inside a template: root.sg.loc1.sector.x;"));
- }
-
- session.close();
- }
-
- @Test
- public void testCountWithTemplate()
- throws IoTDBConnectionException, StatementExecutionException, IOException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- initTreeTemplate("root.sg.loc");
-
- List<String> measurements = new ArrayList<>();
- List<String> values = new ArrayList<>();
- Set<String> checkSet = new HashSet<>();
- SessionDataSet dataSet;
-
- // invoke template template
-
- measurements.add("x");
- measurements.add("y");
- values.add("1.0");
- values.add("2.0");
-
- session.insertAlignedRecord("root.sg.loc.area", 1L, measurements, values);
- session.insertAlignedRecord("root.sg.loc", 1L, measurements, values);
-
- dataSet = session.executeQueryStatement("show timeseries");
-
- checkSet.add("root.sg.loc.x");
- checkSet.add("root.sg.loc.y");
- checkSet.add("root.sg.loc.GPS.x");
- checkSet.add("root.sg.loc.GPS.y");
- checkSet.add("root.sg.loc.vehicle.GPS.x");
- checkSet.add("root.sg.loc.vehicle.GPS.y");
- checkSet.add("root.sg.loc.vehicle.x");
- checkSet.add("root.sg.loc.vehicle.x");
-
- checkSet.add("root.sg.loc.area.x");
- checkSet.add("root.sg.loc.area.y");
- checkSet.add("root.sg.loc.area.GPS.x");
- checkSet.add("root.sg.loc.area.GPS.y");
- checkSet.add("root.sg.loc.area.vehicle.GPS.x");
- checkSet.add("root.sg.loc.area.vehicle.GPS.y");
- checkSet.add("root.sg.loc.area.vehicle.x");
- checkSet.add("root.sg.loc.area.vehicle.x");
-
- while (dataSet.hasNext()) {
- checkSet.remove(dataSet.next().getFields().get(0).toString());
- }
-
- assertTrue(checkSet.isEmpty());
- }
-
- @Test
- public void testInsertPartialTablet2()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- if (!session.checkTimeseriesExists("root.sg.d.s1")) {
- session.createTimeseries(
- "root.sg.d.s1", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- }
- if (!session.checkTimeseriesExists("root.sg.d.s2")) {
- session.createTimeseries(
- "root.sg.d.s2", TSDataType.DOUBLE, TSEncoding.GORILLA, CompressionType.SNAPPY);
- }
- if (!session.checkTimeseriesExists("root.sg.d.s3")) {
- session.createTimeseries(
- "root.sg.d.s3", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- }
- List<MeasurementSchema> schemaList = new ArrayList<>();
- schemaList.add(new MeasurementSchema("s1", TSDataType.INT64));
- schemaList.add(new MeasurementSchema("s2", TSDataType.DOUBLE));
- schemaList.add(new MeasurementSchema("s3", TSDataType.TEXT));
-
- Tablet tablet = new Tablet("root.sg.d", schemaList, 10);
-
- long timestamp = System.currentTimeMillis();
-
- for (long row = 0; row < 15; row++) {
- int rowIndex = tablet.rowSize++;
- tablet.addTimestamp(rowIndex, timestamp);
- tablet.addValue("s1", rowIndex, 1L);
- tablet.addValue("s2", rowIndex, 1D);
- tablet.addValue("s3", rowIndex, new Binary("1"));
- if (tablet.rowSize == tablet.getMaxRowNumber()) {
- try {
- session.insertTablet(tablet, true);
- } catch (StatementExecutionException e) {
- Assert.assertEquals(313, e.getStatusCode());
- }
- tablet.reset();
- }
- timestamp++;
- }
-
- if (tablet.rowSize != 0) {
- try {
- session.insertTablet(tablet);
- } catch (StatementExecutionException e) {
- Assert.assertEquals(313, e.getStatusCode());
- }
- tablet.reset();
- }
-
- SessionDataSet dataSet =
- session.executeQueryStatement("select count(s1), count(s2), count(s3) from root.sg.d");
- while (dataSet.hasNext()) {
- RowRecord rowRecord = dataSet.next();
- Assert.assertEquals(15L, rowRecord.getFields().get(0).getLongV());
- Assert.assertEquals(15L, rowRecord.getFields().get(1).getLongV());
- Assert.assertEquals(0L, rowRecord.getFields().get(2).getLongV());
- }
- session.close();
- }
-
- @Test
- public void testInsertBinaryAsText()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
- // prepare binary data
- List<Object> bytesData = new ArrayList<>();
- for (int i = 0; i < 3; i++) {
- byte[] bytes = new byte[128];
- for (int j = 0; j < 128; j++) {
- bytes[j] = Byte.valueOf("" + (j - i), 10);
- }
- bytesData.add(bytes);
- }
- // insert data using insertRecord
- for (int i = 0; i < bytesData.size(); i++) {
- byte[] data = (byte[]) bytesData.get(i);
- Binary dataBinary = new Binary(data);
- session.insertRecord(
- "root.sg1.d1",
- i,
- Collections.singletonList("s0"),
- Collections.singletonList(TSDataType.TEXT),
- dataBinary);
- }
- // insert data using insertTablet
- List<MeasurementSchema> schemaList = new ArrayList<>();
- schemaList.add(new MeasurementSchema("s1", TSDataType.TEXT));
- Tablet tablet = new Tablet("root.sg1.d1", schemaList, 100);
- for (int i = 0; i < bytesData.size(); i++) {
- byte[] data = (byte[]) bytesData.get(i);
- int rowIndex = tablet.rowSize++;
- tablet.addTimestamp(rowIndex, i);
- Binary dataBinary = new Binary(data);
- tablet.addValue(schemaList.get(0).getMeasurementId(), rowIndex, dataBinary);
- }
- session.insertTablet(tablet);
- // check result
- SessionDataSet dataSet = session.executeQueryStatement("select ** from root.sg1.d1");
- Assert.assertArrayEquals(
- dataSet.getColumnNames().toArray(new String[0]),
- new String[] {"Time", "root.sg1.d1.s0", "root.sg1.d1.s1"});
- while (dataSet.hasNext()) {
- RowRecord rowRecord = dataSet.next();
- for (int i = 0; i < 2; i++) {
- // get Binary value from SessionDataSet
- byte[] actualBytes = rowRecord.getFields().get(i).getBinaryV().getValues();
- // compare Binary value to origin bytesData
- byte[] expectedBytes = (byte[]) bytesData.get((int) rowRecord.getTimestamp());
- Assert.assertArrayEquals(expectedBytes, actualBytes);
- }
- }
- dataSet.closeOperationHandle();
- session.close();
- }
-
- private void initTreeTemplate(String path)
- throws IoTDBConnectionException, StatementExecutionException, IOException {
- Template sessionTemplate = new Template("treeTemplate", true);
- TemplateNode iNodeGPS = new InternalNode("GPS", false);
- TemplateNode iNodeV = new InternalNode("vehicle", true);
- TemplateNode mNodeX =
- new MeasurementNode("x", TSDataType.FLOAT, TSEncoding.RLE, CompressionType.SNAPPY);
- TemplateNode mNodeY =
- new MeasurementNode("y", TSDataType.FLOAT, TSEncoding.RLE, CompressionType.SNAPPY);
- ByteArrayOutputStream stream = new ByteArrayOutputStream();
-
- iNodeGPS.addChild(mNodeX);
- iNodeGPS.addChild(mNodeY);
-
- iNodeV.addChild(mNodeX);
- iNodeV.addChild(mNodeY);
- iNodeV.addChild(iNodeGPS);
-
- sessionTemplate.addToTemplate(iNodeGPS);
- sessionTemplate.addToTemplate(iNodeV);
- sessionTemplate.addToTemplate(mNodeX);
- sessionTemplate.addToTemplate(mNodeY);
-
- session.createSchemaTemplate(sessionTemplate);
- session.setSchemaTemplate("treeTemplate", path);
- }
-
- private void checkResult(Session session)
- throws StatementExecutionException, IoTDBConnectionException {
- SessionDataSet dataSet = session.executeQueryStatement("select * from root.sg.d1");
- dataSet.getColumnNames();
- Assert.assertArrayEquals(
- dataSet.getColumnNames().toArray(new String[0]),
- new String[] {
- "Time",
- "root.sg.d1.s3",
- "root.sg.d1.s4",
- "root.sg.d1.s5",
- "root.sg.d1.s1",
- "root.sg.d1.s2"
- });
- Assert.assertArrayEquals(
- dataSet.getColumnTypes().toArray(new String[0]),
- new String[] {
- String.valueOf(TSDataType.INT64),
- String.valueOf(TSDataType.INT64),
- String.valueOf(TSDataType.FLOAT),
- String.valueOf(TSDataType.BOOLEAN),
- String.valueOf(TSDataType.INT32),
- String.valueOf(TSDataType.INT32)
- });
- long time = 1L;
- //
- Assert.assertTrue(dataSet.hasNext());
- RowRecord record = dataSet.next();
- Assert.assertEquals(time, record.getTimestamp());
- time++;
- assertNulls(record, new int[] {0, 3, 4});
- Assert.assertEquals(5.0f, record.getFields().get(1).getFloatV(), 0.01);
- Assert.assertEquals(Boolean.TRUE, record.getFields().get(2).getBoolV());
-
- Assert.assertTrue(dataSet.hasNext());
- record = dataSet.next();
- Assert.assertEquals(time, record.getTimestamp());
- time++;
- assertNulls(record, new int[] {1, 2, 3});
- Assert.assertEquals(4L, record.getFields().get(0).getLongV());
- Assert.assertEquals(3, record.getFields().get(4).getIntV());
-
- Assert.assertTrue(dataSet.hasNext());
- record = dataSet.next();
- Assert.assertEquals(time, record.getTimestamp());
- time++;
- assertNulls(record, new int[] {0, 1, 2});
- Assert.assertEquals(1, record.getFields().get(3).getIntV());
- Assert.assertEquals(2, record.getFields().get(4).getIntV());
-
- Assert.assertFalse(dataSet.hasNext());
- dataSet.closeOperationHandle();
- }
-
- private void checkResultForInsertStringRecordsOfOneDevice(Session session)
- throws StatementExecutionException, IoTDBConnectionException {
- SessionDataSet dataSet = session.executeQueryStatement("select * from root.sg.d1");
- dataSet.getColumnNames();
- Assert.assertArrayEquals(
- dataSet.getColumnNames().toArray(new String[0]),
- new String[] {
- "Time",
- "root.sg.d1.s3",
- "root.sg.d1.s4",
- "root.sg.d1.s5",
- "root.sg.d1.s1",
- "root.sg.d1.s2"
- });
- Assert.assertArrayEquals(
- dataSet.getColumnTypes().toArray(new String[0]),
- new String[] {
- String.valueOf(TSDataType.INT64),
- String.valueOf(TSDataType.FLOAT),
- String.valueOf(TSDataType.FLOAT),
- String.valueOf(TSDataType.BOOLEAN),
- String.valueOf(TSDataType.BOOLEAN),
- String.valueOf(TSDataType.FLOAT)
- });
- long time = 1L;
-
- Assert.assertTrue(dataSet.hasNext());
- RowRecord record = dataSet.next();
- Assert.assertEquals(time, record.getTimestamp());
- time++;
-
- assertNulls(record, new int[] {0, 3, 4});
- Assert.assertEquals(5.0f, record.getFields().get(1).getFloatV(), 0.01);
- Assert.assertEquals(Boolean.TRUE, record.getFields().get(2).getBoolV());
-
- Assert.assertTrue(dataSet.hasNext());
- record = dataSet.next();
- Assert.assertEquals(time, record.getTimestamp());
- time++;
-
- assertNulls(record, new int[] {1, 2, 3});
- Assert.assertEquals(4, record.getFields().get(0).getFloatV(), 0.01);
- Assert.assertEquals(3, record.getFields().get(4).getFloatV(), 0.01);
-
- Assert.assertTrue(dataSet.hasNext());
- record = dataSet.next();
- Assert.assertEquals(time, record.getTimestamp());
- time++;
-
- assertNulls(record, new int[] {0, 1, 2});
- Assert.assertEquals(false, record.getFields().get(3).getBoolV());
- Assert.assertEquals(6, record.getFields().get(4).getFloatV(), 0.01);
-
- Assert.assertFalse(dataSet.hasNext());
- dataSet.closeOperationHandle();
- }
-
- private void addLine(
- List<Long> times,
- List<List<String>> measurements,
- List<List<TSDataType>> datatypes,
- List<List<Object>> values,
- long time,
- String s1,
- String s2,
- TSDataType s1type,
- TSDataType s2type,
- Object value1,
- Object value2) {
- List<String> tmpMeasurements = new ArrayList<>();
- List<TSDataType> tmpDataTypes = new ArrayList<>();
- List<Object> tmpValues = new ArrayList<>();
- tmpMeasurements.add(s1);
- tmpMeasurements.add(s2);
- tmpDataTypes.add(s1type);
- tmpDataTypes.add(s2type);
- tmpValues.add(value1);
- tmpValues.add(value2);
- times.add(time);
- measurements.add(tmpMeasurements);
- datatypes.add(tmpDataTypes);
- values.add(tmpValues);
- }
-
- private void addStringLine(
- List<Long> times,
- List<List<String>> measurements,
- List<List<String>> values,
- long time,
- String s1,
- String s2,
- String value1,
- String value2) {
- List<String> tmpMeasurements = new ArrayList<>();
- List<String> tmpValues = new ArrayList<>();
- tmpMeasurements.add(s1);
- tmpMeasurements.add(s2);
- tmpValues.add(value1);
- tmpValues.add(value2);
- times.add(time);
- measurements.add(tmpMeasurements);
- values.add(tmpValues);
- }
-
- private void assertNulls(RowRecord record, int[] index) {
- for (int i : index) {
- Assert.assertNull(record.getFields().get(i).getDataType());
- }
- }
-}
diff --git a/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionSyntaxConventionIT.java b/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionSyntaxConventionIT.java
deleted file mode 100644
index 5dfb297050..0000000000
--- a/integration/src/test/java/org/apache/iotdb/session/IoTDBSessionSyntaxConventionIT.java
+++ /dev/null
@@ -1,415 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.iotdb.session;
-
-import org.apache.iotdb.commons.conf.IoTDBConstant;
-import org.apache.iotdb.db.utils.EnvironmentUtils;
-import org.apache.iotdb.itbase.category.LocalStandaloneTest;
-import org.apache.iotdb.rpc.IoTDBConnectionException;
-import org.apache.iotdb.rpc.StatementExecutionException;
-import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
-import org.apache.iotdb.tsfile.utils.Binary;
-import org.apache.iotdb.tsfile.write.record.Tablet;
-import org.apache.iotdb.tsfile.write.schema.MeasurementSchema;
-
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.fail;
-
-@Category({LocalStandaloneTest.class})
-public class IoTDBSessionSyntaxConventionIT {
-
- private Session session;
-
- @Before
- public void setUp() {
- System.setProperty(IoTDBConstant.IOTDB_CONF, "src/test/resources/");
- EnvironmentUtils.envSetUp();
- }
-
- @After
- public void tearDown() throws Exception {
- session.close();
- EnvironmentUtils.cleanEnv();
- }
-
- @Test
- public void createTimeSeries() throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- String storageGroup = "root.sg";
- session.setStorageGroup(storageGroup);
-
- try {
- session.createTimeseries(
- "root.sg.d1.`a.s1", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- fail();
- } catch (Exception e) {
- Assert.assertTrue(e.getMessage().contains("is not a legal path"));
- }
-
- try {
- session.createTimeseries(
- "root.sg.d1.a`.s1", TSDataType.INT64, TSEncoding.RLE, CompressionType.SNAPPY);
- fail();
- } catch (Exception e) {
- Assert.assertTrue(e.getMessage().contains("is not a legal path"));
- }
-
- final SessionDataSet dataSet = session.executeQueryStatement("SHOW TIMESERIES");
- assertFalse(dataSet.hasNext());
-
- session.deleteStorageGroup(storageGroup);
- session.close();
- }
-
- @Test
- public void testInsert() throws Exception {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- String deviceId = "root.sg1.d1";
- List<String> measurements = new ArrayList<>();
-
- measurements.add("`\"a“（Φ）”b\"`");
- measurements.add("`\"a>b\"`");
- measurements.add("```a.b```");
- measurements.add("`'a“（Φ）”b'`");
- measurements.add("`'a>b'`");
- measurements.add("`a“（Φ）”b`");
- measurements.add("`a>b`");
- measurements.add("`\\\"a`");
- List<String> values = new ArrayList<>();
-
- for (int i = 0; i < measurements.size(); i++) {
- values.add("1");
- }
-
- session.insertRecord(deviceId, 1L, measurements, values);
-
- Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.`\"a“（Φ）”b\"`"));
- Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.`\"a>b\"`"));
- Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.```a.b```"));
- Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.`'a“（Φ）”b'`"));
- Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.`'a>b'`"));
- Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.`a“（Φ）”b`"));
- Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.`a>b`"));
- Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.`\\\"a`"));
-
- session.close();
- }
-
- @Test
- public void testInserRecordWithIllegalMeasurement()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- String deviceId = "root.sg1.d1";
- List<String> measurements = new ArrayList<>();
- List<String> values = new ArrayList<>();
- measurements.add("a.b");
- values.add("1");
- try {
- session.insertRecord(deviceId, 1L, measurements, values);
- } catch (Exception e) {
- e.printStackTrace();
- }
-
- measurements.clear();
- values.clear();
- measurements.add("111");
- values.add("1.2");
- try {
- session.insertRecord(deviceId, 1L, measurements, values);
- } catch (Exception e) {
- e.printStackTrace();
- }
-
- measurements.clear();
- values.clear();
- measurements.add("`a");
- values.add("1.2");
- try {
- session.insertRecord(deviceId, 1L, measurements, values);
- } catch (Exception e) {
- e.printStackTrace();
- }
-
- measurements.clear();
- values.clear();
- measurements.add("a..b");
- values.add("1.2");
- try {
- session.insertRecord(deviceId, 1L, measurements, values);
- } catch (Exception e) {
- e.printStackTrace();
- }
-
- measurements.clear();
- values.clear();
- measurements.add("");
- values.add("1.2");
- try {
- session.insertRecord(deviceId, 1L, measurements, values);
- } catch (Exception e) {
- e.printStackTrace();
- }
-
- measurements.clear();
- values.clear();
- measurements.add("`a``");
- values.add("1.2");
- try {
- session.insertRecord(deviceId, 1L, measurements, values);
- } catch (Exception e) {
- e.printStackTrace();
- }
-
- measurements.clear();
- values.clear();
- measurements.add("`ab````");
- values.add("1.2");
- try {
- session.insertRecord(deviceId, 1L, measurements, values);
- } catch (Exception e) {
- e.printStackTrace();
- }
-
- SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
- Assert.assertFalse(dataSet.hasNext());
- }
-
- @Test
- public void testInsertRecordsWithIllegalMeasurement()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- String deviceId = "root.sg1.d1";
- List<String> measurements = new ArrayList<>();
- measurements.add("a.b");
- measurements.add("111");
- measurements.add("`a");
- measurements.add("a..b");
-
- List<String> values = new ArrayList<>();
- values.add("1");
- values.add("1.2");
- values.add("true");
- values.add("dad");
-
- List<Long> times = new ArrayList<>();
- times.add(1L);
- try {
- session.insertRecords(
- Collections.singletonList(deviceId),
- times,
- Collections.singletonList(measurements),
- Collections.singletonList(values));
- } catch (Exception e) {
- e.printStackTrace();
- }
-
- SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
- Assert.assertFalse(dataSet.hasNext());
- }
-
- @Test
- public void testInsertTabletWithIllegalMeasurement()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root", null);
- session.open();
-
- String deviceId = "root.sg1.d1";
- List<MeasurementSchema> schemaList = new ArrayList<>();
- schemaList.add(new MeasurementSchema("wrong`", TSDataType.INT64, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s2", TSDataType.DOUBLE, TSEncoding.RLE));
- schemaList.add(new MeasurementSchema("s3", TSDataType.TEXT, TSEncoding.PLAIN));
- schemaList.add(new MeasurementSchema("s4", TSDataType.INT64, TSEncoding.PLAIN));
-
- Tablet tablet = new Tablet(deviceId, schemaList, 10);
-
- long[] timestamps = tablet.timestamps;
- Object[] values = tablet.values;
-
- for (long time = 0; time < 10; time++) {
- int row = tablet.rowSize++;
- timestamps[row] = time;
- long[] sensor = (long[]) values[0];
- sensor[row] = time;
- double[] sensor2 = (double[]) values[1];
- sensor2[row] = 0.1 + time;
- Binary[] sensor3 = (Binary[]) values[2];
- sensor3[row] = Binary.valueOf("ha" + time);
- long[] sensor4 = (long[]) values[3];
- sensor4[row] = time;
- }
-
- try {
- session.insertTablet(tablet);
- fail();
- } catch (Exception e) {
- e.printStackTrace();
- }
-
- SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
- Assert.assertFalse(dataSet.hasNext());
- }
-
- @Test
- public void testCreateAlignedTimeseriesWithIllegalMeasurement()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root", null);
- session.open();
-
- String deviceId = "root.sg1.d1";
- List<String> measurements = new ArrayList<>();
- measurements.add("111");
- measurements.add("a.b");
- List<TSDataType> dataTypes = new ArrayList<>();
- dataTypes.add(TSDataType.INT64);
- dataTypes.add(TSDataType.INT64);
- List<TSEncoding> encodings = new ArrayList<>();
- List<CompressionType> compressors = new ArrayList<>();
- for (int i = 1; i <= 2; i++) {
- encodings.add(TSEncoding.RLE);
- compressors.add(CompressionType.SNAPPY);
- }
- try {
- session.createAlignedTimeseries(
- deviceId, measurements, dataTypes, encodings, compressors, null, null, null);
- } catch (Exception e) {
- e.printStackTrace();
- }
- SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
- Assert.assertFalse(dataSet.hasNext());
- }
-
- @Test
- public void testCreateAlignedTimeseriesWithIllegalMeasurementAlias()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root", null);
- session.open();
-
- String deviceId = "root.sg1.d1";
- List<String> measurements = new ArrayList<>();
- measurements.add("s1");
- measurements.add("s2");
- List<String> measurementAliasList = new ArrayList<>();
- measurementAliasList.add("s3");
- measurementAliasList.add("111");
- List<TSDataType> dataTypes = new ArrayList<>();
- dataTypes.add(TSDataType.INT64);
- dataTypes.add(TSDataType.INT64);
- List<TSEncoding> encodings = new ArrayList<>();
- List<CompressionType> compressors = new ArrayList<>();
- for (int i = 1; i <= 2; i++) {
- encodings.add(TSEncoding.RLE);
- compressors.add(CompressionType.SNAPPY);
- }
- try {
- session.createAlignedTimeseries(
- deviceId,
- measurements,
- dataTypes,
- encodings,
- compressors,
- measurementAliasList,
- null,
- null);
- } catch (Exception e) {
- e.printStackTrace();
- }
- SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
- Assert.assertFalse(dataSet.hasNext());
- }
-
- @Test
- public void testCreateMultiTimeseriesWithIllegalMeasurementAlias()
- throws IoTDBConnectionException, StatementExecutionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- List<String> paths = new ArrayList<>();
- paths.add("root.sg1.d1.s1");
- paths.add("root.sg1.d1.s2");
- List<TSDataType> tsDataTypes = new ArrayList<>();
- tsDataTypes.add(TSDataType.DOUBLE);
- tsDataTypes.add(TSDataType.DOUBLE);
- List<TSEncoding> tsEncodings = new ArrayList<>();
- tsEncodings.add(TSEncoding.RLE);
- tsEncodings.add(TSEncoding.RLE);
- List<CompressionType> compressionTypes = new ArrayList<>();
- compressionTypes.add(CompressionType.SNAPPY);
- compressionTypes.add(CompressionType.SNAPPY);
- List<String> measurementAliasList = new ArrayList<>();
- measurementAliasList.add("s3");
- measurementAliasList.add("111");
-
- try {
- session.createMultiTimeseries(
- paths,
- tsDataTypes,
- tsEncodings,
- compressionTypes,
- null,
- null,
- null,
- measurementAliasList);
- } catch (StatementExecutionException e) {
- e.printStackTrace();
- }
- SessionDataSet dataSet = session.executeQueryStatement("show timeseries root");
- Assert.assertFalse(dataSet.hasNext());
- }
-
- @Test
- public void testCreateSchemaTemplateWithIllegalMeasurement() throws IoTDBConnectionException {
- session = new Session("127.0.0.1", 6667, "root", "root");
- session.open();
-
- String tempName = "flatTemplate";
- List<String> measurements = Arrays.asList("1", "2", "a.b");
- List<TSDataType> dataTypes =
- Arrays.asList(TSDataType.FLOAT, TSDataType.FLOAT, TSDataType.DOUBLE);
- List<TSEncoding> encodings = Arrays.asList(TSEncoding.RLE, TSEncoding.RLE, TSEncoding.GORILLA);
- List<CompressionType> compressors =
- Arrays.asList(CompressionType.SNAPPY, CompressionType.SNAPPY, CompressionType.LZ4);
-
- try {
- session.createSchemaTemplate(tempName, measurements, dataTypes, encodings, compressors, true);
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
-}
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/parser/StatementGenerator.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/parser/StatementGenerator.java
index 0478b11864..97a945bcc7 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/parser/StatementGenerator.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/parser/StatementGenerator.java
@@ -46,6 +46,7 @@ import org.apache.iotdb.db.mpp.plan.statement.metadata.CreateAlignedTimeSeriesSt
import org.apache.iotdb.db.mpp.plan.statement.metadata.CreateMultiTimeSeriesStatement;
import org.apache.iotdb.db.mpp.plan.statement.metadata.CreateTimeSeriesStatement;
import org.apache.iotdb.db.mpp.plan.statement.metadata.DeleteStorageGroupStatement;
+import org.apache.iotdb.db.mpp.plan.statement.metadata.DeleteTimeSeriesStatement;
import org.apache.iotdb.db.mpp.plan.statement.metadata.SetStorageGroupStatement;
import org.apache.iotdb.db.mpp.plan.statement.metadata.template.CreateSchemaTemplateStatement;
import org.apache.iotdb.db.mpp.plan.statement.metadata.template.SetSchemaTemplateStatement;
@@ -89,6 +90,7 @@ import org.antlr.v4.runtime.tree.ParseTree;
import java.nio.ByteBuffer;
import java.time.ZoneId;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
@@ -339,7 +341,9 @@ public class StatementGenerator {
statement.setDevicePath(insertStatement.getDevicePath());
addMeasurementAndValue(
statement, req.getMeasurementsList().get(i), req.getValuesList().get(i));
- statement.setDataTypes(new TSDataType[statement.getMeasurements().length]);
+ TSDataType[] dataTypes = new TSDataType[statement.getMeasurements().length];
+ Arrays.fill(dataTypes, TSDataType.TEXT);
+ statement.setDataTypes(dataTypes);
statement.setTime(req.timestamps.get(i));
statement.setNeedInferType(true);
statement.setAligned(req.isAligned);
@@ -432,7 +436,7 @@ public class StatementGenerator {
return statement;
}
- public static Statement createStatement(List<String> storageGroups) {
+ public static Statement createStatement(List<String> storageGroups) throws IllegalPathException {
DeleteStorageGroupStatement statement = new DeleteStorageGroupStatement();
statement.setPrefixPath(storageGroups);
return statement;
@@ -620,4 +624,13 @@ public class StatementGenerator {
return new SetSchemaTemplateStatement(
req.getTemplateName(), new PartialPath(req.getPrefixPath()));
}
+
+ public static DeleteTimeSeriesStatement createDeleteTimeSeriesStatement(
+ List<String> pathPatternStringList) throws IllegalPathException {
+ List<PartialPath> pathPatternList = new ArrayList<>();
+ for (String pathPatternString : pathPatternStringList) {
+ pathPatternList.add(new PartialPath(pathPatternString));
+ }
+ return new DeleteTimeSeriesStatement(pathPatternList);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/statement/metadata/DeleteTimeSeriesStatement.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/statement/metadata/DeleteTimeSeriesStatement.java
index ffc653f597..c21f590a24 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/statement/metadata/DeleteTimeSeriesStatement.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/statement/metadata/DeleteTimeSeriesStatement.java
@@ -37,6 +37,11 @@ public class DeleteTimeSeriesStatement extends Statement implements IConfigState
statementType = StatementType.DELETE_TIMESERIES;
}
+ public DeleteTimeSeriesStatement(List<PartialPath> pathPatternList) {
+ this();
+ this.pathPatternList = pathPatternList;
+ }
+
@Override
public List<PartialPath> getPaths() {
return pathPatternList;
diff --git a/server/src/main/java/org/apache/iotdb/db/service/thrift/impl/ClientRPCServiceImpl.java b/server/src/main/java/org/apache/iotdb/db/service/thrift/impl/ClientRPCServiceImpl.java
index dc3a0857fd..7bc5737345 100644
--- a/server/src/main/java/org/apache/iotdb/db/service/thrift/impl/ClientRPCServiceImpl.java
+++ b/server/src/main/java/org/apache/iotdb/db/service/thrift/impl/ClientRPCServiceImpl.java
@@ -52,6 +52,7 @@ import org.apache.iotdb.db.mpp.plan.statement.metadata.CreateAlignedTimeSeriesSt
import org.apache.iotdb.db.mpp.plan.statement.metadata.CreateMultiTimeSeriesStatement;
import org.apache.iotdb.db.mpp.plan.statement.metadata.CreateTimeSeriesStatement;
import org.apache.iotdb.db.mpp.plan.statement.metadata.DeleteStorageGroupStatement;
+import org.apache.iotdb.db.mpp.plan.statement.metadata.DeleteTimeSeriesStatement;
import org.apache.iotdb.db.mpp.plan.statement.metadata.SetStorageGroupStatement;
import org.apache.iotdb.db.mpp.plan.statement.metadata.template.CreateSchemaTemplateStatement;
import org.apache.iotdb.db.mpp.plan.statement.metadata.template.SetSchemaTemplateStatement;
@@ -330,6 +331,8 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
SCHEMA_FETCHER);
return result.status;
+ } catch (IoTDBException e) {
+ return onIoTDBException(e, OperationType.SET_STORAGE_GROUP, e.getErrorCode());
} catch (Exception e) {
return onNPEOrUnexpectedException(
e, OperationType.SET_STORAGE_GROUP, TSStatusCode.EXECUTE_STATEMENT_ERROR);
@@ -373,7 +376,7 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
return result.status;
} catch (IoTDBException e) {
- return onIoTDBException(e, OperationType.INSERT_RECORDS, e.getErrorCode());
+ return onIoTDBException(e, OperationType.CREATE_TIMESERIES, e.getErrorCode());
} catch (Exception e) {
return onNPEOrUnexpectedException(
e, OperationType.CREATE_TIMESERIES, TSStatusCode.EXECUTE_STATEMENT_ERROR);
@@ -423,7 +426,7 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
return result.status;
} catch (IoTDBException e) {
- return onIoTDBException(e, OperationType.INSERT_RECORDS, e.getErrorCode());
+ return onIoTDBException(e, OperationType.CREATE_ALIGNED_TIMESERIES, e.getErrorCode());
} catch (Exception e) {
return onNPEOrUnexpectedException(
e, OperationType.CREATE_ALIGNED_TIMESERIES, TSStatusCode.EXECUTE_STATEMENT_ERROR);
@@ -471,7 +474,7 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
return result.status;
} catch (IoTDBException e) {
- return onIoTDBException(e, OperationType.INSERT_RECORDS, e.getErrorCode());
+ return onIoTDBException(e, OperationType.CREATE_MULTI_TIMESERIES, e.getErrorCode());
} catch (Exception e) {
return onNPEOrUnexpectedException(
e, OperationType.CREATE_MULTI_TIMESERIES, TSStatusCode.EXECUTE_STATEMENT_ERROR);
@@ -480,7 +483,39 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
@Override
public TSStatus deleteTimeseries(long sessionId, List<String> path) {
- throw new UnsupportedOperationException();
+ try {
+ if (!SESSION_MANAGER.checkLogin(sessionId)) {
+ return getNotLoggedInStatus();
+ }
+
+ // Step 1: transfer from DeleteStorageGroupsReq to Statement
+ DeleteTimeSeriesStatement statement =
+ StatementGenerator.createDeleteTimeSeriesStatement(path);
+
+ // permission check
+ TSStatus status = AuthorityChecker.checkAuthority(statement, sessionId);
+ if (status.getCode() != TSStatusCode.SUCCESS_STATUS.getStatusCode()) {
+ return status;
+ }
+
+ // Step 2: call the coordinator
+ long queryId = SESSION_MANAGER.requestQueryId(false);
+ ExecutionResult result =
+ COORDINATOR.execute(
+ statement,
+ queryId,
+ SESSION_MANAGER.getSessionInfo(sessionId),
+ "",
+ PARTITION_FETCHER,
+ SCHEMA_FETCHER);
+
+ return result.status;
+ } catch (IoTDBException e) {
+ return onIoTDBException(e, OperationType.DELETE_TIMESERIES, e.getErrorCode());
+ } catch (Exception e) {
+ return onNPEOrUnexpectedException(
+ e, OperationType.DELETE_TIMESERIES, TSStatusCode.EXECUTE_STATEMENT_ERROR);
+ }
}
@Override
@@ -520,6 +555,8 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
SCHEMA_FETCHER);
return result.status;
+ } catch (IoTDBException e) {
+ return onIoTDBException(e, OperationType.DELETE_STORAGE_GROUPS, e.getErrorCode());
} catch (Exception e) {
return onNPEOrUnexpectedException(
e, OperationType.DELETE_STORAGE_GROUPS, TSStatusCode.EXECUTE_STATEMENT_ERROR);
@@ -803,7 +840,7 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
return result.status;
} catch (IoTDBException e) {
- return onIoTDBException(e, OperationType.INSERT_RECORDS, e.getErrorCode());
+ return onIoTDBException(e, OperationType.INSERT_RECORDS_OF_ONE_DEVICE, e.getErrorCode());
} catch (Exception e) {
return onNPEOrUnexpectedException(
e, OperationType.INSERT_RECORDS_OF_ONE_DEVICE, TSStatusCode.EXECUTE_STATEMENT_ERROR);
@@ -858,7 +895,8 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
return result.status;
} catch (IoTDBException e) {
- return onIoTDBException(e, OperationType.INSERT_RECORDS, e.getErrorCode());
+ return onIoTDBException(
+ e, OperationType.INSERT_STRING_RECORDS_OF_ONE_DEVICE, e.getErrorCode());
} catch (Exception e) {
return onNPEOrUnexpectedException(
e,
@@ -911,7 +949,7 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
return result.status;
} catch (IoTDBException e) {
- return onIoTDBException(e, OperationType.INSERT_RECORDS, e.getErrorCode());
+ return onIoTDBException(e, OperationType.INSERT_RECORD, e.getErrorCode());
} catch (Exception e) {
return onNPEOrUnexpectedException(
e, OperationType.INSERT_RECORD, TSStatusCode.EXECUTE_STATEMENT_ERROR);
@@ -957,7 +995,7 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
return result.status;
} catch (IoTDBException e) {
- return onIoTDBException(e, OperationType.INSERT_RECORDS, e.getErrorCode());
+ return onIoTDBException(e, OperationType.INSERT_TABLETS, e.getErrorCode());
} catch (Exception e) {
return onNPEOrUnexpectedException(
e, OperationType.INSERT_TABLETS, TSStatusCode.EXECUTE_STATEMENT_ERROR);
@@ -1003,7 +1041,7 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
return result.status;
} catch (IoTDBException e) {
- return onIoTDBException(e, OperationType.INSERT_RECORDS, e.getErrorCode());
+ return onIoTDBException(e, OperationType.INSERT_TABLET, e.getErrorCode());
} catch (Exception e) {
return onNPEOrUnexpectedException(
e, OperationType.INSERT_TABLET, TSStatusCode.EXECUTE_STATEMENT_ERROR);
@@ -1055,7 +1093,7 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
return result.status;
} catch (IoTDBException e) {
- return onIoTDBException(e, OperationType.INSERT_RECORDS, e.getErrorCode());
+ return onIoTDBException(e, OperationType.INSERT_STRING_RECORDS, e.getErrorCode());
} catch (Exception e) {
return onNPEOrUnexpectedException(
e, OperationType.INSERT_STRING_RECORDS, TSStatusCode.EXECUTE_STATEMENT_ERROR);
@@ -1539,7 +1577,7 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
return result.status;
} catch (IoTDBException e) {
- return onIoTDBException(e, OperationType.INSERT_RECORDS, e.getErrorCode());
+ return onIoTDBException(e, OperationType.INSERT_STRING_RECORD, e.getErrorCode());
} catch (Exception e) {
return onNPEOrUnexpectedException(
e, OperationType.INSERT_STRING_RECORD, TSStatusCode.EXECUTE_STATEMENT_ERROR);