apache iotdb 初步使用以及遇到的问题

落日映苍穹つ 2022-12-25 11:56 381阅读 0赞

# 0，遇到的问题 #

1）日志显示跟flink的冲突，需要排除

<dependency>
        <groupId>org.apache.iotdb</groupId>
        <artifactId>flink-iotdb-connector</artifactId>
        <version>0.11.0</version>
        <exclusions>
            <exclusion>
                <artifactId>logback-classic</artifactId>
                <groupId>ch.qos.logback</groupId>
            </exclusion>
        </exclusions>
    </dependency>

2) 在flink任务重启的时候会报错：（这里是验证flink并行度 1跟大于1的时候）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70][]

存储组已经存在。

需要将 77行要给try-catch起来，修改源码再编译，不过官方已经解决发布了

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 1][]

3）源码问题

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 2][]

大家可以测试，会报错

![20201204102302668.png][]

错误地点在tablet类

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 3][]

目前官方已经修改。

# 1，安装iotdb  #

1）下载zip包

[https://iotdb.apache.org/Download/][https_iotdb.apache.org_Download]

unzip 解压

启动：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 4][]

# 2，Flink代码写入iotdb #

import com.google.common.collect.Lists;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.api.functions.source.SourceFunction;
    import org.apache.iotdb.flink.DefaultIoTSerializationSchema;
    import org.apache.iotdb.flink.IoTDBOptions;
    import org.apache.iotdb.flink.IoTDBSink;
    import org.apache.iotdb.flink.IoTSerializationSchema;
    
    import java.util.*;
    
    /**
     * @program: flink-neiwang-dev
     * @description: iotdb测试
     * @author: Mr.Wang
     * @create: 2020-12-01 15:38
     **/
    
    
    public class IoTDBSinkInsertTest {
        public static void main(String[] args) throws Exception {
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    
            IoTDBOptions options = new IoTDBOptions();
            options.setHost("192.168.6.36");
            options.setPort(6667);
            options.setUser("root");
            options.setPassword("root");
            options.setStorageGroup("root.test1");
            options.setTimeseriesOptionList(
                    Lists.newArrayList(
                            new IoTDBOptions.TimeseriesOption("root.test1.D01.aaa"),
                            new IoTDBOptions.TimeseriesOption("root.test1.D01.bbb"),
                            new IoTDBOptions.TimeseriesOption("root.test1.D01.ccc")
                    )
            );
    
            IoTSerializationSchema serializationSchema = new DefaultIoTSerializationSchema();
            IoTDBSink ioTDBSink = new IoTDBSink(options, serializationSchema)
                    // enable batching
                    .withBatchSize(10) ;
    
    
            env.addSource(new SensorSource())
                    .name("sensor-source")
                    .setParallelism(1)
                    .addSink(ioTDBSink)
                    .name("iotdb-sink")
                    .setParallelism(1);
    
    
            env.execute("iotdb-flink-example");
        }
        private static class SensorSource implements SourceFunction< Map<String, Object>> {
            private static final long serialVersionUID = 1L;
    
    
            private volatile boolean isRunning = true;
            private int counter = 0;
    
            /**
             * @Description:
             * @Param:
             * @return:
             * @Author: intsmaze
             * @Date: 2019/1/5
             */
            @Override
            public void run(SourceFunction.SourceContext< Map<String, Object>> ctx) throws Exception {
                Random random = new Random();
                String[] strArray={"aaa","bbb","ccc"};
    
            while (true){
                Thread.sleep(5000);
                int index = random.nextInt(3);
                Map<String, Object> tuple = new HashMap();
                tuple.put("device", "root.test1.D01");
                long timeMillis = System.currentTimeMillis();
                tuple.put("timestamp", String.valueOf(timeMillis));
                tuple.put("measurements", "aa,bb,cc");
    
                tuple.put("types", "TEXT,TEXT,TEXT");
                tuple.put("values", "1,2,3");
    //            tuple.put("values", String.valueOf(index));
    
                ctx.collect(tuple);
            }
    
            }
    
            @Override
            public void cancel() {
                isRunning = false;
            }
        }
    
    
    }

