You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by ma...@apache.org on 2023/04/26 02:05:52 UTC
[iotdb] branch rel/1.1 updated: [To rel/1.1][IOTDB-5807]Fix decompression error for aligned series in fast compaction
This is an automated email from the ASF dual-hosted git repository.
marklau99 pushed a commit to branch rel/1.1
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/rel/1.1 by this push:
new 2624c5a366 [To rel/1.1][IOTDB-5807]Fix decompression error for aligned series in fast compaction
2624c5a366 is described below
commit 2624c5a3660faf887c6a5305660db3654b79216c
Author: 周沛辰 <45...@users.noreply.github.com>
AuthorDate: Wed Apr 26 10:05:46 2023 +0800
[To rel/1.1][IOTDB-5807]Fix decompression error for aligned series in fast compaction
---
.../performer/impl/FastCompactionPerformer.java | 11 +-
.../impl/ReadPointCompactionPerformer.java | 3 +
.../execute/utils/MultiTsFileDeviceIterator.java | 4 +-
.../fast/AlignedSeriesCompactionExecutor.java | 3 +-
.../utils/writer/AbstractCompactionWriter.java | 7 +-
.../engine/compaction/AbstractCompactionTest.java | 3 +
.../compaction/FastAlignedCrossCompactionTest.java | 751 +++++++++++++++----
.../FastNonAlignedCrossCompactionTest.java | 767 ++++++++++++++-----
.../compaction/ReadChunkInnerCompactionTest.java | 377 ++++++++++
...va => ReadPointAlignedCrossCompactionTest.java} | 804 +++++++++++++++-----
...=> ReadPointNonAlignedCrossCompactionTest.java} | 820 ++++++++++++++++-----
.../compaction/utils/TsFileGeneratorUtils.java | 116 ++-
.../AlignedSeriesScanLimitOffsetPushDownTest.java | 36 +-
.../series/SeriesScanLimitOffsetPushDownTest.java | 23 +-
.../iotdb/tsfile/read/TsFileSequenceReader.java | 2 +-
.../read/reader/chunk/AlignedChunkReader.java | 40 +-
.../tsfile/read/reader/chunk/ChunkReader.java | 4 +
.../tsfile/write/chunk/AlignedChunkWriterImpl.java | 42 +-
18 files changed, 3056 insertions(+), 757 deletions(-)
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/performer/impl/FastCompactionPerformer.java b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/performer/impl/FastCompactionPerformer.java
index ba306efe05..ffc8330729 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/performer/impl/FastCompactionPerformer.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/performer/impl/FastCompactionPerformer.java
@@ -52,15 +52,13 @@ import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
-import java.util.HashMap;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-import static org.apache.iotdb.tsfile.common.constant.TsFileConstant.TIME_COLUMN_ID;
-
public class FastCompactionPerformer
implements ICrossCompactionPerformer, ISeqCompactionPerformer, IUnseqCompactionPerformer {
private final Logger LOGGER = LoggerFactory.getLogger(IoTDBConstant.COMPACTION_LOGGER_NAME);
@@ -172,7 +170,7 @@ public class FastCompactionPerformer
throws PageException, IOException, WriteProcessException, IllegalPathException {
// measurement -> tsfile resource -> timeseries metadata <startOffset, endOffset>
Map<String, Map<TsFileResource, Pair<Long, Long>>> timeseriesMetadataOffsetMap =
- new HashMap<>();
+ new LinkedHashMap<>();
List<IMeasurementSchema> measurementSchemas = new ArrayList<>();
// Get all value measurements and their schemas of the current device. Also get start offset and
@@ -184,9 +182,7 @@ public class FastCompactionPerformer
// overlapped tsfiles contain all the value measurements.
for (Map.Entry<String, Pair<MeasurementSchema, Map<TsFileResource, Pair<Long, Long>>>> entry :
deviceIterator.getTimeseriesSchemaAndMetadataOffsetOfCurrentDevice().entrySet()) {
- if (!entry.getKey().equals(TIME_COLUMN_ID)) {
- measurementSchemas.add(entry.getValue().left);
- }
+ measurementSchemas.add(entry.getValue().left);
timeseriesMetadataOffsetMap.put(entry.getKey(), entry.getValue().right);
}
@@ -218,6 +214,7 @@ public class FastCompactionPerformer
deviceIterator.getTimeseriesMetadataOffsetOfCurrentDevice();
List<String> allMeasurements = new ArrayList<>(timeseriesMetadataOffsetMap.keySet());
+ allMeasurements.sort((String::compareTo));
int subTaskNums = Math.min(allMeasurements.size(), subTaskNum);
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/performer/impl/ReadPointCompactionPerformer.java b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/performer/impl/ReadPointCompactionPerformer.java
index 637501d852..8384916b92 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/performer/impl/ReadPointCompactionPerformer.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/performer/impl/ReadPointCompactionPerformer.java
@@ -42,6 +42,7 @@ import org.apache.iotdb.db.engine.querycontext.QueryDataSource;
import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
import org.apache.iotdb.db.mpp.execution.fragment.FragmentInstanceContext;
import org.apache.iotdb.db.query.control.QueryResourceManager;
+import org.apache.iotdb.tsfile.common.constant.TsFileConstant;
import org.apache.iotdb.tsfile.read.common.block.TsBlock;
import org.apache.iotdb.tsfile.read.reader.IPointReader;
import org.apache.iotdb.tsfile.utils.Pair;
@@ -155,6 +156,7 @@ public class ReadPointCompactionPerformer
QueryDataSource queryDataSource)
throws IOException, MetadataException {
Map<String, MeasurementSchema> schemaMap = deviceIterator.getAllSchemasOfCurrentDevice();
+ IMeasurementSchema timeSchema = schemaMap.remove(TsFileConstant.TIME_COLUMN_ID);
List<IMeasurementSchema> measurementSchemas = new ArrayList<>(schemaMap.values());
if (measurementSchemas.isEmpty()) {
return;
@@ -176,6 +178,7 @@ public class ReadPointCompactionPerformer
if (dataBlockReader.hasNextBatch()) {
// chunkgroup is serialized only when at least one timeseries under this device has data
compactionWriter.startChunkGroup(device, true);
+ measurementSchemas.add(0, timeSchema);
compactionWriter.startMeasurement(measurementSchemas, 0);
writeWithReader(compactionWriter, dataBlockReader, device, 0, true);
compactionWriter.endMeasurement(0);
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/MultiTsFileDeviceIterator.java b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/MultiTsFileDeviceIterator.java
index 7572e797e1..967338d1f8 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/MultiTsFileDeviceIterator.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/MultiTsFileDeviceIterator.java
@@ -39,6 +39,7 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
+import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
@@ -197,7 +198,6 @@ public class MultiTsFileDeviceIterator implements AutoCloseable {
}
}
}
- schemaMap.remove("");
return schemaMap;
}
@@ -247,7 +247,7 @@ public class MultiTsFileDeviceIterator implements AutoCloseable {
public Map<String, Pair<MeasurementSchema, Map<TsFileResource, Pair<Long, Long>>>>
getTimeseriesSchemaAndMetadataOffsetOfCurrentDevice() throws IOException {
Map<String, Pair<MeasurementSchema, Map<TsFileResource, Pair<Long, Long>>>>
- timeseriesMetadataOffsetMap = new HashMap<>();
+ timeseriesMetadataOffsetMap = new LinkedHashMap<>();
for (TsFileResource resource : tsFileResourcesSortedByDesc) {
if (!deviceIteratorMap.containsKey(resource)
|| !deviceIteratorMap.get(resource).current().equals(currentDevice)) {
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/executor/fast/AlignedSeriesCompactionExecutor.java b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/executor/fast/AlignedSeriesCompactionExecutor.java
index 3c4df9022c..2f939a1f37 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/executor/fast/AlignedSeriesCompactionExecutor.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/executor/fast/AlignedSeriesCompactionExecutor.java
@@ -52,6 +52,7 @@ import java.util.Map;
public class AlignedSeriesCompactionExecutor extends SeriesCompactionExecutor {
// measurementID -> tsfile resource -> timeseries metadata <startOffset, endOffset>
+ // linked hash map, which has the same measurement lexicographical order as measurementSchemas.
// used to get the chunk metadatas from tsfile directly according to timeseries metadata offset.
private final Map<String, Map<TsFileResource, Pair<Long, Long>>> timeseriesMetadataOffsetMap;
@@ -274,7 +275,7 @@ public class AlignedSeriesCompactionExecutor extends SeriesCompactionExecutor {
alignedPageHeaders,
compressedTimePageDatas.get(i),
alignedPageDatas,
- new AlignedChunkReader(timeChunk, valueChunks, null),
+ new AlignedChunkReader(timeChunk, valueChunks),
chunkMetadataElement,
i == timePageHeaders.size() - 1,
chunkMetadataElement.priority));
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/writer/AbstractCompactionWriter.java b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/writer/AbstractCompactionWriter.java
index 553167b1c9..471cb8a3a9 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/writer/AbstractCompactionWriter.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/writer/AbstractCompactionWriter.java
@@ -23,6 +23,7 @@ import org.apache.iotdb.db.engine.compaction.schedule.CompactionTaskManager;
import org.apache.iotdb.db.engine.compaction.schedule.constant.CompactionType;
import org.apache.iotdb.db.engine.compaction.schedule.constant.ProcessChunkType;
import org.apache.iotdb.db.service.metrics.recorder.CompactionMetricsManager;
+import org.apache.iotdb.tsfile.common.constant.TsFileConstant;
import org.apache.iotdb.tsfile.exception.write.PageException;
import org.apache.iotdb.tsfile.file.header.PageHeader;
import org.apache.iotdb.tsfile.file.metadata.ChunkMetadata;
@@ -106,8 +107,10 @@ public abstract class AbstractCompactionWriter implements AutoCloseable {
lastCheckIndex = 0;
lastTime[subTaskId] = Long.MIN_VALUE;
if (isAlign) {
- chunkWriters[subTaskId] = new AlignedChunkWriterImpl(measurementSchemaList);
- measurementId[subTaskId] = "";
+ // the first is time schema and the rest is value schema list
+ chunkWriters[subTaskId] =
+ new AlignedChunkWriterImpl(measurementSchemaList.remove(0), measurementSchemaList);
+ measurementId[subTaskId] = TsFileConstant.TIME_COLUMN_ID;
} else {
chunkWriters[subTaskId] = new ChunkWriterImpl(measurementSchemaList.get(0), true);
measurementId[subTaskId] = measurementSchemaList.get(0).getMeasurementId();
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/compaction/AbstractCompactionTest.java b/server/src/test/java/org/apache/iotdb/db/engine/compaction/AbstractCompactionTest.java
index c3c8e6366e..51952b43cd 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/compaction/AbstractCompactionTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/compaction/AbstractCompactionTest.java
@@ -84,6 +84,9 @@ public class AbstractCompactionTest {
protected static String COMPACTION_TEST_SG = TsFileGeneratorUtils.testStorageGroup;
private TSDataType dataType;
+ protected int maxDeviceNum = 25;
+ protected int maxMeasurementNum = 25;
+
private static final long oldTargetChunkSize =
IoTDBDescriptor.getInstance().getConfig().getTargetChunkSize();
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastAlignedCrossCompactionTest.java b/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastAlignedCrossCompactionTest.java
index 06e7f59697..415a63487b 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastAlignedCrossCompactionTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastAlignedCrossCompactionTest.java
@@ -29,7 +29,9 @@ import org.apache.iotdb.db.exception.StorageEngineException;
import org.apache.iotdb.db.query.control.FileReaderManager;
import org.apache.iotdb.tsfile.common.conf.TSFileDescriptor;
import org.apache.iotdb.tsfile.exception.write.WriteProcessException;
+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.TimeValuePair;
import org.apache.iotdb.tsfile.read.common.TimeRange;
import org.apache.iotdb.tsfile.write.chunk.AlignedChunkWriterImpl;
@@ -48,7 +50,9 @@ import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createChunkWriter;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createCompressionType;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createDataType;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createEncodingType;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createTimeseries;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.testStorageGroup;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.writeAlignedChunk;
@@ -92,6 +96,9 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
+
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -103,7 +110,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(0L, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, true)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true)) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -127,6 +135,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -137,7 +147,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = new ArrayList<>();
pages.add(new TimeRange(200L, 2200L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, true)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true)) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
tsFileIOWriter.endChunkGroup();
@@ -161,6 +172,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -173,7 +186,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(1550L, 1700L));
pages.add(new TimeRange(1750L, 2000L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, true)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true)) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -197,6 +211,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -209,7 +225,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(1200L, 1300L));
pages.add(new TimeRange(1500L, 1600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, true)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true)) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
tsFileIOWriter.endChunkGroup();
@@ -228,7 +245,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
@@ -262,6 +279,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -273,7 +292,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(100L, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, true)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true)) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -297,6 +317,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -309,7 +331,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(900L, 1189L));
timeRanges.add(new TimeRange(1301L, 1400L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneAlignedPage((AlignedChunkWriterImpl) iChunkWriter, timeRanges, true);
iChunkWriter.writeToFileWriter(tsFileIOWriter);
@@ -346,6 +369,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -358,7 +383,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(0L, 1189L));
timeRanges.add(new TimeRange(1301L, 2000L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneAlignedPage((AlignedChunkWriterImpl) iChunkWriter, timeRanges, false);
iChunkWriter.writeToFileWriter(tsFileIOWriter);
@@ -393,6 +419,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -406,7 +434,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(1200L, 1300L));
timeRanges.add(new TimeRange(1500L, 2200L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk(
(AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
@@ -433,6 +462,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -446,7 +477,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(550L, 700L));
timeRanges.add(new TimeRange(1050L, 1150L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk(
(AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
@@ -468,7 +500,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -500,6 +532,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -511,7 +545,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(100L, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, true)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true)) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -535,6 +570,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -547,7 +584,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(900L, 1249L));
timeRanges.add(new TimeRange(1351L, 1400L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneAlignedPage((AlignedChunkWriterImpl) iChunkWriter, timeRanges, true);
iChunkWriter.writeToFileWriter(tsFileIOWriter);
@@ -584,6 +622,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -596,7 +636,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(0L, 1249L));
timeRanges.add(new TimeRange(1351L, 2000L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneAlignedPage((AlignedChunkWriterImpl) iChunkWriter, timeRanges, false);
iChunkWriter.writeToFileWriter(tsFileIOWriter);
@@ -631,6 +672,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -644,7 +687,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(1250L, 1350L));
timeRanges.add(new TimeRange(1500L, 2200L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk(
(AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
@@ -671,6 +715,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -684,7 +730,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(550L, 700L));
timeRanges.add(new TimeRange(1050L, 1150L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk(
(AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
@@ -706,7 +753,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -738,6 +785,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -745,7 +794,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -786,13 +836,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -825,13 +878,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -877,13 +933,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -917,13 +976,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -961,7 +1023,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -993,6 +1055,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -1000,7 +1064,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1041,13 +1106,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1080,13 +1148,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1125,13 +1196,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1177,13 +1251,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1224,13 +1301,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1264,13 +1344,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1309,7 +1392,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -1341,6 +1424,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -1348,7 +1433,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1389,13 +1475,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1428,13 +1517,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1473,13 +1565,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1525,13 +1620,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1572,13 +1670,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1612,13 +1713,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1665,7 +1769,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -1697,6 +1801,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -1704,7 +1810,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1747,13 +1854,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1794,13 +1904,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1839,13 +1952,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1891,13 +2007,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1938,13 +2057,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1978,13 +2100,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2031,7 +2156,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -2063,6 +2188,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -2070,7 +2197,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2111,13 +2239,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2150,13 +2281,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2197,13 +2331,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2249,13 +2386,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2296,13 +2436,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2336,13 +2479,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2381,7 +2527,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -2413,6 +2559,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -2420,7 +2568,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2461,13 +2610,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2500,13 +2652,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2547,13 +2702,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2599,13 +2757,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2646,13 +2807,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2686,13 +2850,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2732,7 +2899,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -2764,6 +2931,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -2771,7 +2940,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2814,13 +2984,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2861,13 +3034,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2908,13 +3084,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2960,13 +3139,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3007,13 +3189,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3047,13 +3232,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3093,7 +3281,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
validateSeqFiles(true);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
@@ -3126,6 +3314,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -3133,7 +3323,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3174,13 +3365,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3216,13 +3410,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3266,13 +3463,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3324,13 +3524,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3373,13 +3576,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3413,13 +3619,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3468,13 +3677,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3507,7 +3719,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -3539,6 +3751,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -3546,7 +3760,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3589,13 +3804,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3631,13 +3849,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3681,13 +3902,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3740,13 +3964,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3789,13 +4016,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3829,13 +4059,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3884,13 +4117,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3923,7 +4159,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -3955,6 +4191,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -3962,7 +4200,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4005,13 +4244,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4047,13 +4289,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4097,13 +4342,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -4156,13 +4404,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4205,13 +4456,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4245,13 +4499,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -4300,13 +4557,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4339,7 +4599,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -4371,6 +4631,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -4378,7 +4640,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4421,13 +4684,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4463,13 +4729,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4513,13 +4782,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -4572,13 +4844,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4621,13 +4896,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4661,13 +4939,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -4716,13 +4997,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4760,13 +5044,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4804,7 +5091,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -4836,6 +5123,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -4843,7 +5132,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4886,13 +5176,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4928,13 +5221,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4978,13 +5274,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -5034,13 +5333,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -5083,13 +5385,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -5123,13 +5428,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -5178,13 +5486,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -5217,7 +5528,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -5249,6 +5560,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5262,7 +5575,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(100, 199));
pages.add(new TimeRange(200, 300));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5295,6 +5609,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5305,7 +5621,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(900, 1400, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5343,6 +5660,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5353,7 +5672,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(200, 2200, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5379,6 +5699,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5389,7 +5711,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(550, 800, 70);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5423,7 +5746,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -5455,6 +5778,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5465,7 +5790,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(100, 300, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5497,6 +5823,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5508,7 +5836,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = createPages(900, 1199, 100);
pages.addAll(createPages(1301, 1400, 100));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5552,6 +5881,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5563,7 +5894,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = createPages(0, 1199, 50);
pages.addAll(createPages(1301, 2000, 100));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5595,6 +5927,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5605,7 +5939,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(550, 800, 70);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5644,6 +5979,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5654,7 +5991,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(350, 400, 70);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5688,7 +6026,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -5720,6 +6058,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5730,7 +6070,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(0, 300, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5762,6 +6103,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5773,7 +6116,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = createPages(900, 1199, 100);
pages.addAll(createPages(1301, 1400, 100));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5798,6 +6142,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5808,7 +6154,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(1800, 1900, 30);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5846,6 +6193,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5857,7 +6206,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = createPages(100, 1199, 50);
pages.addAll(createPages(1301, 1650, 100));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5889,6 +6239,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5899,7 +6251,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(2200, 2400, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5932,6 +6285,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5942,7 +6297,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(550, 800, 70);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5986,6 +6342,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5996,7 +6354,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(350, 400, 25);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6034,6 +6393,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6044,7 +6405,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(2700, 2800, 25);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6071,7 +6433,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -6103,6 +6465,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6110,7 +6474,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6151,13 +6516,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6190,13 +6558,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6237,13 +6608,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -6289,13 +6663,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6336,13 +6713,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6376,13 +6756,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -6422,7 +6805,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -6454,6 +6837,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6464,7 +6849,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(300, 600, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -6502,6 +6888,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6512,7 +6900,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(1600, 1900, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -6544,6 +6933,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6554,7 +6945,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(0, 2000, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6580,6 +6972,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6590,7 +6984,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(100, 400, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6623,6 +7018,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6633,7 +7030,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(450, 950, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6661,7 +7059,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -6693,6 +7091,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6708,7 +7108,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(900, 1100));
pages.add(new TimeRange(1400, 1600));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -6734,6 +7135,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6744,7 +7147,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
// first page
timeRanges.clear();
@@ -6795,7 +7199,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -6827,6 +7231,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6837,7 +7243,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(0, 1000, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -6875,6 +7282,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6885,7 +7294,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(50, 250, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6932,6 +7342,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6942,7 +7354,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(700, 800, 50);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6977,7 +7390,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -7010,6 +7423,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -7021,7 +7436,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(0, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, true)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true)) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -7045,6 +7461,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -7058,7 +7476,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(1350, 1700));
timeRanges.add(new TimeRange(1750, 2000));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk(
(AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, true);
@@ -7093,6 +7512,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -7104,7 +7525,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> timeRanges = new ArrayList<>();
timeRanges.add(new TimeRange(500, 950));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk(
(AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
@@ -7149,6 +7571,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -7161,7 +7585,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(500, 800));
timeRanges.add(new TimeRange(850, 950));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk(
(AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
@@ -7193,7 +7618,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastNonAlignedCrossCompactionTest.java b/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastNonAlignedCrossCompactionTest.java
index a91cab2062..b50a69e339 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastNonAlignedCrossCompactionTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastNonAlignedCrossCompactionTest.java
@@ -30,7 +30,9 @@ import org.apache.iotdb.db.exception.StorageEngineException;
import org.apache.iotdb.db.query.control.FileReaderManager;
import org.apache.iotdb.tsfile.common.conf.TSFileDescriptor;
import org.apache.iotdb.tsfile.exception.write.WriteProcessException;
+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.TimeValuePair;
import org.apache.iotdb.tsfile.read.common.TimeRange;
import org.apache.iotdb.tsfile.write.chunk.ChunkWriterImpl;
@@ -49,7 +51,9 @@ import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createChunkWriter;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createCompressionType;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createDataType;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createEncodingType;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createTimeseries;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.testStorageGroup;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.writeNonAlignedChunk;
@@ -91,6 +95,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(10);
+ List<TSEncoding> encodings = createEncodingType(10);
+ List<CompressionType> compressionTypes = createCompressionType(10);
List<PartialPath> timeseriesPath = new ArrayList<>();
for (int i = 0; i < 10; i++) {
timeseriesPath.add(
@@ -109,12 +115,13 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(0L, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, false)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
resource.updateStartTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 0);
- resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 599);
+ resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 600);
timeserisPathList.addAll(timeseriesPath);
tsDataTypes.addAll(dataTypes);
}
@@ -124,13 +131,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
seqResources.add(resource);
// unseq file 1
+ int measurementNum = 5;
resource = createEmptyFileAndResource(false);
try (TsFileIOWriter tsFileIOWriter = new TsFileIOWriter(resource.getTsFile())) {
// write the data in device
for (int deviceIndex = 0; deviceIndex < 15; deviceIndex++) {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
- List<TSDataType> dataTypes = createDataType(5);
+ List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<PartialPath> timeseriesPath = new ArrayList<>();
for (int i = 0; i < 5; i++) {
timeseriesPath.add(
@@ -148,12 +158,13 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = new ArrayList<>();
pages.add(new TimeRange(200L, 2200L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, false)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
tsFileIOWriter.endChunkGroup();
resource.updateStartTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 200);
- resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 2199);
+ resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 2200);
timeserisPathList.addAll(timeseriesPath);
tsDataTypes.addAll(dataTypes);
}
@@ -163,13 +174,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
unseqResources.add(resource);
// seq file 2
+ measurementNum = 5;
resource = createEmptyFileAndResource(true);
try (TsFileIOWriter tsFileIOWriter = new TsFileIOWriter(resource.getTsFile())) {
// write the data in device
for (int deviceIndex = 0; deviceIndex < 12; deviceIndex++) {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
- List<TSDataType> dataTypes = createDataType(5);
+ List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<PartialPath> timeseriesPath = new ArrayList<>();
for (int i = 0; i < 5; i++) {
timeseriesPath.add(
@@ -189,12 +203,13 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(1550L, 1700L));
pages.add(new TimeRange(1750L, 2000L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, false)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
resource.updateStartTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 900);
- resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 1999);
+ resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 2000);
timeserisPathList.addAll(timeseriesPath);
tsDataTypes.addAll(dataTypes);
}
@@ -204,13 +219,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
seqResources.add(resource);
// unseq file 2
+ measurementNum = 5;
resource = createEmptyFileAndResource(false);
try (TsFileIOWriter tsFileIOWriter = new TsFileIOWriter(resource.getTsFile())) {
// write the data in device
for (int deviceIndex = 0; deviceIndex < 15; deviceIndex++) {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
- List<TSDataType> dataTypes = createDataType(5);
+ List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<PartialPath> timeseriesPath = new ArrayList<>();
for (int i = 0; i < 5; i++) {
timeseriesPath.add(
@@ -230,12 +248,13 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(1200L, 1300L));
pages.add(new TimeRange(1500L, 1600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, false)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
tsFileIOWriter.endChunkGroup();
resource.updateStartTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 550);
- resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 1599);
+ resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 1600);
timeserisPathList.addAll(timeseriesPath);
tsDataTypes.addAll(dataTypes);
}
@@ -249,7 +268,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -282,6 +301,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -293,7 +314,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(100L, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, false)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -317,6 +339,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -329,7 +353,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(900L, 1189L));
timeRanges.add(new TimeRange(1301L, 1400L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneNonAlignedPage((ChunkWriterImpl) iChunkWriter, timeRanges, true);
((ChunkWriterImpl) iChunkWriter).writeToFileWriter(tsFileIOWriter);
@@ -365,6 +390,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -377,7 +404,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(0L, 1189L));
timeRanges.add(new TimeRange(1301L, 2000L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneNonAlignedPage((ChunkWriterImpl) iChunkWriter, timeRanges, false);
((ChunkWriterImpl) iChunkWriter).writeToFileWriter(tsFileIOWriter);
@@ -411,6 +439,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -424,7 +454,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(1200L, 1300L));
timeRanges.add(new TimeRange(1500L, 2200L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
}
@@ -450,6 +481,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -463,7 +496,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(550L, 700L));
timeRanges.add(new TimeRange(1050L, 1150L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
}
@@ -484,7 +518,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -516,6 +550,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -527,7 +563,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(100L, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, false)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -551,6 +588,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -563,7 +602,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(900L, 1249L));
timeRanges.add(new TimeRange(1351L, 1400L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneNonAlignedPage((ChunkWriterImpl) iChunkWriter, timeRanges, true);
((ChunkWriterImpl) iChunkWriter).writeToFileWriter(tsFileIOWriter);
@@ -599,6 +639,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -611,7 +653,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(0L, 1249L));
timeRanges.add(new TimeRange(1351L, 2000L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneNonAlignedPage((ChunkWriterImpl) iChunkWriter, timeRanges, false);
((ChunkWriterImpl) iChunkWriter).writeToFileWriter(tsFileIOWriter);
@@ -645,6 +688,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -658,7 +703,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(1250L, 1350L));
timeRanges.add(new TimeRange(1500L, 2200L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
}
@@ -684,6 +730,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -697,7 +745,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(550L, 700L));
timeRanges.add(new TimeRange(1050L, 1150L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
}
@@ -718,7 +767,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -750,6 +799,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -757,7 +808,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -798,13 +850,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -837,13 +892,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -888,13 +946,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -928,13 +989,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -970,7 +1034,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -1002,6 +1066,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -1009,7 +1075,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1050,13 +1117,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1089,13 +1159,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1134,13 +1207,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1185,13 +1261,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1232,13 +1311,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1272,13 +1354,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1315,7 +1400,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -1347,6 +1432,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -1354,7 +1441,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1395,13 +1483,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1434,13 +1525,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1479,13 +1573,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1530,13 +1627,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1577,13 +1677,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1617,13 +1720,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1667,7 +1773,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -1699,6 +1805,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -1706,7 +1814,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1749,13 +1858,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1796,13 +1908,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1841,13 +1956,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1892,13 +2010,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1939,13 +2060,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1979,13 +2103,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2029,7 +2156,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -2061,6 +2188,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -2068,7 +2197,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2109,13 +2239,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2148,13 +2281,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2195,13 +2331,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2246,13 +2385,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2293,13 +2435,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2333,13 +2478,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2376,7 +2524,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -2408,6 +2556,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -2415,7 +2565,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2456,13 +2607,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2495,13 +2649,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2542,13 +2699,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2593,13 +2753,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2640,13 +2803,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2680,13 +2846,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2724,7 +2893,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -2756,6 +2925,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -2763,7 +2934,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2806,13 +2978,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2853,13 +3028,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2900,13 +3078,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2951,13 +3132,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2998,13 +3182,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3038,13 +3225,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3082,7 +3272,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -3114,6 +3304,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -3121,7 +3313,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3162,13 +3355,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3204,13 +3400,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3254,13 +3453,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3311,13 +3513,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3360,13 +3565,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3400,13 +3608,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3453,13 +3664,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3492,7 +3706,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -3524,6 +3738,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -3531,7 +3747,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3574,13 +3791,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3616,13 +3836,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3666,13 +3889,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3724,13 +3950,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3773,13 +4002,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3813,13 +4045,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3866,13 +4101,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3905,7 +4143,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -3937,6 +4175,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -3944,7 +4184,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3987,13 +4228,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4029,13 +4273,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4079,13 +4326,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -4137,13 +4387,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4186,13 +4439,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4226,13 +4482,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -4279,13 +4538,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4318,7 +4580,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -4350,6 +4612,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -4357,7 +4621,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4400,13 +4665,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4442,13 +4710,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4492,13 +4763,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -4550,13 +4824,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4599,13 +4876,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4639,13 +4919,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -4692,13 +4975,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4736,13 +5022,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4780,7 +5069,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -4812,6 +5101,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -4819,7 +5110,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4862,13 +5154,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4904,13 +5199,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4954,13 +5252,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -5009,13 +5310,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -5058,13 +5362,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -5098,13 +5405,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -5151,13 +5461,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -5190,7 +5503,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -5222,6 +5535,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5235,7 +5550,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(100, 199));
pages.add(new TimeRange(200, 300));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -5268,6 +5584,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5278,7 +5596,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(900, 1400, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -5316,6 +5635,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5326,7 +5647,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(200, 2200, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5352,6 +5674,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5362,7 +5686,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(550, 800, 70);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5396,7 +5721,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -5428,6 +5753,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5438,7 +5765,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(100, 300, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -5470,6 +5798,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5481,7 +5811,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = createPages(900, 1199, 100);
pages.addAll(createPages(1301, 1400, 100));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -5525,6 +5856,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5536,7 +5869,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = createPages(0, 1199, 50);
pages.addAll(createPages(1301, 2000, 100));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5568,6 +5902,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5578,7 +5914,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(550, 800, 70);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5617,6 +5954,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5627,7 +5966,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(350, 400, 70);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5661,7 +6001,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -5693,6 +6033,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5703,7 +6045,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(0, 300, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -5735,6 +6078,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5746,7 +6091,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = createPages(900, 1199, 100);
pages.addAll(createPages(1301, 1400, 100));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -5771,6 +6117,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5781,7 +6129,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(1800, 1900, 30);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -5819,6 +6168,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5830,7 +6181,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = createPages(100, 1199, 50);
pages.addAll(createPages(1301, 1650, 100));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5862,6 +6214,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5872,7 +6226,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(2200, 2400, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5905,6 +6260,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5915,7 +6272,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(550, 800, 70);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5959,6 +6317,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5969,7 +6329,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(350, 400, 25);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6007,6 +6368,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6017,7 +6380,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(2700, 2800, 25);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6044,7 +6408,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -6076,6 +6440,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6083,7 +6449,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6124,13 +6491,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6163,13 +6533,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6210,13 +6583,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -6261,13 +6637,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6308,13 +6687,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6348,13 +6730,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -6392,7 +6777,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -6424,6 +6809,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6434,7 +6821,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(300, 600, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -6472,6 +6860,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6482,7 +6872,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(1600, 1900, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -6514,6 +6905,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6524,7 +6917,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(0, 2000, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6550,6 +6944,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6560,7 +6956,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(100, 400, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6593,6 +6990,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6603,7 +7002,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(450, 950, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6631,7 +7031,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -6663,6 +7063,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6678,7 +7080,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(900, 1100));
pages.add(new TimeRange(1400, 1600));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -6704,6 +7107,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6714,7 +7119,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
// first page
timeRanges.clear();
@@ -6765,7 +7171,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -6797,6 +7203,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6807,7 +7215,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(0, 1000, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -6845,6 +7254,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6855,7 +7266,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(50, 250, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6902,6 +7314,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6912,7 +7326,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(700, 800, 50);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6947,7 +7362,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
@@ -6980,6 +7395,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6991,7 +7408,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(0, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, false)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -7015,6 +7433,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -7028,7 +7448,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(1350, 1700));
timeRanges.add(new TimeRange(1750, 2000));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, true);
}
@@ -7061,6 +7482,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -7072,7 +7495,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> timeRanges = new ArrayList<>();
timeRanges.add(new TimeRange(500, 950));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
}
@@ -7114,6 +7538,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -7126,7 +7552,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(500, 800));
timeRanges.add(new TimeRange(850, 950));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
}
@@ -7156,7 +7583,7 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadChunkInnerCompactionTest.java b/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadChunkInnerCompactionTest.java
new file mode 100644
index 0000000000..3eb49e38ad
--- /dev/null
+++ b/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadChunkInnerCompactionTest.java
@@ -0,0 +1,377 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.iotdb.db.engine.compaction;
+
+import org.apache.iotdb.commons.exception.MetadataException;
+import org.apache.iotdb.commons.path.MeasurementPath;
+import org.apache.iotdb.commons.path.PartialPath;
+import org.apache.iotdb.db.conf.IoTDBDescriptor;
+import org.apache.iotdb.db.engine.compaction.execute.performer.impl.ReadChunkCompactionPerformer;
+import org.apache.iotdb.db.engine.compaction.execute.task.InnerSpaceCompactionTask;
+import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
+import org.apache.iotdb.db.exception.StorageEngineException;
+import org.apache.iotdb.db.query.control.FileReaderManager;
+import org.apache.iotdb.tsfile.common.conf.TSFileDescriptor;
+import org.apache.iotdb.tsfile.exception.write.WriteProcessException;
+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.TimeValuePair;
+import org.apache.iotdb.tsfile.read.common.TimeRange;
+import org.apache.iotdb.tsfile.write.chunk.AlignedChunkWriterImpl;
+import org.apache.iotdb.tsfile.write.chunk.ChunkWriterImpl;
+import org.apache.iotdb.tsfile.write.chunk.IChunkWriter;
+import org.apache.iotdb.tsfile.write.writer.TsFileIOWriter;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createChunkWriter;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createCompressionType;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createDataType;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createEncodingType;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createTimeseries;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.writeAlignedChunk;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.writeNonAlignedChunk;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.writeOneAlignedPage;
+import static org.apache.iotdb.tsfile.common.constant.TsFileConstant.PATH_SEPARATOR;
+
+public class ReadChunkInnerCompactionTest extends AbstractCompactionTest {
+ @Before
+ public void setUp()
+ throws IOException, WriteProcessException, MetadataException, InterruptedException {
+ super.setUp();
+ IoTDBDescriptor.getInstance().getConfig().setTargetChunkSize(512);
+ IoTDBDescriptor.getInstance().getConfig().setTargetChunkPointNum(100);
+ TSFileDescriptor.getInstance().getConfig().setMaxNumberOfPointsInPage(30);
+ TSFileDescriptor.getInstance().getConfig().setMaxDegreeOfIndexNode(3);
+ }
+
+ @After
+ public void tearDown() throws IOException, StorageEngineException {
+ super.tearDown();
+ for (TsFileResource tsFileResource : seqResources) {
+ FileReaderManager.getInstance().closeFileAndRemoveReader(tsFileResource.getTsFilePath());
+ }
+ for (TsFileResource tsFileResource : unseqResources) {
+ FileReaderManager.getInstance().closeFileAndRemoveReader(tsFileResource.getTsFilePath());
+ }
+ }
+
+ @Test
+ public void testNonAlignedWithDifferentEncodingAndCompression()
+ throws MetadataException, IOException {
+ List<PartialPath> timeserisPathList = new ArrayList<>();
+ List<TSDataType> tsDataTypes = new ArrayList<>();
+ // seq file 1
+ int measurementNum = 20;
+ TsFileResource resource = createEmptyFileAndResource(true);
+ try (TsFileIOWriter tsFileIOWriter = new TsFileIOWriter(resource.getTsFile())) {
+ // write the data in device
+ for (int deviceIndex = 0; deviceIndex < 10; deviceIndex++) {
+ tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
+
+ List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
+ List<PartialPath> timeseriesPath = new ArrayList<>();
+ for (int i = 0; i < measurementNum; i++) {
+ timeseriesPath.add(
+ new MeasurementPath(
+ COMPACTION_TEST_SG
+ + PATH_SEPARATOR
+ + "d"
+ + deviceIndex
+ + PATH_SEPARATOR
+ + "s"
+ + i,
+ dataTypes.get(i)));
+ }
+
+ List<TimeRange> pages = new ArrayList<>();
+ pages.add(new TimeRange(0L, 300L));
+ pages.add(new TimeRange(500L, 600L));
+
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
+ writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
+ }
+ tsFileIOWriter.endChunkGroup();
+ resource.updateStartTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 0);
+ resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 600);
+ timeserisPathList.addAll(timeseriesPath);
+ tsDataTypes.addAll(dataTypes);
+ }
+ tsFileIOWriter.endFile();
+ }
+ resource.serialize();
+ seqResources.add(resource);
+
+ // seq file 2
+ measurementNum = 15;
+ resource = createEmptyFileAndResource(true);
+ try (TsFileIOWriter tsFileIOWriter = new TsFileIOWriter(resource.getTsFile())) {
+ // write the data in device
+ for (int deviceIndex = 0; deviceIndex < 12; deviceIndex++) {
+ tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
+
+ List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
+ List<PartialPath> timeseriesPath = new ArrayList<>();
+ for (int i = 0; i < 5; i++) {
+ timeseriesPath.add(
+ new MeasurementPath(
+ COMPACTION_TEST_SG
+ + PATH_SEPARATOR
+ + "d"
+ + deviceIndex
+ + PATH_SEPARATOR
+ + "s"
+ + i,
+ dataTypes.get(i)));
+ }
+
+ List<TimeRange> pages = new ArrayList<>();
+ pages.add(new TimeRange(900L, 1400L));
+ pages.add(new TimeRange(1550L, 1700L));
+ pages.add(new TimeRange(1750L, 2000L));
+
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
+ writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
+ }
+ tsFileIOWriter.endChunkGroup();
+ resource.updateStartTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 900);
+ resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 2000);
+ timeserisPathList.addAll(timeseriesPath);
+ tsDataTypes.addAll(dataTypes);
+ }
+ tsFileIOWriter.endFile();
+ }
+ resource.serialize();
+ seqResources.add(resource);
+
+ // start compacting
+ tsFileManager.addAll(seqResources, true);
+ tsFileManager.addAll(unseqResources, false);
+
+ Map<PartialPath, List<TimeValuePair>> sourceDatas =
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
+ InnerSpaceCompactionTask task =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ seqResources,
+ true,
+ new ReadChunkCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ task.start();
+
+ validateSeqFiles(true);
+
+ validateTargetDatas(sourceDatas, tsDataTypes);
+ }
+
+ @Test
+ public void testAlignedWithDifferentEncodingAndCompression()
+ throws MetadataException, IOException {
+ List<PartialPath> timeserisPathList = new ArrayList<>();
+ List<TSDataType> tsDataTypes = new ArrayList<>();
+ // seq file 1
+ int deviceNum = 10;
+ int measurementNum = 10;
+ TsFileResource resource = createEmptyFileAndResource(true);
+ try (TsFileIOWriter tsFileIOWriter = new TsFileIOWriter(resource.getTsFile())) {
+ // write the data in device
+ for (int deviceIndex = 0; deviceIndex < deviceNum; deviceIndex++) {
+ tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
+
+ List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
+ List<Integer> measurementIndexes = new ArrayList<>();
+ for (int i = 0; i < measurementNum; i++) {
+ measurementIndexes.add(i);
+ }
+ List<PartialPath> timeseriesPath =
+ createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
+
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
+
+ // write first chunk
+ List<TimeRange> pages = new ArrayList<>();
+ pages.add(new TimeRange(0L, 300L));
+ pages.add(new TimeRange(500L, 600L));
+
+ for (IChunkWriter iChunkWriter : iChunkWriters) {
+ writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
+ }
+
+ // write second chunk
+ List<TimeRange> timeRanges = new ArrayList<>();
+ timeRanges.add(new TimeRange(900L, 1199L));
+ timeRanges.add(new TimeRange(1301L, 1400L));
+ for (IChunkWriter iChunkWriter : iChunkWriters) {
+ writeOneAlignedPage((AlignedChunkWriterImpl) iChunkWriter, timeRanges, true);
+ iChunkWriter.writeToFileWriter(tsFileIOWriter);
+ }
+
+ tsFileIOWriter.endChunkGroup();
+ resource.updateStartTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 0);
+ resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 1400);
+ timeserisPathList.addAll(timeseriesPath);
+ tsDataTypes.addAll(dataTypes);
+
+ generateModsFile(timeseriesPath, resource, 500, 600);
+ }
+ tsFileIOWriter.endFile();
+ }
+ resource.serialize();
+ seqResources.add(resource);
+
+ // seq file 2
+ deviceNum = 5;
+ measurementNum = 20;
+ resource = createEmptyFileAndResource(true);
+ try (TsFileIOWriter tsFileIOWriter = new TsFileIOWriter(resource.getTsFile())) {
+ // write the data in device
+ for (int deviceIndex = 0; deviceIndex < deviceNum; deviceIndex++) {
+ tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
+
+ List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
+ List<Integer> measurementIndexes = new ArrayList<>();
+ for (int i = 0; i < measurementNum; i++) {
+ measurementIndexes.add(i);
+ }
+ List<PartialPath> timeseriesPath =
+ createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
+
+ // write first chunk
+ List<TimeRange> pages = new ArrayList<>();
+ pages.add(new TimeRange(1800L, 1900L));
+ pages.add(new TimeRange(2150L, 2250L));
+ pages.add(new TimeRange(2400L, 2500L));
+
+ for (IChunkWriter iChunkWriter : iChunkWriters) {
+ writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
+ }
+
+ tsFileIOWriter.endChunkGroup();
+ resource.updateStartTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 1800);
+ resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 2500);
+ timeserisPathList.addAll(timeseriesPath);
+ tsDataTypes.addAll(dataTypes);
+
+ generateModsFile(timeseriesPath, resource, 1840, 1900);
+ generateModsFile(timeseriesPath, resource, 2150, 2250);
+ }
+ tsFileIOWriter.endFile();
+ }
+ resource.serialize();
+ seqResources.add(resource);
+
+ // seq file 3
+ deviceNum = 15;
+ measurementNum = 15;
+ resource = createEmptyFileAndResource(true);
+ try (TsFileIOWriter tsFileIOWriter = new TsFileIOWriter(resource.getTsFile())) {
+ // write the data in device
+ for (int deviceIndex = 0; deviceIndex < deviceNum; deviceIndex++) {
+ tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
+
+ List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
+ List<Integer> measurementIndexes = new ArrayList<>();
+ for (int i = 0; i < measurementNum; i++) {
+ measurementIndexes.add(i);
+ }
+ List<PartialPath> timeseriesPath =
+ createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
+
+ // write first chunk
+ List<TimeRange> pages = new ArrayList<>();
+ pages.add(new TimeRange(2801, 2850));
+ pages.add(new TimeRange(2851, 2900));
+ pages.add(new TimeRange(3300, 3400));
+
+ for (IChunkWriter iChunkWriter : iChunkWriters) {
+ writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
+ }
+
+ // write second chunk
+ pages.clear();
+ pages.add(new TimeRange(3950, 4100));
+ pages.add(new TimeRange(4200, 4300));
+ for (IChunkWriter iChunkWriter : iChunkWriters) {
+ writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
+ }
+
+ tsFileIOWriter.endChunkGroup();
+ resource.updateStartTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 2801);
+ resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 4300);
+ timeserisPathList.addAll(timeseriesPath);
+ tsDataTypes.addAll(dataTypes);
+
+ generateModsFile(timeseriesPath, resource, 2801, 2850);
+ generateModsFile(timeseriesPath, resource, 3950, 4100);
+ }
+ tsFileIOWriter.endFile();
+ }
+ resource.serialize();
+ seqResources.add(resource);
+
+ // start compacting
+ tsFileManager.addAll(seqResources, true);
+ tsFileManager.addAll(unseqResources, false);
+
+ Map<PartialPath, List<TimeValuePair>> sourceDatas =
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
+ InnerSpaceCompactionTask task =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ seqResources,
+ true,
+ new ReadChunkCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ task.start();
+
+ validateSeqFiles(true);
+
+ validateTargetDatas(sourceDatas, tsDataTypes);
+ }
+}
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastAlignedCrossCompactionTest.java b/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadPointAlignedCrossCompactionTest.java
similarity index 86%
copy from server/src/test/java/org/apache/iotdb/db/engine/compaction/FastAlignedCrossCompactionTest.java
copy to server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadPointAlignedCrossCompactionTest.java
index 06e7f59697..b1c19f1036 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastAlignedCrossCompactionTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadPointAlignedCrossCompactionTest.java
@@ -22,14 +22,16 @@ import org.apache.iotdb.commons.exception.IllegalPathException;
import org.apache.iotdb.commons.exception.MetadataException;
import org.apache.iotdb.commons.path.PartialPath;
import org.apache.iotdb.db.conf.IoTDBDescriptor;
-import org.apache.iotdb.db.engine.compaction.execute.performer.impl.FastCompactionPerformer;
+import org.apache.iotdb.db.engine.compaction.execute.performer.impl.ReadPointCompactionPerformer;
import org.apache.iotdb.db.engine.compaction.execute.task.CrossSpaceCompactionTask;
import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
import org.apache.iotdb.db.exception.StorageEngineException;
import org.apache.iotdb.db.query.control.FileReaderManager;
import org.apache.iotdb.tsfile.common.conf.TSFileDescriptor;
import org.apache.iotdb.tsfile.exception.write.WriteProcessException;
+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.TimeValuePair;
import org.apache.iotdb.tsfile.read.common.TimeRange;
import org.apache.iotdb.tsfile.write.chunk.AlignedChunkWriterImpl;
@@ -48,14 +50,17 @@ import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createChunkWriter;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createCompressionType;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createDataType;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createEncodingType;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createTimeseries;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.testStorageGroup;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.writeAlignedChunk;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.writeOneAlignedPage;
import static org.apache.iotdb.tsfile.common.constant.TsFileConstant.PATH_SEPARATOR;
-public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
+public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest {
+ private final String oldThreadName = Thread.currentThread().getName();
@Before
public void setUp()
@@ -65,11 +70,13 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
IoTDBDescriptor.getInstance().getConfig().setTargetChunkPointNum(100);
TSFileDescriptor.getInstance().getConfig().setMaxNumberOfPointsInPage(30);
TSFileDescriptor.getInstance().getConfig().setMaxDegreeOfIndexNode(3);
+ Thread.currentThread().setName("pool-1-IoTDB-Compaction-1");
}
@After
public void tearDown() throws IOException, StorageEngineException {
super.tearDown();
+ Thread.currentThread().setName(oldThreadName);
for (TsFileResource tsFileResource : seqResources) {
FileReaderManager.getInstance().closeFileAndRemoveReader(tsFileResource.getTsFilePath());
}
@@ -92,6 +99,9 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
+
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -103,7 +113,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(0L, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, true)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true)) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -127,6 +138,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -137,7 +150,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = new ArrayList<>();
pages.add(new TimeRange(200L, 2200L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, true)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true)) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
tsFileIOWriter.endChunkGroup();
@@ -161,6 +175,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -173,7 +189,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(1550L, 1700L));
pages.add(new TimeRange(1750L, 2000L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, true)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true)) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -197,6 +214,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -209,7 +228,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(1200L, 1300L));
pages.add(new TimeRange(1500L, 1600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, true)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true)) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
tsFileIOWriter.endChunkGroup();
@@ -228,7 +248,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
@@ -236,7 +256,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -262,6 +282,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -273,7 +295,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(100L, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, true)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true)) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -297,6 +320,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -309,7 +334,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(900L, 1189L));
timeRanges.add(new TimeRange(1301L, 1400L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneAlignedPage((AlignedChunkWriterImpl) iChunkWriter, timeRanges, true);
iChunkWriter.writeToFileWriter(tsFileIOWriter);
@@ -346,6 +372,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -358,7 +386,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(0L, 1189L));
timeRanges.add(new TimeRange(1301L, 2000L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneAlignedPage((AlignedChunkWriterImpl) iChunkWriter, timeRanges, false);
iChunkWriter.writeToFileWriter(tsFileIOWriter);
@@ -393,6 +422,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -406,7 +437,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(1200L, 1300L));
timeRanges.add(new TimeRange(1500L, 2200L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk(
(AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
@@ -433,6 +465,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -446,7 +480,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(550L, 700L));
timeRanges.add(new TimeRange(1050L, 1150L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk(
(AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
@@ -468,14 +503,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -500,6 +535,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -511,7 +548,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(100L, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, true)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true)) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -535,6 +573,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -547,7 +587,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(900L, 1249L));
timeRanges.add(new TimeRange(1351L, 1400L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneAlignedPage((AlignedChunkWriterImpl) iChunkWriter, timeRanges, true);
iChunkWriter.writeToFileWriter(tsFileIOWriter);
@@ -584,6 +625,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -596,7 +639,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(0L, 1249L));
timeRanges.add(new TimeRange(1351L, 2000L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneAlignedPage((AlignedChunkWriterImpl) iChunkWriter, timeRanges, false);
iChunkWriter.writeToFileWriter(tsFileIOWriter);
@@ -631,6 +675,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -644,7 +690,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(1250L, 1350L));
timeRanges.add(new TimeRange(1500L, 2200L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk(
(AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
@@ -671,6 +718,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -684,7 +733,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(550L, 700L));
timeRanges.add(new TimeRange(1050L, 1150L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk(
(AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
@@ -706,14 +756,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -738,6 +788,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -745,7 +797,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -786,13 +839,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -825,13 +881,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -877,13 +936,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -917,13 +979,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -961,14 +1026,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -993,6 +1058,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -1000,7 +1067,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1041,13 +1109,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1080,13 +1151,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1125,13 +1199,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1177,13 +1254,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1224,13 +1304,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1264,13 +1347,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1309,14 +1395,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -1341,6 +1427,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -1348,7 +1436,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1389,13 +1478,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1428,13 +1520,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1473,13 +1568,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1525,13 +1623,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1572,13 +1673,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1612,13 +1716,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1665,14 +1772,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -1697,6 +1804,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -1704,7 +1813,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1747,13 +1857,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1794,13 +1907,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1839,13 +1955,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1891,13 +2010,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1938,13 +2060,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1978,13 +2103,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2031,14 +2159,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -2063,6 +2191,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -2070,7 +2200,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2111,13 +2242,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2150,13 +2284,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2197,13 +2334,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2249,13 +2389,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2296,13 +2439,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2336,13 +2482,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2381,14 +2530,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -2413,6 +2562,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -2420,7 +2571,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2461,13 +2613,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2500,13 +2655,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2547,13 +2705,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2599,13 +2760,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2646,13 +2810,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2686,13 +2853,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2732,14 +2902,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -2764,6 +2934,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -2771,7 +2943,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2814,13 +2987,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2861,13 +3037,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -2908,13 +3087,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -2960,13 +3142,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3007,13 +3192,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3047,13 +3235,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3093,7 +3284,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
validateSeqFiles(true);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
@@ -3101,7 +3292,7 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -3126,6 +3317,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -3133,7 +3326,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3174,13 +3368,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3216,13 +3413,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3266,13 +3466,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3324,13 +3527,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3373,13 +3579,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3413,13 +3622,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3468,13 +3680,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3507,14 +3722,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -3539,6 +3754,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -3546,7 +3763,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3589,13 +3807,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3631,13 +3852,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3681,13 +3905,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3740,13 +3967,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3789,13 +4019,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3829,13 +4062,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -3884,13 +4120,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -3923,14 +4162,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -3955,6 +4194,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -3962,7 +4203,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4005,13 +4247,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4047,13 +4292,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4097,13 +4345,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -4156,13 +4407,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4205,13 +4459,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4245,13 +4502,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -4300,13 +4560,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4339,14 +4602,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -4371,6 +4634,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -4378,7 +4643,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4421,13 +4687,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4463,13 +4732,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4513,13 +4785,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -4572,13 +4847,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4621,13 +4899,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4661,13 +4942,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -4716,13 +5000,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4760,13 +5047,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4804,14 +5094,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -4836,6 +5126,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -4843,7 +5135,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4886,13 +5179,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4928,13 +5224,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -4978,13 +5277,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -5034,13 +5336,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -5083,13 +5388,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -5123,13 +5431,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -5178,13 +5489,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -5217,14 +5531,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -5249,6 +5563,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5262,7 +5578,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(100, 199));
pages.add(new TimeRange(200, 300));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5295,6 +5612,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5305,7 +5624,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(900, 1400, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5343,6 +5663,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5353,7 +5675,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(200, 2200, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5379,6 +5702,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5389,7 +5714,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(550, 800, 70);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5423,14 +5749,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -5455,6 +5781,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5465,7 +5793,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(100, 300, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5497,6 +5826,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5508,7 +5839,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = createPages(900, 1199, 100);
pages.addAll(createPages(1301, 1400, 100));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5552,6 +5884,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5563,7 +5897,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = createPages(0, 1199, 50);
pages.addAll(createPages(1301, 2000, 100));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5595,6 +5930,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5605,7 +5942,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(550, 800, 70);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5644,6 +5982,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5654,7 +5994,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(350, 400, 70);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5688,14 +6029,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -5720,6 +6061,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5730,7 +6073,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(0, 300, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5762,6 +6106,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5773,7 +6119,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = createPages(900, 1199, 100);
pages.addAll(createPages(1301, 1400, 100));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5798,6 +6145,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5808,7 +6157,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(1800, 1900, 30);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5846,6 +6196,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5857,7 +6209,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = createPages(100, 1199, 50);
pages.addAll(createPages(1301, 1650, 100));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5889,6 +6242,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5899,7 +6254,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(2200, 2400, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5932,6 +6288,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5942,7 +6300,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(550, 800, 70);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -5986,6 +6345,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -5996,7 +6357,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(350, 400, 25);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6034,6 +6396,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6044,7 +6408,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(2700, 2800, 25);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6071,14 +6436,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -6103,6 +6468,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6110,7 +6477,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6151,13 +6519,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6190,13 +6561,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6237,13 +6611,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -6289,13 +6666,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6336,13 +6716,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -6376,13 +6759,16 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, true);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -6422,14 +6808,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -6454,6 +6840,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6464,7 +6852,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(300, 600, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -6502,6 +6891,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6512,7 +6903,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(1600, 1900, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -6544,6 +6936,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6554,7 +6948,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(0, 2000, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6580,6 +6975,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6590,7 +6987,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(100, 400, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6623,6 +7021,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6633,7 +7033,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(450, 950, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6661,14 +7062,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -6693,6 +7094,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6708,7 +7111,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(900, 1100));
pages.add(new TimeRange(1400, 1600));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -6734,6 +7138,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6744,7 +7150,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
// first page
timeRanges.clear();
@@ -6795,14 +7202,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -6827,6 +7234,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6837,7 +7246,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(0, 1000, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
@@ -6875,6 +7285,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6885,7 +7297,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(50, 250, 100);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6932,6 +7345,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(testStorageGroup + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -6942,7 +7357,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
// write first chunk
List<TimeRange> pages = createPages(700, 800, 50);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
@@ -6977,14 +7393,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -7010,6 +7426,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -7021,7 +7439,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(0, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, true)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true)) {
writeAlignedChunk((AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -7045,6 +7464,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -7058,7 +7479,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(1350, 1700));
timeRanges.add(new TimeRange(1750, 2000));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk(
(AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, true);
@@ -7093,6 +7515,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -7104,7 +7528,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> timeRanges = new ArrayList<>();
timeRanges.add(new TimeRange(500, 950));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk(
(AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
@@ -7149,6 +7574,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -7161,7 +7588,8 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(500, 800));
timeRanges.add(new TimeRange(850, 950));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, true);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, true);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeAlignedChunk(
(AlignedChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
@@ -7193,14 +7621,14 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, true), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastNonAlignedCrossCompactionTest.java b/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadPointNonAlignedCrossCompactionTest.java
similarity index 85%
copy from server/src/test/java/org/apache/iotdb/db/engine/compaction/FastNonAlignedCrossCompactionTest.java
copy to server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadPointNonAlignedCrossCompactionTest.java
index a91cab2062..1727745e62 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastNonAlignedCrossCompactionTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadPointNonAlignedCrossCompactionTest.java
@@ -23,14 +23,16 @@ import org.apache.iotdb.commons.exception.MetadataException;
import org.apache.iotdb.commons.path.MeasurementPath;
import org.apache.iotdb.commons.path.PartialPath;
import org.apache.iotdb.db.conf.IoTDBDescriptor;
-import org.apache.iotdb.db.engine.compaction.execute.performer.impl.FastCompactionPerformer;
+import org.apache.iotdb.db.engine.compaction.execute.performer.impl.ReadPointCompactionPerformer;
import org.apache.iotdb.db.engine.compaction.execute.task.CrossSpaceCompactionTask;
import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
import org.apache.iotdb.db.exception.StorageEngineException;
import org.apache.iotdb.db.query.control.FileReaderManager;
import org.apache.iotdb.tsfile.common.conf.TSFileDescriptor;
import org.apache.iotdb.tsfile.exception.write.WriteProcessException;
+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.TimeValuePair;
import org.apache.iotdb.tsfile.read.common.TimeRange;
import org.apache.iotdb.tsfile.write.chunk.ChunkWriterImpl;
@@ -49,14 +51,17 @@ import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createChunkWriter;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createCompressionType;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createDataType;
+import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createEncodingType;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.createTimeseries;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.testStorageGroup;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.writeNonAlignedChunk;
import static org.apache.iotdb.db.engine.compaction.utils.TsFileGeneratorUtils.writeOneNonAlignedPage;
import static org.apache.iotdb.tsfile.common.constant.TsFileConstant.PATH_SEPARATOR;
-public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
+public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTest {
+ private final String oldThreadName = Thread.currentThread().getName();
@Before
public void setUp()
@@ -66,11 +71,13 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
IoTDBDescriptor.getInstance().getConfig().setTargetChunkPointNum(100);
TSFileDescriptor.getInstance().getConfig().setMaxNumberOfPointsInPage(30);
TSFileDescriptor.getInstance().getConfig().setMaxDegreeOfIndexNode(3);
+ Thread.currentThread().setName("pool-1-IoTDB-Compaction-1");
}
@After
public void tearDown() throws IOException, StorageEngineException {
super.tearDown();
+ Thread.currentThread().setName(oldThreadName);
for (TsFileResource tsFileResource : seqResources) {
FileReaderManager.getInstance().closeFileAndRemoveReader(tsFileResource.getTsFilePath());
}
@@ -91,6 +98,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(10);
+ List<TSEncoding> encodings = createEncodingType(10);
+ List<CompressionType> compressionTypes = createCompressionType(10);
List<PartialPath> timeseriesPath = new ArrayList<>();
for (int i = 0; i < 10; i++) {
timeseriesPath.add(
@@ -109,12 +118,13 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(0L, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, false)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
resource.updateStartTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 0);
- resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 599);
+ resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 600);
timeserisPathList.addAll(timeseriesPath);
tsDataTypes.addAll(dataTypes);
}
@@ -124,13 +134,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
seqResources.add(resource);
// unseq file 1
+ int measurementNum = 5;
resource = createEmptyFileAndResource(false);
try (TsFileIOWriter tsFileIOWriter = new TsFileIOWriter(resource.getTsFile())) {
// write the data in device
for (int deviceIndex = 0; deviceIndex < 15; deviceIndex++) {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
- List<TSDataType> dataTypes = createDataType(5);
+ List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<PartialPath> timeseriesPath = new ArrayList<>();
for (int i = 0; i < 5; i++) {
timeseriesPath.add(
@@ -148,12 +161,13 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<TimeRange> pages = new ArrayList<>();
pages.add(new TimeRange(200L, 2200L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, false)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
tsFileIOWriter.endChunkGroup();
resource.updateStartTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 200);
- resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 2199);
+ resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 2200);
timeserisPathList.addAll(timeseriesPath);
tsDataTypes.addAll(dataTypes);
}
@@ -163,13 +177,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
unseqResources.add(resource);
// seq file 2
+ measurementNum = 5;
resource = createEmptyFileAndResource(true);
try (TsFileIOWriter tsFileIOWriter = new TsFileIOWriter(resource.getTsFile())) {
// write the data in device
for (int deviceIndex = 0; deviceIndex < 12; deviceIndex++) {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
- List<TSDataType> dataTypes = createDataType(5);
+ List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<PartialPath> timeseriesPath = new ArrayList<>();
for (int i = 0; i < 5; i++) {
timeseriesPath.add(
@@ -189,12 +206,13 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(1550L, 1700L));
pages.add(new TimeRange(1750L, 2000L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, false)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
resource.updateStartTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 900);
- resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 1999);
+ resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 2000);
timeserisPathList.addAll(timeseriesPath);
tsDataTypes.addAll(dataTypes);
}
@@ -204,13 +222,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
seqResources.add(resource);
// unseq file 2
+ measurementNum = 5;
resource = createEmptyFileAndResource(false);
try (TsFileIOWriter tsFileIOWriter = new TsFileIOWriter(resource.getTsFile())) {
// write the data in device
for (int deviceIndex = 0; deviceIndex < 15; deviceIndex++) {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
- List<TSDataType> dataTypes = createDataType(5);
+ List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<PartialPath> timeseriesPath = new ArrayList<>();
for (int i = 0; i < 5; i++) {
timeseriesPath.add(
@@ -230,12 +251,13 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(1200L, 1300L));
pages.add(new TimeRange(1500L, 1600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, false)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, false);
}
tsFileIOWriter.endChunkGroup();
resource.updateStartTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 550);
- resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 1599);
+ resource.updateEndTime(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex, 1600);
timeserisPathList.addAll(timeseriesPath);
tsDataTypes.addAll(dataTypes);
}
@@ -249,14 +271,14 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -282,6 +304,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -293,7 +317,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(100L, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, false)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -317,6 +342,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -329,7 +356,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(900L, 1189L));
timeRanges.add(new TimeRange(1301L, 1400L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneNonAlignedPage((ChunkWriterImpl) iChunkWriter, timeRanges, true);
((ChunkWriterImpl) iChunkWriter).writeToFileWriter(tsFileIOWriter);
@@ -365,6 +393,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -377,7 +407,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(0L, 1189L));
timeRanges.add(new TimeRange(1301L, 2000L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneNonAlignedPage((ChunkWriterImpl) iChunkWriter, timeRanges, false);
((ChunkWriterImpl) iChunkWriter).writeToFileWriter(tsFileIOWriter);
@@ -411,6 +442,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -424,7 +457,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(1200L, 1300L));
timeRanges.add(new TimeRange(1500L, 2200L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
}
@@ -450,6 +484,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -463,7 +499,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(550L, 700L));
timeRanges.add(new TimeRange(1050L, 1150L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
}
@@ -484,14 +521,14 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -516,6 +553,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -527,7 +566,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
pages.add(new TimeRange(100L, 300L));
pages.add(new TimeRange(500L, 600L));
- for (IChunkWriter iChunkWriter : createChunkWriter(timeseriesPath, dataTypes, false)) {
+ for (IChunkWriter iChunkWriter :
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false)) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, pages, true);
}
tsFileIOWriter.endChunkGroup();
@@ -551,6 +591,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -563,7 +605,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(900L, 1249L));
timeRanges.add(new TimeRange(1351L, 1400L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneNonAlignedPage((ChunkWriterImpl) iChunkWriter, timeRanges, true);
((ChunkWriterImpl) iChunkWriter).writeToFileWriter(tsFileIOWriter);
@@ -599,6 +642,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -611,7 +656,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(0L, 1249L));
timeRanges.add(new TimeRange(1351L, 2000L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeOneNonAlignedPage((ChunkWriterImpl) iChunkWriter, timeRanges, false);
((ChunkWriterImpl) iChunkWriter).writeToFileWriter(tsFileIOWriter);
@@ -645,6 +691,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -658,7 +706,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(1250L, 1350L));
timeRanges.add(new TimeRange(1500L, 2200L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
}
@@ -684,6 +733,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -697,7 +748,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
timeRanges.add(new TimeRange(550L, 700L));
timeRanges.add(new TimeRange(1050L, 1150L));
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
for (IChunkWriter iChunkWriter : iChunkWriters) {
writeNonAlignedChunk((ChunkWriterImpl) iChunkWriter, tsFileIOWriter, timeRanges, false);
}
@@ -718,14 +770,14 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -750,6 +802,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -757,7 +811,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -798,13 +853,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -837,13 +895,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -888,13 +949,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -928,13 +992,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -970,14 +1037,14 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -1002,6 +1069,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -1009,7 +1078,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1050,13 +1120,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1089,13 +1162,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1134,13 +1210,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1185,13 +1264,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1232,13 +1314,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1272,13 +1357,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> timeRanges = new ArrayList<>();
@@ -1315,14 +1403,14 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileManager.addAll(unseqResources, false);
Map<PartialPath, List<TimeValuePair>> sourceDatas =
- readSourceFiles(timeserisPathList, tsDataTypes);
+ readSourceFiles(createTimeseries(maxDeviceNum, maxMeasurementNum, false), tsDataTypes);
CrossSpaceCompactionTask task =
new CrossSpaceCompactionTask(
0,
tsFileManager,
seqResources,
unseqResources,
- new FastCompactionPerformer(true),
+ new ReadPointCompactionPerformer(),
new AtomicInteger(0),
0,
0);
@@ -1347,6 +1435,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
@@ -1354,7 +1444,8 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1395,13 +1486,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
List<Integer> measurementIndexes = new ArrayList<>();
for (int i = 0; i < measurementNum; i++) {
measurementIndexes.add(i);
}
List<PartialPath> timeseriesPath =
createTimeseries(deviceIndex, measurementIndexes, dataTypes, false);
- List<IChunkWriter> iChunkWriters = createChunkWriter(timeseriesPath, dataTypes, false);
+ List<IChunkWriter> iChunkWriters =
+ createChunkWriter(timeseriesPath, dataTypes, encodings, compressionTypes, false);
// write first chunk
List<TimeRange> pages = new ArrayList<>();
@@ -1434,13 +1528,16 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
tsFileIOWriter.startChunkGroup(COMPACTION_TEST_SG + PATH_SEPARATOR + "d" + deviceIndex);
List<TSDataType> dataTypes = createDataType(measurementNum);
+ List<TSEncoding> encodings = createEncodingType(measurementNum);
+ List<CompressionType> compressionTypes = createCompressionType(measurementNum);
... 2919 lines suppressed ...