This is an automated email from the ASF dual-hosted git repository. xuekaifeng pushed a commit to branch IOTDB-615-Use-binary-rather-than-string-in-insert-plan in repository https://gitbox.apache.org/repos/asf/incubator-iotdb.git
commit d4a408ba849f53a4a01e551613a1818b40e73eb6 Merge: d4b3ed6 73dd5eb Author: 151250176 <[email protected]> AuthorDate: Tue May 5 21:51:44 2020 +0800 Merge branch 'master' of https://github.com/apache/incubator-iotdb into IOTDB-615-Use-binary-rather-than-string-in-insert-plan # Conflicts: # example/session/src/main/java/org/apache/iotdb/SessionExample.java # server/src/main/java/org/apache/iotdb/db/qp/executor/PlanExecutor.java # server/src/main/java/org/apache/iotdb/db/qp/strategy/PhysicalGenerator.java # service-rpc/rpc-changelist.md # session/src/main/java/org/apache/iotdb/session/Session.java # session/src/main/java/org/apache/iotdb/session/pool/SessionPool.java # session/src/test/java/org/apache/iotdb/session/IoTDBSessionIT.java # session/src/test/java/org/apache/iotdb/session/pool/SessionPoolTest.java README.md | 18 +- README_ZH.md | 14 +- {client => cli}/pom.xml | 6 +- .../client.xml => cli/src/assembly/cli.xml | 2 +- .../src/assembly/resources/sbin/start-cli.bat | 4 +- .../src/assembly/resources/sbin/start-cli.sh | 2 +- .../src/assembly/resources/tools/export-csv.bat | 0 .../src/assembly/resources/tools/export-csv.sh | 0 .../src/assembly/resources/tools/import-csv.bat | 0 .../src/assembly/resources/tools/import-csv.sh | 0 .../java/org/apache/iotdb/cli/AbstractCli.java | 9 +- .../src/main/java/org/apache/iotdb/cli/Cli.java | 10 +- .../src/main/java/org/apache/iotdb/cli/WinCli.java | 6 +- .../apache/iotdb/exception/ArgsErrorException.java | 0 .../org/apache/iotdb/tool/AbstractCsvTool.java | 0 .../main/java/org/apache/iotdb/tool/ExportCsv.java | 4 +- .../main/java/org/apache/iotdb/tool/ImportCsv.java | 0 .../java/org/apache/iotdb/cli/AbstractCliIT.java | 218 +++++++ .../java/org/apache/iotdb/cli}/AbstractScript.java | 4 +- .../org/apache/iotdb/cli}/StartClientScriptIT.java | 8 +- .../org/apache/iotdb/tool/ExportCsvTestIT.java | 2 +- .../org/apache/iotdb/tool/ImportCsvTestIT.java | 2 +- {client => cli}/src/test/resources/logback.xml | 0 client-py/src/client_example.py | 8 +- .../org/apache/iotdb/client/AbstractClientIT.java | 218 ------- distribution/pom.xml | 2 +- docker/src/main/Dockerfile-0.9.1-jre8 | 41 ++ docs/Development/ContributeGuide.md | 3 +- docs/Download/README.md | 10 + docs/SystemDesign/1-TsFile/3-Write.md | 4 +- .../3-SchemaManager/1-SchemaManager.md | 218 ++++++- .../4-StorageEngine/6-DataManipulation.md | 2 +- docs/SystemDesign/5-DataQuery/1-DataQuery.md | 4 +- .../5-DataQuery/2-QueryFundamentals.md | 128 ++++ .../5-DataQuery/3-ModificationHandle.md | 73 --- .../{2-SeriesReader.md => 3-SeriesReader.md} | 0 docs/UserGuide/0-Get Started/1-QuickStart.md | 12 +- .../0-Get Started/2-Frequently asked questions.md | 14 +- docs/UserGuide/3-Server/4-Config Manual.md | 12 + .../UserGuide/4-Client/1-Command Line Interface.md | 44 +- .../4-Client/2-Programming - Native API.md | 114 ++-- docs/UserGuide/4-Client/3-Programming - JDBC.md | 8 + .../4-Client/5-Programming - TsFile API.md | 153 +---- docs/UserGuide/4-Client/7-Status Codes.md | 11 +- .../1-DDL Data Definition Language.md | 91 ++- .../5-Operation Manual/4-SQL Reference.md | 47 ++ .../6-System Tools/8-Load External Tsfile.md | 4 +- .../UserGuide/7-Ecosystem Integration/1-Grafana.md | 7 +- docs/zh/Development/ContributeGuide.md | 2 +- docs/zh/Download/README.md | 10 + docs/zh/SystemDesign/1-TsFile/3-Write.md | 2 +- .../3-SchemaManager/1-SchemaManager.md | 210 +++++- .../4-StorageEngine/6-DataManipulation.md | 2 +- docs/zh/SystemDesign/5-DataQuery/1-DataQuery.md | 4 +- .../5-DataQuery/2-QueryFundamentals.md | 110 ++++ .../5-DataQuery/3-ModificationHandle.md | 73 --- .../{2-SeriesReader.md => 3-SeriesReader.md} | 0 docs/zh/UserGuide/0-Get Started/1-QuickStart.md | 10 +- .../0-Get Started/2-Frequently asked questions.md | 8 +- docs/zh/UserGuide/3-Server/1-Download.md | 36 +- docs/zh/UserGuide/3-Server/4-Config Manual.md | 13 + .../UserGuide/4-Client/1-Command Line Interface.md | 38 +- .../4-Client/2-Programming - Native API.md | 101 ++- docs/zh/UserGuide/4-Client/3-Programming - JDBC.md | 11 +- .../4-Client/5-Programming - TsFile API.md | 152 +---- docs/zh/UserGuide/4-Client/7-Status Codes.md | 11 +- .../1-DDL Data Definition Language.md | 87 ++- .../5-Operation Manual/4-SQL Reference.md | 46 ++ .../6-System Tools/8-Load External Tsfile.md | 4 +- .../UserGuide/7-Ecosystem Integration/1-Grafana.md | 7 +- .../apache/iotdb/hadoop/tsfile/TsFileHelper.java | 50 +- .../apache/iotdb/rocketmq/RocketMQConsumer.java | 2 +- .../main/java/org/apache/iotdb/SessionExample.java | 238 ++++--- .../java/org/apache/iotdb/tsfile/TsFileRead.java | 4 +- .../apache/iotdb/tsfile/TsFileSequenceRead.java | 15 +- ...ithRowBatch.java => TsFileWriteWithTablet.java} | 76 ++- .../java/org/apache/iotdb/flink/IoTDBSink.java | 4 +- .../iotdb/flink/IoTDBSinkBatchInsertTest.java | 4 +- .../iotdb/flink/IoTDBSinkBatchTimerTest.java | 2 +- .../apache/iotdb/flink/IoTDBSinkInsertTest.java | 2 +- .../iotdb/flink/tsfile/util/TSFileConfigUtil.java | 1 + .../util/TSFileConfigUtilCompletenessTest.java | 102 +-- .../iotdb/web/grafana/dao/impl/BasicDaoImpl.java | 109 ++-- grafana/src/main/resources/application.properties | 6 +- .../apache/iotdb/hadoop/tsfile/TSFInputFormat.java | 10 +- .../iotdb/hadoop/tsfile/TsFileTestHelper.java | 40 +- .../org/apache/iotdb/hive/TsFileTestHelper.java | 41 +- .../java/org/apache/iotdb/jdbc/IoTDBStatement.java | 12 +- pom.xml | 2 +- .../resources/conf/iotdb-engine.properties | 11 +- .../org/apache/iotdb/db/qp/strategy/SqlBase.g4 | 19 + .../java/org/apache/iotdb/db/conf/IoTDBConfig.java | 2 +- .../org/apache/iotdb/db/conf/IoTDBDescriptor.java | 40 +- .../org/apache/iotdb/db/engine/StorageEngine.java | 10 +- .../apache/iotdb/db/engine/cache/ChunkCache.java | 1 + .../iotdb/db/engine/cache/ChunkMetadataCache.java | 1 + .../db/engine/cache/TimeSeriesMetadataCache.java | 22 +- .../iotdb/db/engine/cache/TsFileMetaDataCache.java | 24 +- .../iotdb/db/engine/memtable/AbstractMemTable.java | 20 +- .../apache/iotdb/db/engine/memtable/IMemTable.java | 6 +- .../engine/storagegroup/StorageGroupProcessor.java | 108 ++-- .../db/engine/storagegroup/TsFileProcessor.java | 26 +- .../exception/metadata/DeleteFailedException.java | 19 +- .../org/apache/iotdb/db/metadata/MLogWriter.java | 6 + .../org/apache/iotdb/db/metadata/MManager.java | 714 +++++++++++++++------ .../java/org/apache/iotdb/db/metadata/MTree.java | 211 ++++-- .../org/apache/iotdb/db/metadata/MetaUtils.java | 6 +- .../iotdb/db/metadata/MetadataOperationType.java | 1 + .../org/apache/iotdb/db/metadata/TagLogFile.java | 24 +- .../iotdb/db/metadata/mnode/InternalMNode.java | 59 +- .../org/apache/iotdb/db/metadata/mnode/MNode.java | 8 +- .../main/java/org/apache/iotdb/db/qp/Planner.java | 6 +- .../apache/iotdb/db/qp/constant/SQLConstant.java | 7 +- .../apache/iotdb/db/qp/executor/IPlanExecutor.java | 4 +- .../apache/iotdb/db/qp/executor/PlanExecutor.java | 333 ++++++---- .../org/apache/iotdb/db/qp/logical/Operator.java | 3 +- .../db/qp/logical/sys/AlterTimeSeriesOperator.java | 97 +++ .../db/qp/logical/sys/ShowTimeSeriesOperator.java | 2 +- .../apache/iotdb/db/qp/physical/PhysicalPlan.java | 4 +- ...{BatchInsertPlan.java => InsertTabletPlan.java} | 24 +- .../db/qp/physical/sys/AlterTimeSeriesPlan.java | 86 +++ .../db/qp/physical/sys/ShowTimeSeriesPlan.java | 15 +- .../iotdb/db/qp/strategy/LogicalGenerator.java | 99 ++- .../iotdb/db/qp/strategy/PhysicalGenerator.java | 138 ++-- .../dataset/groupby/LocalGroupByExecutor.java | 92 +-- .../iotdb/db/query/reader/series/SeriesReader.java | 135 ++-- .../org/apache/iotdb/db/service/TSServiceImpl.java | 118 +++- .../apache/iotdb/db/tools/TsFileSketchTool.java | 66 +- .../java/org/apache/iotdb/db/utils/AuthUtils.java | 22 +- .../org/apache/iotdb/db/utils/FileLoaderUtils.java | 38 +- .../java/org/apache/iotdb/db/utils/MemUtils.java | 10 +- .../java/org/apache/iotdb/db/utils/MergeUtils.java | 14 +- .../iotdb/db/writelog/recover/LogReplayer.java | 31 +- .../writelog/recover/TsFileRecoverPerformer.java | 28 +- .../storagegroup/StorageGroupProcessorTest.java | 29 +- .../apache/iotdb/db/integration/IoTDBLastIT.java | 6 +- .../db/integration/IoTDBLoadExternalTsfileIT.java | 6 +- .../iotdb/db/integration/IoTDBSimpleQueryIT.java | 2 + .../iotdb/db/integration/IoTDBTagAlterIT.java | 455 +++++++++++++ .../apache/iotdb/db/integration/IoTDBTagIT.java | 69 +- .../iotdb/db/metadata/MManagerImproveTest.java | 24 +- .../apache/iotdb/db/qp/plan/PhysicalPlanTest.java | 6 +- service-rpc/rpc-changelist.md | 41 +- .../java/org/apache/iotdb/rpc/TSStatusCode.java | 3 +- service-rpc/src/main/thrift/rpc.thrift | 30 +- .../java/org/apache/iotdb/session/Session.java | 388 +++++------ .../org/apache/iotdb/session/SessionUtils.java | 42 +- .../org/apache/iotdb/session/pool/SessionPool.java | 126 ++-- .../org/apache/iotdb/session/IoTDBSessionIT.java | 268 ++++---- .../java/org/apache/iotdb/session/SessionUT.java | 90 +++ .../apache/iotdb/session/pool/SessionPoolTest.java | 18 +- site/pom.xml | 1 + site/src/main/.vuepress/config.js | 14 +- site/src/main/.vuepress/styles/index.styl | 2 +- .../.vuepress/theme/global-components/IoTDB.vue | 4 +- .../apache/iotdb/spark/tsfile/DefaultSource.scala | 2 +- .../iotdb/spark/tsfile/NarrowConverter.scala | 2 +- .../apache/iotdb/spark/tsfile/WideConverter.scala | 7 +- tsfile/format-changelist.md | 1 + .../iotdb/tsfile/common/conf/TSFileConfig.java | 12 + .../iotdb/tsfile/common/conf/TSFileDescriptor.java | 2 + .../iotdb/tsfile/exception/NullFieldException.java | 12 +- .../file/metadata/MetadataIndexConstructor.java | 151 +++++ .../tsfile/file/metadata/MetadataIndexEntry.java | 91 +++ .../tsfile/file/metadata/MetadataIndexNode.java | 125 ++++ .../tsfile/file/metadata/TimeseriesMetadata.java | 14 +- .../iotdb/tsfile/file/metadata/TsFileMetadata.java | 50 +- .../file/metadata/enums/MetadataIndexNodeType.java | 86 +++ .../iotdb/tsfile/read/TsFileSequenceReader.java | 334 +++++++--- .../org/apache/iotdb/tsfile/read/common/Field.java | 23 + .../tsfile/read/controller/IMetadataQuerier.java | 2 +- .../read/controller/MetadataQuerierByFileImpl.java | 27 +- .../tsfile/read/query/executor/TsFileExecutor.java | 3 - .../iotdb/tsfile/utils/ReadWriteIOUtils.java | 7 + .../apache/iotdb/tsfile/write/TsFileWriter.java | 40 +- .../tsfile/write/chunk/ChunkGroupWriterImpl.java | 24 +- .../tsfile/write/chunk/IChunkGroupWriter.java | 14 +- .../write/record/{RowBatch.java => Tablet.java} | 100 +-- .../apache/iotdb/tsfile/write/schema/Schema.java | 22 - .../write/writer/RestorableTsFileIOWriter.java | 9 +- .../iotdb/tsfile/write/writer/TsFileIOWriter.java | 67 +- .../file/metadata/MetadataIndexNodeTest.java | 46 ++ .../tsfile/file/metadata/utils/TestHelper.java | 20 +- .../iotdb/tsfile/file/metadata/utils/Utils.java | 14 +- .../apache/iotdb/tsfile/read/common/FieldTest.java | 15 +- .../iotdb/tsfile/read/reader/ReaderTest.java | 2 + .../iotdb/tsfile/write/TsFileIOWriterTest.java | 5 +- .../iotdb/tsfile/write/TsFileWriterTest.java | 35 +- 188 files changed, 5946 insertions(+), 2946 deletions(-) diff --cc example/session/src/main/java/org/apache/iotdb/SessionExample.java index f3d5b55,6aa0e25..9d07e88 --- a/example/session/src/main/java/org/apache/iotdb/SessionExample.java +++ b/example/session/src/main/java/org/apache/iotdb/SessionExample.java @@@ -18,6 -18,6 +18,10 @@@ */ package org.apache.iotdb; ++import java.util.ArrayList; ++import java.util.HashMap; ++import java.util.List; ++import java.util.Map; import org.apache.iotdb.rpc.BatchExecutionException; import org.apache.iotdb.rpc.IoTDBConnectionException; import org.apache.iotdb.rpc.StatementExecutionException; @@@ -26,14 -26,13 +30,8 @@@ import org.apache.iotdb.session.Session 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.Path; - import org.apache.iotdb.tsfile.write.record.RowBatch; + import org.apache.iotdb.tsfile.write.record.Tablet; import org.apache.iotdb.tsfile.write.schema.MeasurementSchema; --import org.apache.iotdb.tsfile.write.schema.Schema; --import java.util.ArrayList; --import java.util.HashMap; --import java.util.List; --import java.util.Map; public class SessionExample { @@@ -94,57 -95,54 +94,59 @@@ private static void createMultiTimeseries() throws IoTDBConnectionException, BatchExecutionException { - 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.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("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); + 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 insert() throws IoTDBConnectionException, StatementExecutionException { + 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<String> values = new ArrayList<>(); - values.add("1"); - values.add("2"); - values.add("3"); - session.insertRecord(deviceId, time, measurements, values); + List<Object> values = new ArrayList<>(); + values.add(1L); + values.add(2L); + values.add(3L); - session.insert(deviceId, time, measurements, types, values); ++ session.insertRecord(deviceId, time, measurements, types, values); } } @@@ -156,12 -153,8 +158,12 @@@ 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.insert(deviceId, time, measurements, types, 1L, 1L, 1L); - session.insertRecord(deviceId, time, measurements, 1L, 1L, 1L); ++ session.insertRecord(deviceId, time, measurements, types, 1L, 1L, 1L); } } @@@ -190,10 -178,9 +192,10 @@@ deviceIds.add(deviceId); measurementsList.add(measurements); valuesList.add(values); + typesList.add(types); timestamps.add(time); if (time != 0 && time % 100 == 0) { - session.insertInBatch(deviceIds, timestamps, measurementsList, typesList, valuesList); - session.insertRecords(deviceIds, timestamps, measurementsList, valuesList); ++ session.insertRecords(deviceIds, timestamps, measurementsList, typesList, valuesList); deviceIds.clear(); measurementsList.clear(); valuesList.clear(); @@@ -201,35 -188,36 +203,46 @@@ } } - session.insertInBatch(deviceIds, timestamps, measurementsList, typesList, valuesList); - session.insertRecords(deviceIds, timestamps, measurementsList, valuesList); ++ session.insertRecords(deviceIds, timestamps, measurementsList, typesList, valuesList); } - /** ++<<<<<<< HEAD + * insert a batch data of one device, each batch contains multiple timestamps with values of + * sensors + * <p> + * a RowBatch example: + * <p> + * device1 time s1, s2, s3 1, 1, 1, 1 2, 2, 2, 2 3, 3, 3, 3 + * <p> + * Users need to control the count of RowBatch and write a batch when it reaches the maxBatchSize ++======= + * 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 ++>>>>>>> 73dd5eb6e44e2194b650eea72aabcfaf929e5bdc */ - private static void insertRowBatch() throws IoTDBConnectionException, BatchExecutionException { + private static void insertTablet() throws IoTDBConnectionException, BatchExecutionException { // The schema of sensors of one device - Schema schema = new Schema(); - schema.registerTimeseries(new Path("root.sg1.d1", "s1"), - new MeasurementSchema("s1", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path("root.sg1.d1", "s2"), - new MeasurementSchema("s2", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path("root.sg1.d1", "s3"), - new MeasurementSchema("s3", TSDataType.INT64, TSEncoding.RLE)); + 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)); - RowBatch rowBatch = schema.createRowBatch("root.sg1.d1", 100); + Tablet tablet = new Tablet("root.sg1.d1", schemaList, 100); - long[] timestamps = rowBatch.timestamps; - Object[] values = rowBatch.values; + long[] timestamps = tablet.timestamps; + Object[] values = tablet.values; for (long time = 0; time < 100; time++) { - int row = rowBatch.batchSize++; + int row = tablet.rowSize++; timestamps[row] = time; for (int i = 0; i < 3; i++) { long[] sensor = (long[]) values[i]; diff --cc server/src/main/java/org/apache/iotdb/db/engine/memtable/AbstractMemTable.java index 7a3b2f5,5292938..dde8bee --- a/server/src/main/java/org/apache/iotdb/db/engine/memtable/AbstractMemTable.java +++ b/server/src/main/java/org/apache/iotdb/db/engine/memtable/AbstractMemTable.java @@@ -29,9 -29,10 +29,9 @@@ import org.apache.iotdb.db.engine.modif import org.apache.iotdb.db.engine.querycontext.ReadOnlyMemChunk; import org.apache.iotdb.db.exception.WriteProcessException; import org.apache.iotdb.db.exception.query.QueryProcessException; - import org.apache.iotdb.db.qp.physical.crud.BatchInsertPlan; + import org.apache.iotdb.db.qp.physical.crud.InsertTabletPlan; import org.apache.iotdb.db.qp.physical.crud.InsertPlan; import org.apache.iotdb.db.rescon.TVListAllocator; -import org.apache.iotdb.db.utils.CommonUtils; import org.apache.iotdb.db.utils.MemUtils; import org.apache.iotdb.db.utils.datastructure.TVList; import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType; diff --cc server/src/main/java/org/apache/iotdb/db/qp/executor/PlanExecutor.java index 838a6e7,92f363e..b9927e8 --- a/server/src/main/java/org/apache/iotdb/db/qp/executor/PlanExecutor.java +++ b/server/src/main/java/org/apache/iotdb/db/qp/executor/PlanExecutor.java @@@ -757,7 -815,8 +815,7 @@@ public class PlanExecutor implements IP try { String[] measurementList = insertPlan.getMeasurements(); String deviceId = insertPlan.getDeviceId(); - MNode node = mManager.getDeviceNodeWithAutoCreateStorageGroup(deviceId); + node = mManager.getDeviceNodeWithAutoCreateAndReadLock(deviceId); - String[] strValues = insertPlan.getValues(); MeasurementSchema[] schemas = new MeasurementSchema[measurementList.length]; for (int i = 0; i < measurementList.length; i++) { diff --cc server/src/main/java/org/apache/iotdb/db/qp/strategy/PhysicalGenerator.java index f192091,72e66b4..7ebccc9 --- a/server/src/main/java/org/apache/iotdb/db/qp/strategy/PhysicalGenerator.java +++ b/server/src/main/java/org/apache/iotdb/db/qp/strategy/PhysicalGenerator.java @@@ -35,69 -27,25 +35,68 @@@ import org.apache.iotdb.db.metadata.MMa import org.apache.iotdb.db.qp.constant.SQLConstant; import org.apache.iotdb.db.qp.logical.Operator; import org.apache.iotdb.db.qp.logical.Operator.OperatorType; -import org.apache.iotdb.db.qp.logical.crud.*; -import org.apache.iotdb.db.qp.logical.sys.*; +import org.apache.iotdb.db.qp.logical.crud.BasicFunctionOperator; +import org.apache.iotdb.db.qp.logical.crud.DeleteDataOperator; +import org.apache.iotdb.db.qp.logical.crud.FilterOperator; +import org.apache.iotdb.db.qp.logical.crud.InsertOperator; +import org.apache.iotdb.db.qp.logical.crud.QueryOperator; ++import org.apache.iotdb.db.qp.logical.sys.AlterTimeSeriesOperator; +import org.apache.iotdb.db.qp.logical.sys.AuthorOperator; +import org.apache.iotdb.db.qp.logical.sys.CountOperator; +import org.apache.iotdb.db.qp.logical.sys.CreateTimeSeriesOperator; +import org.apache.iotdb.db.qp.logical.sys.DataAuthOperator; +import org.apache.iotdb.db.qp.logical.sys.DeleteStorageGroupOperator; +import org.apache.iotdb.db.qp.logical.sys.DeleteTimeSeriesOperator; +import org.apache.iotdb.db.qp.logical.sys.LoadDataOperator; +import org.apache.iotdb.db.qp.logical.sys.LoadFilesOperator; +import org.apache.iotdb.db.qp.logical.sys.MoveFileOperator; +import org.apache.iotdb.db.qp.logical.sys.RemoveFileOperator; +import org.apache.iotdb.db.qp.logical.sys.SetStorageGroupOperator; +import org.apache.iotdb.db.qp.logical.sys.SetTTLOperator; +import org.apache.iotdb.db.qp.logical.sys.ShowChildPathsOperator; +import org.apache.iotdb.db.qp.logical.sys.ShowDevicesOperator; +import org.apache.iotdb.db.qp.logical.sys.ShowTTLOperator; +import org.apache.iotdb.db.qp.logical.sys.ShowTimeSeriesOperator; import org.apache.iotdb.db.qp.physical.PhysicalPlan; -import org.apache.iotdb.db.qp.physical.crud.*; +import org.apache.iotdb.db.qp.physical.crud.AggregationPlan; +import org.apache.iotdb.db.qp.physical.crud.AlignByDevicePlan; import org.apache.iotdb.db.qp.physical.crud.AlignByDevicePlan.MeasurementType; -import org.apache.iotdb.db.qp.physical.sys.*; +import org.apache.iotdb.db.qp.physical.crud.DeletePlan; +import org.apache.iotdb.db.qp.physical.crud.FillQueryPlan; +import org.apache.iotdb.db.qp.physical.crud.GroupByFillPlan; +import org.apache.iotdb.db.qp.physical.crud.GroupByPlan; +import org.apache.iotdb.db.qp.physical.crud.InsertPlan; +import org.apache.iotdb.db.qp.physical.crud.LastQueryPlan; +import org.apache.iotdb.db.qp.physical.crud.QueryPlan; +import org.apache.iotdb.db.qp.physical.crud.RawDataQueryPlan; ++import org.apache.iotdb.db.qp.physical.sys.AlterTimeSeriesPlan; +import org.apache.iotdb.db.qp.physical.sys.AuthorPlan; +import org.apache.iotdb.db.qp.physical.sys.CountPlan; +import org.apache.iotdb.db.qp.physical.sys.CreateTimeSeriesPlan; +import org.apache.iotdb.db.qp.physical.sys.DataAuthPlan; +import org.apache.iotdb.db.qp.physical.sys.DeleteStorageGroupPlan; +import org.apache.iotdb.db.qp.physical.sys.DeleteTimeSeriesPlan; +import org.apache.iotdb.db.qp.physical.sys.LoadConfigurationPlan; +import org.apache.iotdb.db.qp.physical.sys.LoadDataPlan; +import org.apache.iotdb.db.qp.physical.sys.OperateFilePlan; +import org.apache.iotdb.db.qp.physical.sys.SetStorageGroupPlan; +import org.apache.iotdb.db.qp.physical.sys.SetTTLPlan; +import org.apache.iotdb.db.qp.physical.sys.ShowChildPathsPlan; +import org.apache.iotdb.db.qp.physical.sys.ShowDevicesPlan; +import org.apache.iotdb.db.qp.physical.sys.ShowPlan; import org.apache.iotdb.db.qp.physical.sys.ShowPlan.ShowContentType; +import org.apache.iotdb.db.qp.physical.sys.ShowTTLPlan; +import org.apache.iotdb.db.qp.physical.sys.ShowTimeSeriesPlan; import org.apache.iotdb.db.utils.SchemaUtils; import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType; import org.apache.iotdb.tsfile.read.common.Path; import org.apache.iotdb.tsfile.read.expression.IExpression; import org.apache.iotdb.tsfile.utils.Pair; - /** - * Used to convert logical operator to physical plan - */ -import java.util.*; - + /** Used to convert logical operator to physical plan */ public class PhysicalGenerator { - public PhysicalPlan transformToPhysicalPlan(Operator operator) - throws QueryProcessException { + public PhysicalPlan transformToPhysicalPlan(Operator operator) throws QueryProcessException { List<Path> paths; switch (operator.getType()) { case AUTHOR: @@@ -142,8 -121,9 +172,10 @@@ throw new LogicalOperatorException( "For Insert command, cannot specified more than one seriesPath: " + paths); } + - return new InsertPlan(paths.get(0).getFullPath(), insert.getTime(), + return new InsertPlan( + paths.get(0).getFullPath(), + insert.getTime(), insert.getMeasurementList(), insert.getValueList()); case QUERY: diff --cc server/src/main/java/org/apache/iotdb/db/service/TSServiceImpl.java index ac65ac0,f8a36c2..091abc0 --- a/server/src/main/java/org/apache/iotdb/db/service/TSServiceImpl.java +++ b/server/src/main/java/org/apache/iotdb/db/service/TSServiceImpl.java @@@ -61,19 -43,9 +61,19 @@@ import org.apache.iotdb.db.qp.executor. import org.apache.iotdb.db.qp.executor.PlanExecutor; import org.apache.iotdb.db.qp.logical.Operator.OperatorType; import org.apache.iotdb.db.qp.physical.PhysicalPlan; -import org.apache.iotdb.db.qp.physical.crud.*; +import org.apache.iotdb.db.qp.physical.crud.AlignByDevicePlan; import org.apache.iotdb.db.qp.physical.crud.AlignByDevicePlan.MeasurementType; - import org.apache.iotdb.db.qp.physical.crud.BatchInsertPlan; -import org.apache.iotdb.db.qp.physical.sys.*; +import org.apache.iotdb.db.qp.physical.crud.DeletePlan; +import org.apache.iotdb.db.qp.physical.crud.InsertPlan; ++import org.apache.iotdb.db.qp.physical.crud.InsertTabletPlan; +import org.apache.iotdb.db.qp.physical.crud.LastQueryPlan; +import org.apache.iotdb.db.qp.physical.crud.QueryPlan; +import org.apache.iotdb.db.qp.physical.sys.AuthorPlan; +import org.apache.iotdb.db.qp.physical.sys.CreateTimeSeriesPlan; +import org.apache.iotdb.db.qp.physical.sys.DeleteStorageGroupPlan; +import org.apache.iotdb.db.qp.physical.sys.DeleteTimeSeriesPlan; +import org.apache.iotdb.db.qp.physical.sys.SetStorageGroupPlan; +import org.apache.iotdb.db.qp.physical.sys.ShowPlan; import org.apache.iotdb.db.query.context.QueryContext; import org.apache.iotdb.db.query.control.QueryResourceManager; import org.apache.iotdb.db.query.dataset.NonAlignEngineDataSet; @@@ -84,33 -56,7 +84,34 @@@ import org.apache.iotdb.db.utils.QueryD import org.apache.iotdb.db.utils.SchemaUtils; import org.apache.iotdb.rpc.RpcUtils; import org.apache.iotdb.rpc.TSStatusCode; -import org.apache.iotdb.service.rpc.thrift.*; +import org.apache.iotdb.service.rpc.thrift.ServerProperties; - import org.apache.iotdb.service.rpc.thrift.TSBatchInsertionReq; +import org.apache.iotdb.service.rpc.thrift.TSCancelOperationReq; +import org.apache.iotdb.service.rpc.thrift.TSCloseOperationReq; +import org.apache.iotdb.service.rpc.thrift.TSCloseSessionReq; +import org.apache.iotdb.service.rpc.thrift.TSCreateMultiTimeseriesReq; +import org.apache.iotdb.service.rpc.thrift.TSCreateTimeseriesReq; +import org.apache.iotdb.service.rpc.thrift.TSDeleteDataReq; +import org.apache.iotdb.service.rpc.thrift.TSExecuteBatchStatementReq; +import org.apache.iotdb.service.rpc.thrift.TSExecuteBatchStatementResp; +import org.apache.iotdb.service.rpc.thrift.TSExecuteStatementReq; +import org.apache.iotdb.service.rpc.thrift.TSExecuteStatementResp; +import org.apache.iotdb.service.rpc.thrift.TSFetchMetadataReq; +import org.apache.iotdb.service.rpc.thrift.TSFetchMetadataResp; +import org.apache.iotdb.service.rpc.thrift.TSFetchResultsReq; +import org.apache.iotdb.service.rpc.thrift.TSFetchResultsResp; +import org.apache.iotdb.service.rpc.thrift.TSGetTimeZoneResp; +import org.apache.iotdb.service.rpc.thrift.TSIService; - import org.apache.iotdb.service.rpc.thrift.TSInsertInBatchReq; - import org.apache.iotdb.service.rpc.thrift.TSInsertReq; ++import org.apache.iotdb.service.rpc.thrift.TSInsertRecordReq; ++import org.apache.iotdb.service.rpc.thrift.TSInsertRecordsReq; ++import org.apache.iotdb.service.rpc.thrift.TSInsertTabletReq; ++import org.apache.iotdb.service.rpc.thrift.TSInsertTabletsReq; +import org.apache.iotdb.service.rpc.thrift.TSOpenSessionReq; +import org.apache.iotdb.service.rpc.thrift.TSOpenSessionResp; +import org.apache.iotdb.service.rpc.thrift.TSProtocolVersion; +import org.apache.iotdb.service.rpc.thrift.TSQueryDataSet; +import org.apache.iotdb.service.rpc.thrift.TSQueryNonAlignDataSet; +import org.apache.iotdb.service.rpc.thrift.TSSetTimeZoneReq; +import org.apache.iotdb.service.rpc.thrift.TSStatus; import org.apache.iotdb.tsfile.exception.filter.QueryFilterOptimizationException; import org.apache.iotdb.tsfile.exception.write.UnSupportedDataTypeException; import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType; diff --cc service-rpc/rpc-changelist.md index 43f5fcc,b2e528f..f8a83db --- a/service-rpc/rpc-changelist.md +++ b/service-rpc/rpc-changelist.md @@@ -91,34 -121,3 +121,35 @@@ Last Updated on 2019-10-27 by Lei Rui | Add required i64 statementId in TSExecuteStatementReq | Yuan Tian | | Add required binary time, required list<binary> valueList, required list<binary> bitmapList and remove required binary values, required i32 rowCount in TSQueryDataSet| Yuan Tian | | Add optional i32 fetchSize in TSExecuteStatementReq,<br />Add optional TSQueryDataSet in TSExecuteStatementResp| liutaohua | ++<<<<<<< HEAD +| Add optional map<string, string> props, optional map<string, string> tags, optional map<string, string> attributes and optional string aliasPath in TSCreateTimeseriesReq | Yuan Tian | + + +# 0.10.0 (version-1) -> version-2 + +Last Updated on November 12th, 2019 by Tian Jiang. + + +## 1. Delete Old + +| Latest Changes | Related Committers | +| ---------------------------------- | ------------------ | +| Remove TS_SessionHandle,TSHandleIdentifier | Tian Jiang | +| Remove TSStatus,TSExecuteInsertRowInBatchResp | Jialin Qiao| + +## 2. Add New + +| Latest Changes | Related Committers | +| ------------------------------------------------------------ | ---------------------------------- | +| Add parameter sessionId in getTimeZone, getProperties, setStorageGroup, createTimeseries... | Tian Jiang| +| Add struct TSQueryNonAlignDataSet | Haonan Hou| + +## 3. Update + +| Latest Changes | Related Committers | +| ------------------------------------------------------------ | ---------------------- | +| Replace TS_SessionHandles with SessionIds, TSOperationHandle with queryIds | Tian Jiang | +| Add optional TSQueryNonAlignDataSet in TSExecuteStatementResp, TSFetchResultsResp and required bool isAlign in TSFetchResultsReq | Haonan Hou | +| Rename TSStatusType to TSStatus | Jialin Qiao | +| Remove sessionId in TSExecuteBatchStatementResp | Jialin Qiao | - | Use TsDataType and binary rather than string in TSInsertInBatchReq and TSInsertReq | Kaifeng Xue | ++| Use TsDataType and binary rather than string in TSInsertInBatchReq and TSInsertReq | Kaifeng Xue | diff --cc session/src/main/java/org/apache/iotdb/session/Session.java index 0210d10,20dd400..213a55e --- a/session/src/main/java/org/apache/iotdb/session/Session.java +++ b/session/src/main/java/org/apache/iotdb/session/Session.java @@@ -51,8 -50,7 +52,8 @@@ import org.apache.iotdb.tsfile.file.met 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.utils.ReadWriteIOUtils; - import org.apache.iotdb.tsfile.write.record.RowBatch; + import org.apache.iotdb.tsfile.write.record.Tablet; import org.apache.iotdb.tsfile.write.schema.MeasurementSchema; import org.apache.thrift.TException; import org.apache.thrift.protocol.TBinaryProtocol; @@@ -188,18 -186,64 +189,35 @@@ public class Session } /** - * check whether the batch has been sorted - * insert data in one row, if you want to improve your performance, please use insertRecords method - * or insertTablet method ++ * insert data in one row, if you want to improve your performance, please use insertRecords ++ * method or insertTablet method * - * @return whether the batch has been sorted - * @see Session#insertRecords(List, List, List, List) ++ * @see Session#insertRecords(List, List, List, List, List) + * @see Session#insertTablet(Tablet) */ - private boolean checkSorted(RowBatch rowBatch) { - for (int i = 1; i < rowBatch.batchSize; i++) { - if (rowBatch.timestamps[i] < rowBatch.timestamps[i - 1]) { - return false; - } - } + public void insertRecord(String deviceId, long time, List<String> measurements, ++ List<TSDataType> types, + Object... values) throws IoTDBConnectionException, StatementExecutionException { - List<String> stringValues = new ArrayList<>(); - for (Object o : values) { - stringValues.add(o.toString()); - } - - insertRecord(deviceId, time, measurements, stringValues); - } ++ List<Object> valuesList = new ArrayList<>(Arrays.asList(values)); - return true; - /** - * insert data in one row, if you want to improve your performance, please use insertRecords method - * or insertTablet method - * - * @see Session#insertRecords(List, List, List, List) - * @see Session#insertTablet(Tablet) - */ - public void insertRecord(String deviceId, long time, List<String> measurements, - List<String> values) throws IoTDBConnectionException, StatementExecutionException { - TSInsertRecordReq request = new TSInsertRecordReq(); - request.setSessionId(sessionId); - request.setDeviceId(deviceId); - request.setTimestamp(time); - request.setMeasurements(measurements); - request.setValues(values); - - try { - RpcUtils.verifySuccess(client.insertRecord(request)); - } catch (TException e) { - throw new IoTDBConnectionException(e); - } ++ insertRecord(deviceId, time, measurements, types, 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 - * ++ * <p> ++ * a Tablet example: ++ * <p> ++ * device1 time s1, s2, s3 1, 1, 1, 1 2, 2, 2, 2 3, 3, 3, 3 ++ * <p> + * times in Tablet may be not in ascending order + * + * @param tablet data batch + */ + public void insertTablet(Tablet tablet) + throws BatchExecutionException, IoTDBConnectionException { + insertTablet(tablet, false); } /** @@@ -228,144 -281,72 +255,73 @@@ } /** - * use batch interface to insert sorted data times in row batch must be sorted before! - * insert the data of several deivces. - * Given a deivce, for each timestamp, the number of measurements is the same. - * ++ * insert the data of several deivces. Given a deivce, for each timestamp, the number of ++ * measurements is the same. ++ * <p> + * Times in each Tablet may not be in ascending order * - * @param rowBatch data batch + * @param tablets data batch in multiple device */ - public void insertSortedBatch(RowBatch rowBatch) - throws BatchExecutionException, IoTDBConnectionException { - if (!checkSorted(rowBatch)) { - throw new BatchExecutionException( - "Row batch has't been sorted when calling insertSortedBatch"); - } - insertSortedBatchIntern(rowBatch); - } - - /** - * use batch interface to insert data in multiple device - * - * @param rowBatchMap data batch in multiple device - */ - public void insertMultipleDeviceBatch - (Map<String, RowBatch> rowBatchMap) throws IoTDBConnectionException, BatchExecutionException { - for (Map.Entry<String, RowBatch> dataInOneDevice : rowBatchMap.entrySet()) { - sortRowBatch(dataInOneDevice.getValue()); - insertBatch(dataInOneDevice.getValue()); - } - } - - /** - * use batch interface to insert sorted data in multiple device times in row batch must be sorted - * before! - * - * @param rowBatchMap data batch in multiple device - */ - public void insertMultipleDeviceSortedBatch - (Map<String, RowBatch> rowBatchMap) throws IoTDBConnectionException, BatchExecutionException { - for (Map.Entry<String, RowBatch> dataInOneDevice : rowBatchMap.entrySet()) { - checkSorted(dataInOneDevice.getValue()); - insertSortedBatchIntern(dataInOneDevice.getValue()); - } + public void insertTablets(Map<String, Tablet> tablets) + throws IoTDBConnectionException, BatchExecutionException { + insertTablets(tablets, false); } /** - * use batch interface to insert data - * insert the data of several devices. - * Given a device, for each timestamp, the number of measurements is the same. ++ * insert the data of several devices. Given a device, for each timestamp, the number of ++ * measurements is the same. * - * @param rowBatch data batch + * @param tablets data batch in multiple device - * @param sorted whether times in each Tablet are in ascending order ++ * @param sorted whether times in each Tablet are in ascending order */ - public void insertBatch(RowBatch rowBatch) + public void insertTablets(Map<String, Tablet> tablets, boolean sorted) throws IoTDBConnectionException, BatchExecutionException { - sortRowBatch(rowBatch); + TSInsertTabletsReq request = new TSInsertTabletsReq(); + request.setSessionId(sessionId); - insertSortedBatchIntern(rowBatch); - } + for (Tablet tablet : tablets.values()) { + if (sorted) { + if (!checkSorted(tablet)) { + throw new BatchExecutionException("Times in Tablet are not in ascending order"); + } + } else { + sortTablet(tablet); + } - private void sortRowBatch(RowBatch rowBatch) { - /* - * following part of code sort the batch data by time, - * so we can insert continuous data in value list to get a better performance - */ - // sort to get index, and use index to sort value list - Integer[] index = new Integer[rowBatch.batchSize]; - for (int i = 0; i < rowBatch.batchSize; i++) { - index[i] = i; - } - Arrays.sort(index, Comparator.comparingLong(o -> rowBatch.timestamps[o])); - Arrays.sort(rowBatch.timestamps, 0, rowBatch.batchSize); - for (int i = 0; i < rowBatch.getSchemas().size(); i++) { - rowBatch.values[i] = - sortList(rowBatch.values[i], rowBatch.getSchemas().get(i).getType(), index); - } - } + request.addToDeviceIds(tablet.deviceId); + List<String> measurements = new ArrayList<>(); + List<Integer> dataTypes = new ArrayList<>(); + for (MeasurementSchema measurementSchema : tablet.getSchemas()) { + measurements.add(measurementSchema.getMeasurementId()); + dataTypes.add(measurementSchema.getType().ordinal()); + } + request.addToMeasurementsList(measurements); + request.addToTypesList(dataTypes); + request.addToTimestampsList(SessionUtils.getTimeBuffer(tablet)); + request.addToValuesList(SessionUtils.getValueBuffer(tablet)); + request.addToSizeList(tablet.rowSize); - /** - * sort value list by index - * - * @param valueList value list - * @param dataType data type - * @param index index - * @return sorted list - */ - private Object sortList(Object valueList, TSDataType dataType, Integer[] index) { - switch (dataType) { - case BOOLEAN: - boolean[] boolValues = (boolean[]) valueList; - boolean[] sortedValues = new boolean[boolValues.length]; - for (int i = 0; i < index.length; i++) { - sortedValues[index[i]] = boolValues[i]; - } - return sortedValues; - case INT32: - int[] intValues = (int[]) valueList; - int[] sortedIntValues = new int[intValues.length]; - for (int i = 0; i < index.length; i++) { - sortedIntValues[index[i]] = intValues[i]; - } - return sortedIntValues; - case INT64: - long[] longValues = (long[]) valueList; - long[] sortedLongValues = new long[longValues.length]; - for (int i = 0; i < index.length; i++) { - sortedLongValues[index[i]] = longValues[i]; - } - return sortedLongValues; - case FLOAT: - float[] floatValues = (float[]) valueList; - float[] sortedFloatValues = new float[floatValues.length]; - for (int i = 0; i < index.length; i++) { - sortedFloatValues[index[i]] = floatValues[i]; - } - return sortedFloatValues; - case DOUBLE: - double[] doubleValues = (double[]) valueList; - double[] sortedDoubleValues = new double[doubleValues.length]; - for (int i = 0; i < index.length; i++) { - sortedDoubleValues[index[i]] = doubleValues[i]; - } - return sortedDoubleValues; - case TEXT: - Binary[] binaryValues = (Binary[]) valueList; - Binary[] sortedBinaryValues = new Binary[binaryValues.length]; - for (int i = 0; i < index.length; i++) { - sortedBinaryValues[index[i]] = binaryValues[i]; - } - return sortedBinaryValues; - default: - throw new UnSupportedDataTypeException("Unsupported data type:" + dataType); + try { + RpcUtils.verifySuccess(client.insertTablets(request).statusList); + } catch (TException e) { + throw new IoTDBConnectionException(e); + } } } /** - * Insert data in batch format, which can reduce the overhead of network. This method is just like - * jdbc batch insert, we pack some insert request in batch and send them to server If you want - * improve your performance, please see insertBatch method - * Insert multiple rows, which can reduce the overhead of network. This method is just like - * jdbc executeBatch, we pack some insert request in batch and send them to server. - * If you want improve your performance, please see insertTablet method - * ++ * Insert multiple rows, which can reduce the overhead of network. This method is just like jdbc ++ * executeBatch, we pack some insert request in batch and send them to server. If you want improve ++ * your performance, please see insertTablet method ++ * <p> + * Each row is independent, which could have different deviceId, time, number of measurements * - * @see Session#insertBatch(RowBatch) + * @see Session#insertTablet(Tablet) */ - public void insertInBatch(List<String> deviceIds, List<Long> times, + public void insertRecords(List<String> deviceIds, List<Long> times, - List<List<String>> measurementsList, List<List<String>> valuesList) + List<List<String>> measurementsList, List<List<TSDataType>> typesList, + List<List<Object>> valuesList) throws IoTDBConnectionException, BatchExecutionException { // check params size int len = deviceIds.size(); @@@ -379,130 -360,35 +335,112 @@@ request.setDeviceIds(deviceIds); request.setTimestamps(times); request.setMeasurementsList(measurementsList); - request.setValuesList(valuesList); + List<ByteBuffer> buffersList = new ArrayList<>(); + for (int i = 0; i < measurementsList.size(); i++) { + ByteBuffer buffer = ByteBuffer.allocate(calculateLength(typesList.get(i), valuesList.get(i))); + putValues(typesList.get(i), valuesList.get(i), buffer); + buffer.flip(); + buffersList.add(buffer); + } + request.setValuesList(buffersList); try { - RpcUtils.verifySuccess(client.insertRowInBatch(request).statusList); + RpcUtils.verifySuccess(client.insertRecords(request).statusList); } catch (TException e) { throw new IoTDBConnectionException(e); } } - /** - * insert data in one row, if you want improve your performance, please use insertInBatch method - * or insertBatch method - * - * @see Session#insertInBatch(List, List, List, List, List) - * @see Session#insertBatch(RowBatch) - */ - public TSStatus insert(String deviceId, long time, List<String> measurements, - List<TSDataType> types, - Object... values) throws IoTDBConnectionException, StatementExecutionException { - List<Object> valuesList = new ArrayList<>(Arrays.asList(values)); - - return insert(deviceId, time, measurements, types, valuesList); - } + /** - * This method NOT insert data into database and the server just return after accept the request, - * this method should be used to test other time cost in client + * insert data in one row, if you want improve your performance, please use insertInBatch method + * or insertBatch method + * - * @see Session#insertInBatch(List, List, List, List, List) - * @see Session#insertBatch(RowBatch) ++ * @see Session#insertRecords(List, List, List, List, List) ++ * @see Session#insertTablet(Tablet) */ - public TSStatus insert(String deviceId, long time, List<String> measurements, - public void testInsertRecord(String deviceId, long time, List<String> measurements, - List<String> values) throws IoTDBConnectionException, StatementExecutionException { ++ public void insertRecord(String deviceId, long time, List<String> measurements, + List<TSDataType> types, + List<Object> values) throws IoTDBConnectionException, StatementExecutionException { - TSInsertReq request = new TSInsertReq(); + TSInsertRecordReq request = new TSInsertRecordReq(); request.setSessionId(sessionId); request.setDeviceId(deviceId); request.setTimestamp(time); request.setMeasurements(measurements); - request.setValues(values); + ByteBuffer buffer = ByteBuffer.allocate(calculateLength(types, values)); + putValues(types, values, buffer); + buffer.flip(); + request.setValues(buffer); - TSStatus result; try { - result = client.insert(request); - RpcUtils.verifySuccess(result); - RpcUtils.verifySuccess(client.testInsertRecord(request)); ++ RpcUtils.verifySuccess(client.insertRecord(request)); } catch (TException e) { throw new IoTDBConnectionException(e); } - - return result; } + private void putValues(List<TSDataType> types, List<Object> values, ByteBuffer buffer) + throws IoTDBConnectionException { + for (int i = 0; i < values.size(); i++) { + ReadWriteIOUtils.write(types.get(i), buffer); + switch (types.get(i)) { + case BOOLEAN: + ReadWriteIOUtils.write((Boolean) values.get(i), buffer); + break; + case INT32: + ReadWriteIOUtils.write((Integer) values.get(i), buffer); + break; + case INT64: + ReadWriteIOUtils.write((Long) values.get(i), buffer); + break; + case FLOAT: + ReadWriteIOUtils.write((Float) values.get(i), buffer); + break; + case DOUBLE: + ReadWriteIOUtils.write((Double) values.get(i), buffer); + break; + case TEXT: + ReadWriteIOUtils.write(new Binary((String) values.get(i)), buffer); + break; + default: + throw new IoTDBConnectionException("Unsupported data type:" + types.get(i)); + } + } + } + + private int calculateLength(List<TSDataType> types, List<Object> values) + throws IoTDBConnectionException { + int res = 0; + for (int i = 0; i < types.size(); i++) { + // types + res += Short.BYTES; + switch (types.get(i)) { + case BOOLEAN: + res += 1; + break; + case INT32: + res += Integer.BYTES; + break; + case INT64: + res += Long.BYTES; + break; + case FLOAT: + res += Float.BYTES; + break; + case DOUBLE: + res += Double.BYTES; + break; + case TEXT: + res += ((String) values.get(i)).getBytes(TSFileConfig.STRING_CHARSET).length; + break; + default: + throw new IoTDBConnectionException("Unsupported data type:" + types.get(i)); + } + } + + return res; + } + /** * This method NOT insert data into database and the server just return after accept the request, * this method should be used to test other time cost in client @@@ -546,36 -432,16 +484,36 @@@ request.setDeviceIds(deviceIds); request.setTimestamps(times); request.setMeasurementsList(measurementsList); - request.setValuesList(valuesList); + request.setValuesList(new ArrayList<>()); try { - RpcUtils.verifySuccess(client.testInsertRowInBatch(request).statusList); + RpcUtils.verifySuccess(client.testInsertRecords(request).statusList); } catch (TException e) { throw new IoTDBConnectionException(e); } } /** + * This method NOT insert data into database and the server just return after accept the request, + * this method should be used to test other time cost in client + */ - public void testInsert(String deviceId, long time, List<String> measurements, ++ public void testInsertRecord(String deviceId, long time, List<String> measurements, + List<String> values) throws IoTDBConnectionException, StatementExecutionException { - TSInsertReq request = new TSInsertReq(); ++ TSInsertRecordReq request = new TSInsertRecordReq(); + request.setSessionId(sessionId); + request.setDeviceId(deviceId); + request.setTimestamp(time); + request.setMeasurements(measurements); + request.setValues(ByteBuffer.allocate(1)); + + try { - RpcUtils.verifySuccess(client.testInsertRow(request)); ++ RpcUtils.verifySuccess(client.testInsertRecord(request)); + } catch (TException e) { + throw new IoTDBConnectionException(e); + } + } + + /** * delete a timeseries, including data and schema * * @param path timeseries to delete, should be a whole path diff --cc session/src/main/java/org/apache/iotdb/session/pool/SessionPool.java index 8fef612,62e0356..09dfe1b --- a/session/src/main/java/org/apache/iotdb/session/pool/SessionPool.java +++ b/session/src/main/java/org/apache/iotdb/session/pool/SessionPool.java @@@ -325,18 -318,17 +313,17 @@@ public class SessionPool /** * Insert data in batch format, which can reduce the overhead of network. This method is just like * jdbc batch insert, we pack some insert request in batch and send them to server If you want - * improve your performance, please see insertBatch method + * improve your performance, please see insertTablet method * - * @see Session#insertBatch(RowBatch) + * @see Session#insertTablet(Tablet) */ - public void insertInBatch(List<String> deviceIds, List<Long> times, + public void insertRecords(List<String> deviceIds, List<Long> times, - List<List<String>> measurementsList, List<List<String>> valuesList) - throws IoTDBConnectionException, BatchExecutionException { + List<List<String>> measurementsList, List<List<TSDataType>> typesList, - List<List<Object>> valuesList) - throws IoTDBConnectionException, BatchExecutionException { ++ List<List<Object>> valuesList) throws IoTDBConnectionException, BatchExecutionException { for (int i = 0; i < RETRY; i++) { Session session = getSession(); try { - session.insertInBatch(deviceIds, times, measurementsList, typesList, valuesList); - session.insertRecords(deviceIds, times, measurementsList, valuesList); ++ session.insertRecords(deviceIds, times, measurementsList, typesList, valuesList); putBack(session); return; } catch (IoTDBConnectionException e) { @@@ -353,21 -345,20 +340,21 @@@ } /** - * insert data in one row, if you want improve your performance, please use insertInBatch method - * or insertBatch method + * insert data in one row, if you want improve your performance, please use insertRecords method + * or insertTablet method * - * @see Session#insertInBatch(List, List, List, List, List) - * @see Session#insertBatch(RowBatch) - * @see Session#insertRecords(List, List, List, List) ++ * @see Session#insertRecords(List, List, List, List, List) + * @see Session#insertTablet(Tablet) */ - public TSStatus insert(String deviceId, long time, List<String> measurements, - public void insertRecord(String deviceId, long time, List<String> measurements, List<String> values) ++ public void insertRecord(String deviceId, long time, List<String> measurements, + List<TSDataType> types, List<Object> values) throws IoTDBConnectionException, StatementExecutionException { for (int i = 0; i < RETRY; i++) { Session session = getSession(); try { - TSStatus resp = session.insert(deviceId, time, measurements, types, values); - session.insertRecord(deviceId, time, measurements, values); ++ session.insertRecord(deviceId, time, measurements, types, values); putBack(session); - return resp; + return; } catch (IoTDBConnectionException e) { // TException means the connection is broken, remove it and get a new one. closeSession(session); diff --cc session/src/test/java/org/apache/iotdb/session/IoTDBSessionIT.java index b24b82a,820dc3c..dd4c7af --- a/session/src/test/java/org/apache/iotdb/session/IoTDBSessionIT.java +++ b/session/src/test/java/org/apache/iotdb/session/IoTDBSessionIT.java @@@ -204,20 -202,17 +203,18 @@@ public class IoTDBSessionIT createTimeseries(); - // test insert batch - Schema schema = new Schema(); - schema.registerTimeseries(new Path(deviceId, "s1"), - new MeasurementSchema("s1", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path(deviceId, "s2"), - new MeasurementSchema("s2", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path(deviceId, "s3"), - new MeasurementSchema("s3", TSDataType.INT64, TSEncoding.RLE)); + - RowBatch rowBatch = schema.createRowBatch("root.sg1.d1", 100); + // test insert tablet + 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)); - session.testInsertBatch(rowBatch); + Tablet tablet = new Tablet("root.sg1.d1", schemaList, 100); - // test insert row + session.testInsertTablet(tablet); + + // test insert record List<String> measurements = new ArrayList<>(); measurements.add("s1"); measurements.add("s2"); @@@ -357,6 -352,59 +354,63 @@@ session.close(); } + @Test + public void TestSessionInterfacesWithDisabledWAL() + throws StatementExecutionException, IoTDBConnectionException, + BatchExecutionException { + 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"; + + boolean isEnableWAL = IoTDBDescriptor.getInstance().getConfig().isEnableWal(); + IoTDBDescriptor.getInstance().getConfig().setEnableWal(false); + createTimeseries(); + + // test insert record + 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<String> values = new ArrayList<>(); - values.add("1"); - values.add("2"); - values.add("3"); - session.insertRecord(deviceId, time, measurements, values); ++ List<Object> values = new ArrayList<>(); ++ values.add(1L); ++ values.add(2L); ++ values.add(3L); ++ session.insertRecord(deviceId, time, measurements, types, values); + } + + // test insert tablet + 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); + 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++; + } + + session.insertTablet(tablet); + IoTDBDescriptor.getInstance().getConfig().setEnableWal(isEnableWAL); + session.close(); + } private void createTimeseriesForTime() throws StatementExecutionException, IoTDBConnectionException { @@@ -414,13 -462,10 +468,13 @@@ } String sensorId = ss[ss.length - 1]; List<String> measurements = new ArrayList<>(); - List<String> values = new ArrayList<>(); + List<Object> values = new ArrayList<>(); + List<TSDataType> types = new ArrayList<>(); + measurements.add(sensorId); - values.add("100"); - session.insertRecord(deviceId, i, measurements, values); + types.add(TSDataType.INT64); + values.add(100L); - session.insert(deviceId, i, measurements, types, values); ++ session.insertRecord(deviceId, i, measurements, types, values); } } } @@@ -450,10 -490,9 +504,10 @@@ deviceIds.add(deviceId); measurementsList.add(measurements); valuesList.add(values); + typesList.add(types); timestamps.add(time); if (time != 0 && time % 100 == 0) { - session.insertInBatch(deviceIds, timestamps, measurementsList, typesList, valuesList); - session.insertRecords(deviceIds, timestamps, measurementsList, valuesList); ++ session.insertRecords(deviceIds, timestamps, measurementsList, typesList, valuesList); deviceIds.clear(); measurementsList.clear(); valuesList.clear(); @@@ -461,7 -500,7 +515,7 @@@ } } - session.insertInBatch(deviceIds, timestamps, measurementsList, typesList, valuesList); - session.insertRecords(deviceIds, timestamps, measurementsList, valuesList); ++ session.insertRecords(deviceIds, timestamps, measurementsList, typesList, valuesList); } private void insertInObject() throws IoTDBConnectionException, StatementExecutionException { @@@ -471,12 -509,8 +525,12 @@@ 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.insert(deviceId, time, measurements, types,1L, 2L, 3L); - session.insertRecord(deviceId, time, measurements, 1L, 2L, 3L); ++ session.insertRecord(deviceId, time, measurements, types,1L, 2L, 3L); } } @@@ -487,36 -520,29 +541,34 @@@ 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<String> values = new ArrayList<>(); - values.add("1"); - values.add("2"); - values.add("3"); - session.insertRecord(deviceId, time, measurements, values); + List<Object> values = new ArrayList<>(); + values.add(1L); + values.add(2L); + values.add(3L); - session.insert(deviceId, time, measurements, types, values); ++ session.insertRecord(deviceId, time, measurements, types, values); } } - private void insertRowBatchTest1(String deviceId) + private void insertTabletTest1(String deviceId) throws IoTDBConnectionException, BatchExecutionException { - Schema schema = new Schema(); - schema.registerTimeseries(new Path(deviceId, "s1"), - new MeasurementSchema("s1", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path(deviceId, "s2"), - new MeasurementSchema("s2", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path(deviceId, "s3"), - new MeasurementSchema("s3", TSDataType.INT64, TSEncoding.RLE)); + - RowBatch rowBatch = schema.createRowBatch(deviceId, 100); + 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); - long[] timestamps = rowBatch.timestamps; - Object[] values = rowBatch.values; + long[] timestamps = tablet.timestamps; + Object[] values = tablet.values; for (long time = 0; time < 100; time++) { - int row = rowBatch.batchSize++; + int row = tablet.rowSize++; timestamps[row] = time; for (int i = 0; i < 3; i++) { long[] sensor = (long[]) values[i]; @@@ -775,23 -801,20 +827,21 @@@ assertEquals(correctStatus, status); } - private void insertRowBatchTest2(String deviceId) + private void insertTabletTest2(String deviceId) throws IoTDBConnectionException, BatchExecutionException { - Schema schema = new Schema(); - schema.registerTimeseries(new Path(deviceId, "s1"), - new MeasurementSchema("s1", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path(deviceId, "s2"), - new MeasurementSchema("s2", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path(deviceId, "s3"), - new MeasurementSchema("s3", TSDataType.INT64, TSEncoding.RLE)); + - RowBatch rowBatch = schema.createRowBatch(deviceId, 256); + 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, 256); - long[] timestamps = rowBatch.timestamps; - Object[] values = rowBatch.values; + long[] timestamps = tablet.timestamps; + Object[] values = tablet.values; for (long time = 0; time < 1000; time++) { - int row = rowBatch.batchSize++; + int row = tablet.rowSize++; timestamps[row] = time; for (int i = 0; i < 3; i++) { long[] sensor = (long[]) values[i]; @@@ -809,23 -832,20 +859,21 @@@ } } - private void insertRowBatchTest3(String deviceId) + private void insertTabletTest3(String deviceId) throws IoTDBConnectionException, BatchExecutionException { - Schema schema = new Schema(); - schema.registerTimeseries(new Path(deviceId, "s1"), - new MeasurementSchema("s1", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path(deviceId, "s2"), - new MeasurementSchema("s2", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path(deviceId, "s3"), - new MeasurementSchema("s3", TSDataType.INT64, TSEncoding.RLE)); + - RowBatch rowBatch = schema.createRowBatch(deviceId, 200); + 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)); - long[] timestamps = rowBatch.timestamps; - Object[] values = rowBatch.values; + Tablet tablet = new Tablet(deviceId, schemaList, 200); + + long[] timestamps = tablet.timestamps; + Object[] values = tablet.values; for (long time = 500; time < 1500; time++) { - int row = rowBatch.batchSize++; + int row = tablet.rowSize++; timestamps[row] = time; for (int i = 0; i < 3; i++) { long[] sensor = (long[]) values[i]; @@@ -843,32 -863,25 +891,26 @@@ } } - private void insertRowBatchTestForTime(String deviceId) + private void insertTabletTestForTime(String deviceId) throws IoTDBConnectionException, BatchExecutionException { - Schema schema = new Schema(); - schema.registerTimeseries(new Path(deviceId, "s1"), - new MeasurementSchema("s1", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path(deviceId, "s2"), - new MeasurementSchema("s2", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path(deviceId, "s3"), - new MeasurementSchema("s3", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path(deviceId, "s4"), - new MeasurementSchema("s1", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path(deviceId, "s5"), - new MeasurementSchema("s2", TSDataType.INT64, TSEncoding.RLE)); - schema.registerTimeseries(new Path(deviceId, "s6"), - new MeasurementSchema("s3", TSDataType.INT64, TSEncoding.RLE)); ++ + 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)); + schemaList.add(new MeasurementSchema("s4", TSDataType.INT64, TSEncoding.RLE)); + schemaList.add(new MeasurementSchema("s5", TSDataType.INT64, TSEncoding.RLE)); + schemaList.add(new MeasurementSchema("s6", TSDataType.INT64, TSEncoding.RLE)); long count = 10000000; long begin = 0; - //long begin = 1579414903000L; - RowBatch rowBatch = schema.createRowBatch(deviceId, 1000); + Tablet tablet = new Tablet(deviceId, schemaList, 1000); - long[] timestamps = rowBatch.timestamps; - Object[] values = rowBatch.values; + long[] timestamps = tablet.timestamps; + Object[] values = tablet.values; for (long time = begin; time < count + begin; time++) { - int row = rowBatch.batchSize++; + int row = tablet.rowSize++; timestamps[row] = time; for (int i = 0; i < 6; i++) { long[] sensor = (long[]) values[i]; diff --cc session/src/test/java/org/apache/iotdb/session/pool/SessionPoolTest.java index 5923577,00d03ff..79e1962 --- a/session/src/test/java/org/apache/iotdb/session/pool/SessionPoolTest.java +++ b/session/src/test/java/org/apache/iotdb/session/pool/SessionPoolTest.java @@@ -60,8 -55,7 +56,8 @@@ public class SessionPoolTest final int no = i; service.submit(() -> { try { - pool.insert("root.sg1.d1", 1, Collections.singletonList("s" + no), - pool.insertRecord("root.sg1.d1", 1, Collections.singletonList("s" + no), Collections.singletonList("3")); ++ pool.insertRecord("root.sg1.d1", 1, Collections.singletonList("s" + no), + Collections.singletonList(TSDataType.INT64), Collections.singletonList(3L)); } catch (IoTDBConnectionException | StatementExecutionException e) { fail(); } @@@ -84,9 -78,7 +80,9 @@@ SessionPool pool = new SessionPool("127.0.0.1", 6667, "root", "root", 3); assertEquals(0, pool.currentAvailableSize()); try { - pool.insert(".root.sg1.d1", 1, Collections.singletonList("s"), - pool.insertRecord(".root.sg1.d1", 1, Collections.singletonList("s" ), Collections.singletonList("3")); ++ pool.insertRecord(".root.sg1.d1", 1, Collections.singletonList("s"), + Collections.singletonList(TSDataType.INT64), + Collections.singletonList(3L)); } catch (IoTDBConnectionException | StatementExecutionException e) { //do nothing } @@@ -101,9 -93,7 +97,9 @@@ ExecutorService service = Executors.newFixedThreadPool(10); for (int i = 0; i < 10; i++) { try { - pool.insert("root.sg1.d1", i, Collections.singletonList("s" + i), - pool.insertRecord("root.sg1.d1", i, Collections.singletonList("s" + i), Collections.singletonList("" + i)); ++ pool.insertRecord("root.sg1.d1", i, Collections.singletonList("s" + i), + Collections.singletonList(TSDataType.INT64), + Collections.singletonList((long) i)); } catch (IoTDBConnectionException | StatementExecutionException e) { fail(); } @@@ -145,9 -134,7 +141,9 @@@ ExecutorService service = Executors.newFixedThreadPool(10); for (int i = 0; i < 10; i++) { try { - pool.insert("root.sg1.d1", i, Collections.singletonList("s" + i), - pool.insertRecord("root.sg1.d1", i, Collections.singletonList("s" + i), Collections.singletonList("" + i)); ++ pool.insertRecord("root.sg1.d1", i, Collections.singletonList("s" + i), + Collections.singletonList(TSDataType.INT64), + Collections.singletonList((long) i)); } catch (IoTDBConnectionException | StatementExecutionException e) { fail(); } @@@ -183,9 -169,7 +179,9 @@@ SessionPool pool = new SessionPool("127.0.0.1", 6667, "root", "root", 3, 1, 6000, false); for (int i = 0; i < 10; i++) { try { - pool.insert("root.sg1.d1", i, Collections.singletonList("s" + i), - pool.insertRecord("root.sg1.d1", i, Collections.singletonList("s" + i), Collections.singletonList("" + i)); ++ pool.insertRecord("root.sg1.d1", i, Collections.singletonList("s" + i), + Collections.singletonList(TSDataType.INT64), + Collections.singletonList((long) i)); } catch (IoTDBConnectionException | StatementExecutionException e) { fail(); } @@@ -220,9 -204,7 +216,9 @@@ SessionPool pool = new SessionPool("127.0.0.1", 6667, "root", "root", 3, 1, 60000, false); for (int i = 0; i < 10; i++) { try { - pool.insert("root.sg1.d1", i, Collections.singletonList("s" + i), - pool.insertRecord("root.sg1.d1", i, Collections.singletonList("s" + i), Collections.singletonList("" + i)); ++ pool.insertRecord("root.sg1.d1", i, Collections.singletonList("s" + i), + Collections.singletonList(TSDataType.INT64), + Collections.singletonList((long) i)); } catch (IoTDBConnectionException | StatementExecutionException e) { fail(); }