需要导入依赖：

<dependency>
         <groupId>org.apache.iotdb</groupId>
         <artifactId>flink-iotdb-connector</artifactId>
         <version>0.11.0</version>
     </dependency>

# 3，进入客户端查看结果 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 6][]

# 4，初步理解   ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 7][] #

如上图，我们理解为：

电力集团层-电厂层-设备层-传感器层

### 最左侧路径对应的时间序列名称为`ROOT.ln.wf01.wt01.status   解释为：电力集团in-电厂wf01-设备wt01-`**传感器status** ###

在上面的代码里面，每次写入iotdb是Map的格式。

**在代码层面没有List<Map<>>的概率，在下面 的设置中就是批的意思**

**这个实际上就是攒多少条的意思，攒够10条才调用接口就发送一次。**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 8][]

# 5，案例代码： #

[https://github.com/apache/iotdb/blob/master/example/session/src/main/java/org/apache/iotdb/SessionExample.java][https_github.com_apache_iotdb_blob_master_example_session_src_main_java_org_apache_iotdb_SessionExample.java]

package org.apache.iotdb;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Random;
    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.Session;
    import org.apache.iotdb.session.SessionDataSet;
    import org.apache.iotdb.session.SessionDataSet.DataIterator;
    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.write.record.Tablet;
    import org.apache.iotdb.tsfile.write.schema.MeasurementSchema;
    
    public class SessionExample {
    
      private static Session session;
      private static final String ROOT_SG1_D1_S1 = "root.sg1.d1.s1";
      private static final String ROOT_SG1_D1_S2 = "root.sg1.d1.s2";
      private static final String ROOT_SG1_D1_S3 = "root.sg1.d1.s3";
      private static final String ROOT_SG1_D1_S4 = "root.sg1.d1.s4";
      private static final String ROOT_SG1_D1_S5 = "root.sg1.d1.s5";
      private static final String ROOT_SG1_D1 = "root.sg1.d1";
    
    
      public static void main(String[] args)
          throws IoTDBConnectionException, StatementExecutionException {
        session = new Session("127.0.0.1", 6667, "root", "root");
        session.open(false);
    
        try {
          session.setStorageGroup("root.sg1");
        } catch (StatementExecutionException e) {
          if (e.getStatusCode() != TSStatusCode.PATH_ALREADY_EXIST_ERROR.getStatusCode())
            throw e;
        }
    
        createTimeseries();
        createMultiTimeseries();
        insertRecord();
        insertTablet();
        insertTablets();
        insertRecords();
        nonQuery();
        query();
        rawDataQuery();
        queryByIterator();
        deleteData();
        deleteTimeseries();
        session.close();
      }
    
      private static void createTimeseries()
          throws IoTDBConnectionException, StatementExecutionException {
    
        if (!session.checkTimeseriesExists(ROOT_SG1_D1_S1)) {
          session.createTimeseries(ROOT_SG1_D1_S1, TSDataType.INT64, TSEncoding.RLE,
              CompressionType.SNAPPY);
        }
        if (!session.checkTimeseriesExists(ROOT_SG1_D1_S2)) {
          session.createTimeseries(ROOT_SG1_D1_S2, TSDataType.INT64, TSEncoding.RLE,
              CompressionType.SNAPPY);
        }
        if (!session.checkTimeseriesExists(ROOT_SG1_D1_S3)) {
          session.createTimeseries(ROOT_SG1_D1_S3, TSDataType.INT64, TSEncoding.RLE,
              CompressionType.SNAPPY);
        }
    
        // create timeseries with tags and attributes
        if (!session.checkTimeseriesExists(ROOT_SG1_D1_S4)) {
          Map<String, String> tags = new HashMap<>();
          tags.put("tag1", "v1");
          Map<String, String> attributes = new HashMap<>();
          tags.put("description", "v1");
          session.createTimeseries(ROOT_SG1_D1_S4, TSDataType.INT64, TSEncoding.RLE,
              CompressionType.SNAPPY, null, tags, attributes, "temperature");
        }
    
        // create timeseries with SDT property, SDT will take place when flushing
        if (!session.checkTimeseriesExists(ROOT_SG1_D1_S5)) {
          // compDev is required
          // compMax and compMin are optional and their unit is ms
          Map<String, String> props = new HashMap<>();
          props.put("loss", "sdt");
          props.put("compDev", "0.01");
          props.put("compMin", "2");
          props.put("compMax", "10");
          session.createTimeseries(ROOT_SG1_D1_S5, TSDataType.INT64, TSEncoding.RLE,
              CompressionType.SNAPPY, props, null, null, null);
        }
      }
    
      private static void createMultiTimeseries()
          throws IoTDBConnectionException, BatchExecutionException, StatementExecutionException {
    
        if (!session.checkTimeseriesExists("root.sg1.d2.s1") && !session
            .checkTimeseriesExists("root.sg1.d2.s2")) {
          List<String> paths = new ArrayList<>();
          paths.add("root.sg1.d2.s1");
          paths.add("root.sg1.d2.s2");
          List<TSDataType> tsDataTypes = new ArrayList<>();
          tsDataTypes.add(TSDataType.INT64);
          tsDataTypes.add(TSDataType.INT64);
          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("unit", "kg");
          tagsList.add(tags);
          tagsList.add(tags);
    
          List<Map<String, String>> attributesList = new ArrayList<>();
          Map<String, String> attributes = new HashMap<>();
          attributes.put("minValue", "1");
          attributes.put("maxValue", "100");
          attributesList.add(attributes);
          attributesList.add(attributes);
    
          List<String> alias = new ArrayList<>();
          alias.add("weight1");
          alias.add("weight2");
    
          session
              .createMultiTimeseries(paths, tsDataTypes, tsEncodings, compressionTypes, null, tagsList,
                  attributesList, alias);
        }
      }
    
      private static void insertRecord() throws IoTDBConnectionException, StatementExecutionException {
        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++) {
          List<Object> values = new ArrayList<>();
          values.add(1L);
          values.add(2L);
          values.add(3L);
          session.insertRecord(deviceId, time, measurements, types, values);
        }
      }
    
      private static void insertStrRecord() 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 < 10; time++) {
          List<String> values = new ArrayList<>();
          values.add("1");
          values.add("2");
          values.add("3");
          session.insertRecord(deviceId, time, measurements, values);
        }
      }
    
      private static void insertRecordInObject()
          throws IoTDBConnectionException, StatementExecutionException {
        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, 1L, 1L);
        }
      }
    
      private static void insertRecords() throws IoTDBConnectionException, StatementExecutionException {
        String deviceId = ROOT_SG1_D1;
        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);
      }
      /**
       * insert the data of a device. For each timestamp, the number of measurements is the same.
       *
       * a Tablet example:
       *
       *      device1
       * time s1, s2, s3
       * 1,   1,  1,  1
       * 2,   2,  2,  2
       * 3,   3,  3,  3
       *
       * Users need to control the count of Tablet and write a batch when it reaches the maxBatchSize
       */
      private static void insertTablet() throws IoTDBConnectionException, StatementExecutionException {
        // The schema of measurements of one device
        // only measurementId and data type in MeasurementSchema take effects in Tablet
        List<MeasurementSchema> schemaList = new ArrayList<>();
        schemaList.add(new MeasurementSchema("s1", TSDataType.INT64));
        schemaList.add(new MeasurementSchema("s2", TSDataType.INT64));
        schemaList.add(new MeasurementSchema("s3", TSDataType.INT64));
    
        Tablet tablet = new Tablet(ROOT_SG1_D1, schemaList, 100);
    
        //Method 1 to add tablet data
        long timestamp = System.currentTimeMillis();
    
        for (long row = 0; row < 100; row++) {
          int rowIndex = tablet.rowSize++;
          tablet.addTimestamp(rowIndex, timestamp);
          for (int s = 0; s < 3; s++) {
            long value = new Random().nextLong();
            tablet.addValue(schemaList.get(s).getMeasurementId(), rowIndex, value);
          }
          if (tablet.rowSize == tablet.getMaxRowNumber()) {
            session.insertTablet(tablet, true);
            tablet.reset();
          }
          timestamp++;
        }
    
        if (tablet.rowSize != 0) {
          session.insertTablet(tablet);
          tablet.reset();
        }
    
        //Method 2 to add tablet data
        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, true);
            tablet.reset();
          }
        }
    
        if (tablet.rowSize != 0) {
          session.insertTablet(tablet);
          tablet.reset();
        }
      }
    
      private static void insertTablets() throws IoTDBConnectionException, StatementExecutionException {
        // The schema of measurements of one device
        // only measurementId and data type in MeasurementSchema take effects in Tablet
        List<MeasurementSchema> schemaList = new ArrayList<>();
        schemaList.add(new MeasurementSchema("s1", TSDataType.INT64));
        schemaList.add(new MeasurementSchema("s2", TSDataType.INT64));
        schemaList.add(new MeasurementSchema("s3", TSDataType.INT64));
    
        Tablet tablet1 = new Tablet(ROOT_SG1_D1, schemaList, 100);
        Tablet tablet2 = new Tablet("root.sg1.d2", schemaList, 100);
        Tablet tablet3 = new Tablet("root.sg1.d3", schemaList, 100);
    
        Map<String, Tablet> tabletMap = new HashMap<>();
        tabletMap.put(ROOT_SG1_D1, tablet1);
        tabletMap.put("root.sg1.d2", tablet2);
        tabletMap.put("root.sg1.d3", tablet3);
    
        //Method 1 to add tablet data
        long timestamp = System.currentTimeMillis();
        for (long row = 0; row < 100; row++) {
          int row1 = tablet1.rowSize++;
          int row2 = tablet2.rowSize++;
          int row3 = tablet3.rowSize++;
          tablet1.addTimestamp(row1, timestamp);
          tablet2.addTimestamp(row2, timestamp);
          tablet3.addTimestamp(row3, timestamp);
          for (int i = 0; i < 3; i++) {
            long value = new Random().nextLong();
            tablet1.addValue(schemaList.get(i).getMeasurementId(), row1, value);
            tablet2.addValue(schemaList.get(i).getMeasurementId(), row2, value);
            tablet3.addValue(schemaList.get(i).getMeasurementId(), row3, value);
          }
          if (tablet1.rowSize == tablet1.getMaxRowNumber()) {
            session.insertTablets(tabletMap, true);
            tablet1.reset();
            tablet2.reset();
            tablet3.reset();
          }
          timestamp++;
        }
    
        if (tablet1.rowSize != 0) {
          session.insertTablets(tabletMap, true);
          tablet1.reset();
          tablet2.reset();
          tablet3.reset();
        }
    
        //Method 2 to add tablet data
        long[] timestamps1 = tablet1.timestamps;
        Object[] values1 = tablet1.values;
        long[] timestamps2 = tablet2.timestamps;
        Object[] values2 = tablet2.values;
        long[] timestamps3 = tablet3.timestamps;
        Object[] values3 = tablet3.values;
    
        for (long time = 0; time < 100; time++) {
          int row1 = tablet1.rowSize++;
          int row2 = tablet2.rowSize++;
          int row3 = tablet3.rowSize++;
          timestamps1[row1] = time;
          timestamps2[row2] = time;
          timestamps3[row3] = time;
          for (int i = 0; i < 3; i++) {
            long[] sensor1 = (long[]) values1[i];
            sensor1[row1] = i;
            long[] sensor2 = (long[]) values2[i];
            sensor2[row2] = i;
            long[] sensor3 = (long[]) values3[i];
            sensor3[row3] = i;
          }
          if (tablet1.rowSize == tablet1.getMaxRowNumber()) {
            session.insertTablets(tabletMap, true);
    
            tablet1.reset();
            tablet2.reset();
            tablet3.reset();
          }
        }
    
        if (tablet1.rowSize != 0) {
          session.insertTablets(tabletMap, true);
          tablet1.reset();
          tablet2.reset();
          tablet3.reset();
        }
      }
    
      private static void deleteData() throws IoTDBConnectionException, StatementExecutionException {
        String path = ROOT_SG1_D1_S1;
        long deleteTime = 99;
        session.deleteData(path, deleteTime);
      }
    
      private static void deleteTimeseries()
          throws IoTDBConnectionException, StatementExecutionException {
        List<String> paths = new ArrayList<>();
        paths.add(ROOT_SG1_D1_S1);
        paths.add(ROOT_SG1_D1_S2);
        paths.add(ROOT_SG1_D1_S3);
        session.deleteTimeseries(paths);
      }
    
      private static void query() throws IoTDBConnectionException, StatementExecutionException {
        SessionDataSet dataSet = session.executeQueryStatement("select * from root.sg1.d1");
        System.out.println(dataSet.getColumnNames());
        dataSet.setFetchSize(1024); // default is 10000
        while (dataSet.hasNext()) {
          System.out.println(dataSet.next());
        }
    
        dataSet.closeOperationHandle();
      }
    
      private static void rawDataQuery() throws IoTDBConnectionException, StatementExecutionException {
        List<String> paths = new ArrayList<>();
        paths.add(ROOT_SG1_D1_S1);
        paths.add(ROOT_SG1_D1_S2);
        paths.add(ROOT_SG1_D1_S3);
        long startTime = 10L;
        long endTime = 200L;
    
        SessionDataSet dataSet = session.executeRawDataQuery(paths, startTime, endTime);
        System.out.println(dataSet.getColumnNames());
        dataSet.setFetchSize(1024);
        while (dataSet.hasNext()) {
          System.out.println(dataSet.next());
        }
        dataSet.closeOperationHandle();
      }
    
      private static void queryByIterator()
          throws IoTDBConnectionException, StatementExecutionException {
        SessionDataSet dataSet = session.executeQueryStatement("select * from root.sg1.d1");
        DataIterator iterator = dataSet.iterator();
        System.out.println(dataSet.getColumnNames());
        dataSet.setFetchSize(1024); // default is 10000
        while (iterator.next()) {
          StringBuilder builder = new StringBuilder();
          // get time
          builder.append(iterator.getLong(1)).append(",");
          // get second column
          if (!iterator.isNull(2)) {
            builder.append(iterator.getLong(2)).append(",");
          } else {
            builder.append("null").append(",");
          }
    
          // get third column
          if (!iterator.isNull(ROOT_SG1_D1_S2)) {
            builder.append(iterator.getLong(ROOT_SG1_D1_S2)).append(",");
          } else {
            builder.append("null").append(",");
          }
    
          // get forth column
          if (!iterator.isNull(4)) {
            builder.append(iterator.getLong(4)).append(",");
          } else {
            builder.append("null").append(",");
          }
    
          // get fifth column
          if (!iterator.isNull(ROOT_SG1_D1_S4)) {
            builder.append(iterator.getObject(ROOT_SG1_D1_S4));
          } else {
            builder.append("null");
          }
    
          System.out.println(builder.toString());
        }
    
        dataSet.closeOperationHandle();
      }
    
      private static void nonQuery() throws IoTDBConnectionException, StatementExecutionException {
        session.executeNonQueryStatement("insert into root.sg1.d1(timestamp,s1) values(200, 1);");
      }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70]: /images/20221120/741a50c9accd40219ace6f7884a72eaf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201204102052595.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20201204102349539.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz,size_16,color_FFFFFF,t_70
[20201204102302668.png]: https://img-blog.csdnimg.cn/20201204102302668.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20201204102433923.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz,size_16,color_FFFFFF,t_70
[https_iotdb.apache.org_Download]: https://iotdb.apache.org/Download/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20201201194706320.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20201201194804707.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20201201194747605.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20201201194908634.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20201201194846638.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxODY2Nzkz,size_16,color_FFFFFF,t_70
[https_github.com_apache_iotdb_blob_master_example_session_src_main_java_org_apache_iotdb_SessionExample.java]: https://github.com/apache/iotdb/blob/master/example/session/src/main/java/org/apache/iotdb/SessionExample.java