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/28 01:34:32 UTC
[iotdb] branch master updated: [IOTDB-5825]Fix error in aligned empty value chunk in fast compaction (#9719)
This is an automated email from the ASF dual-hosted git repository.
marklau99 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/master by this push:
new 8db6527e80 [IOTDB-5825]Fix error in aligned empty value chunk in fast compaction (#9719)
8db6527e80 is described below
commit 8db6527e80c0362f3918e9e4d30bc4790c7ca2be
Author: 周沛辰 <45...@users.noreply.github.com>
AuthorDate: Fri Apr 28 09:34:25 2023 +0800
[IOTDB-5825]Fix error in aligned empty value chunk in fast compaction (#9719)
---
.../performer/impl/FastCompactionPerformer.java | 3 +-
.../execute/task/AbstractCompactionTask.java | 8 +-
.../execute/task/CrossSpaceCompactionTask.java | 11 +-
.../execute/task/InnerSpaceCompactionTask.java | 7 +-
.../fast/AlignedSeriesCompactionExecutor.java | 16 +-
.../utils/writer/AbstractCompactionWriter.java | 3 +-
.../engine/compaction/AbstractCompactionTest.java | 3 +
.../compaction/CompactionTaskComparatorTest.java | 8 +-
.../compaction/FastAlignedCrossCompactionTest.java | 347 +++++++++++++++++++--
.../FastInnerCompactionPerformerTest.java | 30 +-
.../FastNonAlignedCrossCompactionTest.java | 347 +++++++++++++++++++--
.../ReadPointAlignedCrossCompactionTest.java | 347 +++++++++++++++++++--
.../ReadPointNonAlignedCrossCompactionTest.java | 347 +++++++++++++++++++--
.../CrossSpaceCompactionWithFastPerformerTest.java | 7 +-
...eCompactionWithFastPerformerValidationTest.java | 194 ++++++------
...actionWithReadPointPerformerValidationTest.java | 168 +++++-----
.../utils/MultiTsFileDeviceIteratorTest.java | 12 +-
.../iotdb/tsfile/write/chunk/ValueChunkWriter.java | 4 -
18 files changed, 1551 insertions(+), 311 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 ffc8330729..d029122f0d 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
@@ -168,7 +168,8 @@ public class FastCompactionPerformer
MultiTsFileDeviceIterator deviceIterator,
AbstractCompactionWriter fastCrossCompactionWriter)
throws PageException, IOException, WriteProcessException, IllegalPathException {
- // measurement -> tsfile resource -> timeseries metadata <startOffset, endOffset>
+ // measurement -> tsfile resource -> timeseries metadata <startOffset, endOffset>, including
+ // empty value chunk metadata
Map<String, Map<TsFileResource, Pair<Long, Long>>> timeseriesMetadataOffsetMap =
new LinkedHashMap<>();
List<IMeasurementSchema> measurementSchemas = new ArrayList<>();
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/task/AbstractCompactionTask.java b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/task/AbstractCompactionTask.java
index 482194705d..19e4a0efaa 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/task/AbstractCompactionTask.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/task/AbstractCompactionTask.java
@@ -69,22 +69,22 @@ public abstract class AbstractCompactionTask {
public abstract void setSourceFilesToCompactionCandidate();
- protected abstract void doCompaction();
+ protected abstract boolean doCompaction();
- public void start() {
+ public boolean start() {
currentTaskNum.incrementAndGet();
boolean isSuccess = false;
CompactionMetricsManager.getInstance().reportTaskStartRunning(crossTask, innerSeqTask);
try {
summary.start();
- doCompaction();
- isSuccess = true;
+ isSuccess = doCompaction();
} finally {
this.currentTaskNum.decrementAndGet();
summary.finish(isSuccess);
CompactionTaskManager.getInstance().removeRunningTaskFuture(this);
CompactionMetricsManager.getInstance()
.reportTaskFinishOrAbort(crossTask, innerSeqTask, summary.getTimeCost());
+ return isSuccess;
}
}
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/task/CrossSpaceCompactionTask.java b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/task/CrossSpaceCompactionTask.java
index e29c083c70..69f2de7f8c 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/task/CrossSpaceCompactionTask.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/task/CrossSpaceCompactionTask.java
@@ -96,16 +96,17 @@ public class CrossSpaceCompactionTask extends AbstractCompactionTask {
}
@Override
- public void doCompaction() {
+ public boolean doCompaction() {
try {
SystemInfo.getInstance().addCompactionMemoryCost(memoryCost);
} catch (InterruptedException e) {
LOGGER.error("Interrupted when allocating memory for compaction", e);
- return;
+ return false;
}
+ boolean isSuccess = true;
try {
if (!tsFileManager.isAllowCompaction()) {
- return;
+ return true;
}
long startTime = System.currentTimeMillis();
targetTsfileResourceList =
@@ -118,7 +119,7 @@ public class CrossSpaceCompactionTask extends AbstractCompactionTask {
"{}-{} [Compaction] Cross space compaction file list is empty, end it",
storageGroupName,
dataRegionId);
- return;
+ return true;
}
for (TsFileResource resource : selectedSequenceFiles) {
@@ -246,6 +247,7 @@ public class CrossSpaceCompactionTask extends AbstractCompactionTask {
FileUtils.delete(logFile);
}
} catch (Throwable throwable) {
+ isSuccess = false;
// catch throwable to handle OOM errors
if (!(throwable instanceof InterruptedException)) {
LOGGER.error(
@@ -273,6 +275,7 @@ public class CrossSpaceCompactionTask extends AbstractCompactionTask {
} finally {
SystemInfo.getInstance().resetCompactionMemoryCost(memoryCost);
releaseAllLock();
+ return isSuccess;
}
}
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/task/InnerSpaceCompactionTask.java b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/task/InnerSpaceCompactionTask.java
index 4c871843fa..d5a99e57a6 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/task/InnerSpaceCompactionTask.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/task/InnerSpaceCompactionTask.java
@@ -103,9 +103,9 @@ public class InnerSpaceCompactionTask extends AbstractCompactionTask {
}
@Override
- protected void doCompaction() {
+ protected boolean doCompaction() {
if (!tsFileManager.isAllowCompaction()) {
- return;
+ return true;
}
long startTime = System.currentTimeMillis();
// get resource of target file
@@ -117,6 +117,7 @@ public class InnerSpaceCompactionTask extends AbstractCompactionTask {
sequence ? "Sequence" : "Unsequence",
selectedTsFileResourceList.size(),
selectedFileSize / 1024 / 1024);
+ boolean isSuccess = true;
try {
targetTsFileResource =
@@ -264,6 +265,7 @@ public class InnerSpaceCompactionTask extends AbstractCompactionTask {
FileUtils.delete(logFile);
}
} catch (Throwable throwable) {
+ isSuccess = false;
// catch throwable to handle OOM errors
if (!(throwable instanceof InterruptedException)) {
LOGGER.error(
@@ -303,6 +305,7 @@ public class InnerSpaceCompactionTask extends AbstractCompactionTask {
}
} finally {
releaseFileLocksAndResetMergingStatus();
+ return isSuccess;
}
}
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 2f939a1f37..cd7adbb1ad 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
@@ -250,9 +250,15 @@ public class AlignedSeriesCompactionExecutor extends SeriesCompactionExecutor {
} else {
pageHeader = PageHeader.deserializeFrom(chunkDataBuffer, chunkHeader.getDataType());
}
- ByteBuffer compressedPageData = chunkReader.readPageDataWithoutUncompressing(pageHeader);
- valuePageHeaders.get(i).add(pageHeader);
- compressedValuePageDatas.get(i).add(compressedPageData);
+ if (pageHeader.getCompressedSize() == 0) {
+ // empty value page
+ valuePageHeaders.get(i).add(null);
+ compressedValuePageDatas.get(i).add(null);
+ } else {
+ ByteBuffer compressedPageData = chunkReader.readPageDataWithoutUncompressing(pageHeader);
+ valuePageHeaders.get(i).add(pageHeader);
+ compressedValuePageDatas.get(i).add(compressedPageData);
+ }
}
}
@@ -294,8 +300,8 @@ public class AlignedSeriesCompactionExecutor extends SeriesCompactionExecutor {
.readMemChunk((ChunkMetadata) alignedChunkMetadata.getTimeChunkMetadata());
List<Chunk> valueChunks = new ArrayList<>();
for (IChunkMetadata valueChunkMetadata : alignedChunkMetadata.getValueChunkMetadataList()) {
- if (valueChunkMetadata == null) {
- // value chunk has been deleted completely
+ if (valueChunkMetadata == null || valueChunkMetadata.getStatistics().getCount() == 0) {
+ // value chunk has been deleted completely or is empty value chunk
valueChunks.add(null);
continue;
}
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 471cb8a3a9..32903cc008 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
@@ -28,6 +28,7 @@ import org.apache.iotdb.tsfile.exception.write.PageException;
import org.apache.iotdb.tsfile.file.header.PageHeader;
import org.apache.iotdb.tsfile.file.metadata.ChunkMetadata;
import org.apache.iotdb.tsfile.file.metadata.IChunkMetadata;
+import org.apache.iotdb.tsfile.file.metadata.statistics.Statistics;
import org.apache.iotdb.tsfile.read.TimeValuePair;
import org.apache.iotdb.tsfile.read.common.Chunk;
import org.apache.iotdb.tsfile.read.common.block.column.Column;
@@ -227,7 +228,7 @@ public abstract class AbstractCompactionWriter implements AutoCloseable {
valueChunkWriter.getCompressionType(),
valueChunkWriter.getDataType(),
valueChunkWriter.getEncodingType(),
- valueChunkWriter.getStatistics());
+ Statistics.getStatsByType(valueChunkWriter.getDataType()));
continue;
}
CompactionTaskManager.mergeRateLimiterAcquire(
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 51952b43cd..9d205ad2de 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
@@ -472,6 +472,7 @@ public class AbstractCompactionTest {
protected void validateTargetDatas(
Map<PartialPath, List<TimeValuePair>> sourceDatas, List<TSDataType> dataTypes)
throws IOException {
+ Map<PartialPath, List<TimeValuePair>> tmpSourceDatas = new HashMap<>();
for (Map.Entry<PartialPath, List<TimeValuePair>> entry : sourceDatas.entrySet()) {
IDataBlockReader tsBlockReader =
new SeriesDataBlockReader(
@@ -482,6 +483,7 @@ public class AbstractCompactionTest {
Collections.emptyList(),
true);
List<TimeValuePair> timeseriesData = entry.getValue();
+ tmpSourceDatas.put(entry.getKey(), new ArrayList<>(timeseriesData));
while (tsBlockReader.hasNextBatch()) {
TsBlock block = tsBlockReader.nextBatch();
IBatchDataIterator iterator = block.getTsBlockAlignedRowIterator();
@@ -498,6 +500,7 @@ public class AbstractCompactionTest {
fail();
}
}
+ sourceDatas.putAll(tmpSourceDatas);
}
protected void generateModsFile(
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/compaction/CompactionTaskComparatorTest.java b/server/src/test/java/org/apache/iotdb/db/engine/compaction/CompactionTaskComparatorTest.java
index 07d962bce8..b503ee8e92 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/compaction/CompactionTaskComparatorTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/compaction/CompactionTaskComparatorTest.java
@@ -336,7 +336,9 @@ public class CompactionTaskComparatorTest {
}
@Override
- protected void doCompaction() {}
+ protected boolean doCompaction() {
+ return true;
+ }
@Override
public boolean equalsOtherTask(AbstractCompactionTask other) {
@@ -371,7 +373,9 @@ public class CompactionTaskComparatorTest {
}
@Override
- public void doCompaction() {}
+ public boolean doCompaction() {
+ return true;
+ }
@Override
public boolean equalsOtherTask(AbstractCompactionTask other) {
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 415a63487b..addf2b37e0 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
@@ -24,6 +24,7 @@ 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.task.CrossSpaceCompactionTask;
+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;
@@ -39,6 +40,7 @@ import org.apache.iotdb.tsfile.write.chunk.IChunkWriter;
import org.apache.iotdb.tsfile.write.writer.TsFileIOWriter;
import org.junit.After;
+import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -257,11 +259,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -511,11 +526,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -764,11 +792,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -1034,11 +1075,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -1403,11 +1457,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -1780,11 +1847,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -2167,11 +2247,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -2538,11 +2631,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -2910,11 +3016,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -3293,11 +3412,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -3730,11 +3862,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -4170,11 +4315,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -4610,11 +4768,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -5102,11 +5273,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -5539,11 +5723,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -5757,11 +5954,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -6037,11 +6247,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -6444,11 +6667,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -6816,11 +7052,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7070,11 +7319,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7210,11 +7472,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7401,11 +7676,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7629,11 +7917,24 @@ public class FastAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
private List<TimeRange> createPages(long startTime, long endTime, int pagePointNum) {
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastInnerCompactionPerformerTest.java b/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastInnerCompactionPerformerTest.java
index fbc2f27027..6a60556ebf 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastInnerCompactionPerformerTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/compaction/FastInnerCompactionPerformerTest.java
@@ -128,7 +128,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
@@ -226,7 +226,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
List<TsFileResource> targetResources = tsFileManager.getTsFileList(true);
@@ -367,7 +367,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
List<TsFileResource> targetResources = tsFileManager.getTsFileList(true);
@@ -481,7 +481,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
List<TsFileResource> targetResources = tsFileManager.getTsFileList(false);
@@ -596,7 +596,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
validateSeqFiles(true);
@@ -742,7 +742,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
validateSeqFiles(false);
@@ -877,7 +877,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
validateSeqFiles(false);
@@ -998,7 +998,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
validateSeqFiles(true);
@@ -1089,7 +1089,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
List<TsFileResource> targetResources = tsFileManager.getTsFileList(true);
@@ -1209,7 +1209,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
validateSeqFiles(true);
@@ -1338,7 +1338,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
validateSeqFiles(true);
@@ -1472,7 +1472,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
validateSeqFiles(false);
@@ -1656,7 +1656,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
validateSeqFiles(false);
@@ -1820,7 +1820,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
validateSeqFiles(false);
@@ -1936,7 +1936,7 @@ public class FastInnerCompactionPerformerTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(0),
0);
- task.start();
+ Assert.assertTrue(task.start());
Assert.assertEquals(0, FileReaderManager.getInstance().getClosedFileReaderMap().size());
Assert.assertEquals(0, FileReaderManager.getInstance().getUnclosedFileReaderMap().size());
validateSeqFiles(false);
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 b50a69e339..db75e9321a 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
@@ -25,6 +25,7 @@ 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.task.CrossSpaceCompactionTask;
+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;
@@ -40,6 +41,7 @@ import org.apache.iotdb.tsfile.write.chunk.IChunkWriter;
import org.apache.iotdb.tsfile.write.writer.TsFileIOWriter;
import org.junit.After;
+import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -279,11 +281,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -529,11 +544,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -778,11 +806,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -1045,11 +1086,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -1411,11 +1465,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -1784,11 +1851,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -2167,11 +2247,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -2535,11 +2628,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -2904,11 +3010,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -3283,11 +3402,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -3717,11 +3849,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -4154,11 +4299,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -4591,11 +4749,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -5080,11 +5251,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -5514,11 +5698,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -5732,11 +5929,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -6012,11 +6222,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -6419,11 +6642,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -6788,11 +7024,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7042,11 +7291,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7182,11 +7444,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7373,11 +7648,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7594,11 +7882,24 @@ public class FastNonAlignedCrossCompactionTest extends AbstractCompactionTest {
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
/**
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadPointAlignedCrossCompactionTest.java b/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadPointAlignedCrossCompactionTest.java
index b1c19f1036..f4ae879570 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadPointAlignedCrossCompactionTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadPointAlignedCrossCompactionTest.java
@@ -24,6 +24,7 @@ import org.apache.iotdb.commons.path.PartialPath;
import org.apache.iotdb.db.conf.IoTDBDescriptor;
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.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;
@@ -39,6 +40,7 @@ import org.apache.iotdb.tsfile.write.chunk.IChunkWriter;
import org.apache.iotdb.tsfile.write.writer.TsFileIOWriter;
import org.junit.After;
+import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -260,11 +262,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -514,11 +529,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -767,11 +795,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -1037,11 +1078,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -1406,11 +1460,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -1783,11 +1850,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -2170,11 +2250,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -2541,11 +2634,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -2913,11 +3019,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -3296,11 +3415,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -3733,11 +3865,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -4173,11 +4318,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -4613,11 +4771,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -5105,11 +5276,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -5542,11 +5726,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -5760,11 +5957,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -6040,11 +6250,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -6447,11 +6670,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -6819,11 +7055,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7073,11 +7322,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7213,11 +7475,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7404,11 +7679,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7632,11 +7920,24 @@ public class ReadPointAlignedCrossCompactionTest extends AbstractCompactionTest
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
private List<TimeRange> createPages(long startTime, long endTime, int pagePointNum) {
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadPointNonAlignedCrossCompactionTest.java b/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadPointNonAlignedCrossCompactionTest.java
index 1727745e62..184e7bacc8 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadPointNonAlignedCrossCompactionTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/compaction/ReadPointNonAlignedCrossCompactionTest.java
@@ -25,6 +25,7 @@ import org.apache.iotdb.commons.path.PartialPath;
import org.apache.iotdb.db.conf.IoTDBDescriptor;
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.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;
@@ -40,6 +41,7 @@ import org.apache.iotdb.tsfile.write.chunk.IChunkWriter;
import org.apache.iotdb.tsfile.write.writer.TsFileIOWriter;
import org.junit.After;
+import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -282,11 +284,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -532,11 +547,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -781,11 +809,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -1048,11 +1089,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -1414,11 +1468,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -1787,11 +1854,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -2170,11 +2250,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -2538,11 +2631,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -2907,11 +3013,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -3286,11 +3405,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -3720,11 +3852,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -4157,11 +4302,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -4594,11 +4752,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -5083,11 +5254,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -5517,11 +5701,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -5735,11 +5932,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -6015,11 +6225,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -6422,11 +6645,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -6791,11 +7027,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7045,11 +7294,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7185,11 +7447,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7376,11 +7651,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
@Test
@@ -7597,11 +7885,24 @@ public class ReadPointNonAlignedCrossCompactionTest extends AbstractCompactionTe
new AtomicInteger(0),
0,
0);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceDatas, tsDataTypes);
+
+ InnerSpaceCompactionTask innerTask =
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ tsFileManager.getTsFileList(true),
+ true,
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ 0);
+ Assert.assertTrue(innerTask.start());
+ validateSeqFiles(true);
+ validateTargetDatas(sourceDatas, tsDataTypes);
}
/**
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/CrossSpaceCompactionWithFastPerformerTest.java b/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/CrossSpaceCompactionWithFastPerformerTest.java
index cb9cf75f58..2a9d89cb47 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/CrossSpaceCompactionWithFastPerformerTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/CrossSpaceCompactionWithFastPerformerTest.java
@@ -47,6 +47,7 @@ import org.apache.iotdb.tsfile.read.TimeValuePair;
import org.apache.iotdb.tsfile.utils.Pair;
import org.junit.After;
+import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -429,7 +430,7 @@ public class CrossSpaceCompactionWithFastPerformerTest {
new AtomicInteger(0),
0,
0);
- compactionTask.start();
+ Assert.assertTrue(compactionTask.start());
List<TsFileResource> targetTsfileResourceList = new ArrayList<>();
for (TsFileResource seqResource : seqResources) {
TsFileResource targetResource =
@@ -733,7 +734,7 @@ public class CrossSpaceCompactionWithFastPerformerTest {
new AtomicInteger(0),
0,
0);
- compactionTask.start();
+ Assert.assertTrue(compactionTask.start());
List<TsFileResource> targetTsfileResourceList = new ArrayList<>();
for (TsFileResource seqResource : seqResources.subList(1, 4)) {
TsFileResource targetResource =
@@ -1036,7 +1037,7 @@ public class CrossSpaceCompactionWithFastPerformerTest {
new AtomicInteger(0),
0,
0);
- compactionTask.start();
+ Assert.assertTrue(compactionTask.start());
List<TsFileResource> targetTsfileResourceList = new ArrayList<>();
for (TsFileResource seqResource : seqResources.subList(1, 4)) {
TsFileResource targetResource =
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/CrossSpaceCompactionWithFastPerformerValidationTest.java b/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/CrossSpaceCompactionWithFastPerformerValidationTest.java
index 817fbf11f7..6b3be949db 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/CrossSpaceCompactionWithFastPerformerValidationTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/CrossSpaceCompactionWithFastPerformerValidationTest.java
@@ -2343,15 +2343,16 @@ public class CrossSpaceCompactionWithFastPerformerValidationTest extends Abstrac
new SizeTieredCompactionSelector(COMPACTION_TEST_SG, "0", 0, true, tsFileManager)
.selectInnerSpaceTask(tsFileManager.getOrCreateSequenceListByTimePartition(0));
for (List<TsFileResource> taskResource : taskResources) {
- new InnerSpaceCompactionTask(
- 0,
- tsFileManager,
- taskResource,
- true,
- new FastCompactionPerformer(false),
- new AtomicInteger(0),
- 0L)
- .start();
+ Assert.assertTrue(
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ taskResource,
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0L)
+ .start());
}
// select cross compaction
@@ -2369,16 +2370,17 @@ public class CrossSpaceCompactionWithFastPerformerValidationTest extends Abstrac
Assert.assertEquals(1, sourceFiles.getSeqFiles().size());
Assert.assertEquals(2, sourceFiles.getUnseqFiles().size());
- new CrossSpaceCompactionTask(
- 0,
- tsFileManager,
- sourceFiles.getSeqFiles(),
- sourceFiles.getUnseqFiles(),
- new FastCompactionPerformer(true),
- new AtomicInteger(0),
- sourceFiles.getTotalMemoryCost(),
- 0)
- .start();
+ Assert.assertTrue(
+ new CrossSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ sourceFiles.getSeqFiles(),
+ sourceFiles.getUnseqFiles(),
+ new FastCompactionPerformer(true),
+ new AtomicInteger(0),
+ sourceFiles.getTotalMemoryCost(),
+ 0)
+ .start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
@@ -2423,15 +2425,16 @@ public class CrossSpaceCompactionWithFastPerformerValidationTest extends Abstrac
new SizeTieredCompactionSelector(COMPACTION_TEST_SG, "0", 0, true, tsFileManager)
.selectInnerSpaceTask(tsFileManager.getOrCreateSequenceListByTimePartition(0));
for (List<TsFileResource> taskResource : taskResources) {
- new InnerSpaceCompactionTask(
- 0,
- tsFileManager,
- taskResource,
- true,
- new FastCompactionPerformer(false),
- new AtomicInteger(0),
- 0L)
- .start();
+ Assert.assertTrue(
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ taskResource,
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0L)
+ .start());
}
// select cross compaction
@@ -2504,15 +2507,16 @@ public class CrossSpaceCompactionWithFastPerformerValidationTest extends Abstrac
new SizeTieredCompactionSelector(COMPACTION_TEST_SG, "0", 0, true, tsFileManager)
.selectInnerSpaceTask(tsFileManager.getOrCreateSequenceListByTimePartition(0));
for (List<TsFileResource> taskResource : taskResources) {
- new InnerSpaceCompactionTask(
- 0,
- tsFileManager,
- taskResource,
- true,
- new FastCompactionPerformer(false),
- new AtomicInteger(0),
- 0L)
- .start();
+ Assert.assertTrue(
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ taskResource,
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0L)
+ .start());
}
// select cross compaction
@@ -2586,15 +2590,16 @@ public class CrossSpaceCompactionWithFastPerformerValidationTest extends Abstrac
new SizeTieredCompactionSelector(COMPACTION_TEST_SG, "0", 0, true, tsFileManager)
.selectInnerSpaceTask(tsFileManager.getOrCreateSequenceListByTimePartition(0));
for (List<TsFileResource> taskResource : taskResources) {
- new InnerSpaceCompactionTask(
- 0,
- tsFileManager,
- taskResource,
- true,
- new FastCompactionPerformer(false),
- new AtomicInteger(0),
- 0L)
- .start();
+ Assert.assertTrue(
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ taskResource,
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0L)
+ .start());
}
// select cross compaction
@@ -2612,16 +2617,17 @@ public class CrossSpaceCompactionWithFastPerformerValidationTest extends Abstrac
Assert.assertEquals(2, sourceFiles.getSeqFiles().size());
Assert.assertEquals(3, sourceFiles.getUnseqFiles().size());
- new CrossSpaceCompactionTask(
- 0,
- tsFileManager,
- sourceFiles.getSeqFiles(),
- sourceFiles.getUnseqFiles(),
- new FastCompactionPerformer(true),
- new AtomicInteger(0),
- sourceFiles.getTotalMemoryCost(),
- 0)
- .start();
+ Assert.assertTrue(
+ new CrossSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ sourceFiles.getSeqFiles(),
+ sourceFiles.getUnseqFiles(),
+ new FastCompactionPerformer(true),
+ new AtomicInteger(0),
+ sourceFiles.getTotalMemoryCost(),
+ 0)
+ .start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
@@ -2674,15 +2680,16 @@ public class CrossSpaceCompactionWithFastPerformerValidationTest extends Abstrac
new SizeTieredCompactionSelector(COMPACTION_TEST_SG, "0", 0, true, tsFileManager)
.selectInnerSpaceTask(tsFileManager.getOrCreateSequenceListByTimePartition(0));
for (List<TsFileResource> taskResource : taskResources) {
- new InnerSpaceCompactionTask(
- 0,
- tsFileManager,
- taskResource,
- true,
- new FastCompactionPerformer(false),
- new AtomicInteger(0),
- 0L)
- .start();
+ Assert.assertTrue(
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ taskResource,
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0L)
+ .start());
}
// select cross compaction
@@ -2761,15 +2768,16 @@ public class CrossSpaceCompactionWithFastPerformerValidationTest extends Abstrac
new SizeTieredCompactionSelector(COMPACTION_TEST_SG, "0", 0, true, tsFileManager)
.selectInnerSpaceTask(tsFileManager.getOrCreateSequenceListByTimePartition(0));
for (List<TsFileResource> taskResource : taskResources) {
- new InnerSpaceCompactionTask(
- 0,
- tsFileManager,
- taskResource,
- true,
- new FastCompactionPerformer(false),
- new AtomicInteger(0),
- 0L)
- .start();
+ Assert.assertTrue(
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ taskResource,
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0L)
+ .start());
}
// select cross compaction
@@ -2849,15 +2857,16 @@ public class CrossSpaceCompactionWithFastPerformerValidationTest extends Abstrac
new SizeTieredCompactionSelector(COMPACTION_TEST_SG, "0", 0, true, tsFileManager)
.selectInnerSpaceTask(tsFileManager.getOrCreateSequenceListByTimePartition(0));
for (List<TsFileResource> taskResource : taskResources) {
- new InnerSpaceCompactionTask(
- 0,
- tsFileManager,
- taskResource,
- true,
- new FastCompactionPerformer(false),
- new AtomicInteger(0),
- 0L)
- .start();
+ Assert.assertTrue(
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ taskResource,
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0L)
+ .start());
}
// select cross compaction
@@ -2938,15 +2947,16 @@ public class CrossSpaceCompactionWithFastPerformerValidationTest extends Abstrac
new SizeTieredCompactionSelector(COMPACTION_TEST_SG, "0", 0, true, tsFileManager)
.selectInnerSpaceTask(tsFileManager.getOrCreateSequenceListByTimePartition(0));
for (List<TsFileResource> taskResource : taskResources) {
- new InnerSpaceCompactionTask(
- 0,
- tsFileManager,
- taskResource,
- true,
- new FastCompactionPerformer(false),
- new AtomicInteger(0),
- 0L)
- .start();
+ Assert.assertTrue(
+ new InnerSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ taskResource,
+ true,
+ new FastCompactionPerformer(false),
+ new AtomicInteger(0),
+ 0L)
+ .start());
}
// select cross compaction
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/CrossSpaceCompactionWithReadPointPerformerValidationTest.java b/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/CrossSpaceCompactionWithReadPointPerformerValidationTest.java
index c76dfd162d..6fdf681fa2 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/CrossSpaceCompactionWithReadPointPerformerValidationTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/CrossSpaceCompactionWithReadPointPerformerValidationTest.java
@@ -2229,16 +2229,17 @@ public class CrossSpaceCompactionWithReadPointPerformerValidationTest
Assert.assertEquals(1, sourceFiles.getSeqFiles().size());
Assert.assertEquals(2, sourceFiles.getUnseqFiles().size());
- new CrossSpaceCompactionTask(
- 0,
- tsFileManager,
- sourceFiles.getSeqFiles(),
- sourceFiles.getUnseqFiles(),
- new ReadPointCompactionPerformer(),
- new AtomicInteger(0),
- sourceFiles.getTotalMemoryCost(),
- 0)
- .start();
+ Assert.assertTrue(
+ new CrossSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ sourceFiles.getSeqFiles(),
+ sourceFiles.getUnseqFiles(),
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ sourceFiles.getTotalMemoryCost(),
+ 0)
+ .start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
@@ -2309,16 +2310,17 @@ public class CrossSpaceCompactionWithReadPointPerformerValidationTest
Assert.assertEquals(1, sourceFiles.getSeqFiles().size());
Assert.assertEquals(2, sourceFiles.getUnseqFiles().size());
- new CrossSpaceCompactionTask(
- 0,
- tsFileManager,
- sourceFiles.getSeqFiles(),
- sourceFiles.getUnseqFiles(),
- new ReadPointCompactionPerformer(),
- new AtomicInteger(0),
- sourceFiles.getTotalMemoryCost(),
- 0)
- .start();
+ Assert.assertTrue(
+ new CrossSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ sourceFiles.getSeqFiles(),
+ sourceFiles.getUnseqFiles(),
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ sourceFiles.getTotalMemoryCost(),
+ 0)
+ .start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
@@ -2390,16 +2392,17 @@ public class CrossSpaceCompactionWithReadPointPerformerValidationTest
Assert.assertEquals(1, sourceFiles.getSeqFiles().size());
Assert.assertEquals(2, sourceFiles.getUnseqFiles().size());
- new CrossSpaceCompactionTask(
- 0,
- tsFileManager,
- sourceFiles.getSeqFiles(),
- sourceFiles.getUnseqFiles(),
- new ReadPointCompactionPerformer(),
- new AtomicInteger(0),
- sourceFiles.getTotalMemoryCost(),
- 0)
- .start();
+ Assert.assertTrue(
+ new CrossSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ sourceFiles.getSeqFiles(),
+ sourceFiles.getUnseqFiles(),
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ sourceFiles.getTotalMemoryCost(),
+ 0)
+ .start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
@@ -2472,16 +2475,17 @@ public class CrossSpaceCompactionWithReadPointPerformerValidationTest
Assert.assertEquals(2, sourceFiles.getSeqFiles().size());
Assert.assertEquals(3, sourceFiles.getUnseqFiles().size());
- new CrossSpaceCompactionTask(
- 0,
- tsFileManager,
- sourceFiles.getSeqFiles(),
- sourceFiles.getUnseqFiles(),
- new ReadPointCompactionPerformer(),
- new AtomicInteger(0),
- sourceFiles.getTotalMemoryCost(),
- 0)
- .start();
+ Assert.assertTrue(
+ new CrossSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ sourceFiles.getSeqFiles(),
+ sourceFiles.getUnseqFiles(),
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ sourceFiles.getTotalMemoryCost(),
+ 0)
+ .start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
@@ -2560,16 +2564,17 @@ public class CrossSpaceCompactionWithReadPointPerformerValidationTest
Assert.assertEquals(1, sourceFiles.getSeqFiles().size());
Assert.assertEquals(2, sourceFiles.getUnseqFiles().size());
- new CrossSpaceCompactionTask(
- 0,
- tsFileManager,
- sourceFiles.getSeqFiles(),
- sourceFiles.getUnseqFiles(),
- new ReadPointCompactionPerformer(),
- new AtomicInteger(0),
- sourceFiles.getTotalMemoryCost(),
- 0)
- .start();
+ Assert.assertTrue(
+ new CrossSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ sourceFiles.getSeqFiles(),
+ sourceFiles.getUnseqFiles(),
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ sourceFiles.getTotalMemoryCost(),
+ 0)
+ .start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
@@ -2647,16 +2652,17 @@ public class CrossSpaceCompactionWithReadPointPerformerValidationTest
Assert.assertEquals(1, sourceFiles.getSeqFiles().size());
Assert.assertEquals(2, sourceFiles.getUnseqFiles().size());
- new CrossSpaceCompactionTask(
- 0,
- tsFileManager,
- sourceFiles.getSeqFiles(),
- sourceFiles.getUnseqFiles(),
- new ReadPointCompactionPerformer(),
- new AtomicInteger(0),
- sourceFiles.getTotalMemoryCost(),
- 0)
- .start();
+ Assert.assertTrue(
+ new CrossSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ sourceFiles.getSeqFiles(),
+ sourceFiles.getUnseqFiles(),
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ sourceFiles.getTotalMemoryCost(),
+ 0)
+ .start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
@@ -2735,16 +2741,17 @@ public class CrossSpaceCompactionWithReadPointPerformerValidationTest
Assert.assertEquals(1, sourceFiles.getSeqFiles().size());
Assert.assertEquals(2, sourceFiles.getUnseqFiles().size());
- new CrossSpaceCompactionTask(
- 0,
- tsFileManager,
- sourceFiles.getSeqFiles(),
- sourceFiles.getUnseqFiles(),
- new ReadPointCompactionPerformer(),
- new AtomicInteger(0),
- sourceFiles.getTotalMemoryCost(),
- 0)
- .start();
+ Assert.assertTrue(
+ new CrossSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ sourceFiles.getSeqFiles(),
+ sourceFiles.getUnseqFiles(),
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ sourceFiles.getTotalMemoryCost(),
+ 0)
+ .start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
@@ -2824,16 +2831,17 @@ public class CrossSpaceCompactionWithReadPointPerformerValidationTest
Assert.assertEquals(2, sourceFiles.getSeqFiles().size());
Assert.assertEquals(3, sourceFiles.getUnseqFiles().size());
- new CrossSpaceCompactionTask(
- 0,
- tsFileManager,
- sourceFiles.getSeqFiles(),
- sourceFiles.getUnseqFiles(),
- new ReadPointCompactionPerformer(),
- new AtomicInteger(0),
- sourceFiles.getTotalMemoryCost(),
- 0)
- .start();
+ Assert.assertTrue(
+ new CrossSpaceCompactionTask(
+ 0,
+ tsFileManager,
+ sourceFiles.getSeqFiles(),
+ sourceFiles.getUnseqFiles(),
+ new ReadPointCompactionPerformer(),
+ new AtomicInteger(0),
+ sourceFiles.getTotalMemoryCost(),
+ 0)
+ .start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/compaction/utils/MultiTsFileDeviceIteratorTest.java b/server/src/test/java/org/apache/iotdb/db/engine/compaction/utils/MultiTsFileDeviceIteratorTest.java
index a6d1612889..3160f03839 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/compaction/utils/MultiTsFileDeviceIteratorTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/compaction/utils/MultiTsFileDeviceIteratorTest.java
@@ -401,7 +401,7 @@ public class MultiTsFileDeviceIteratorTest extends AbstractCompactionTest {
new ReadChunkCompactionPerformer(),
new AtomicInteger(),
0L);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
@@ -545,7 +545,7 @@ public class MultiTsFileDeviceIteratorTest extends AbstractCompactionTest {
new ReadChunkCompactionPerformer(),
new AtomicInteger(),
0L);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
@@ -688,7 +688,7 @@ public class MultiTsFileDeviceIteratorTest extends AbstractCompactionTest {
new ReadPointCompactionPerformer(),
new AtomicInteger(),
0L);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
@@ -831,7 +831,7 @@ public class MultiTsFileDeviceIteratorTest extends AbstractCompactionTest {
new ReadPointCompactionPerformer(),
new AtomicInteger(),
0L);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
@@ -984,7 +984,7 @@ public class MultiTsFileDeviceIteratorTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(),
0L);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
@@ -1129,7 +1129,7 @@ public class MultiTsFileDeviceIteratorTest extends AbstractCompactionTest {
new FastCompactionPerformer(false),
new AtomicInteger(),
0L);
- task.start();
+ Assert.assertTrue(task.start());
validateSeqFiles(true);
validateTargetDatas(sourceData, Collections.emptyList());
diff --git a/tsfile/src/main/java/org/apache/iotdb/tsfile/write/chunk/ValueChunkWriter.java b/tsfile/src/main/java/org/apache/iotdb/tsfile/write/chunk/ValueChunkWriter.java
index 1b1100ced6..fc2ee89800 100644
--- a/tsfile/src/main/java/org/apache/iotdb/tsfile/write/chunk/ValueChunkWriter.java
+++ b/tsfile/src/main/java/org/apache/iotdb/tsfile/write/chunk/ValueChunkWriter.java
@@ -406,10 +406,6 @@ public class ValueChunkWriter {
return compressionType;
}
- public Statistics<? extends Serializable> getStatistics() {
- return statistics;
- }
-
/** only used for test */
public PublicBAOS getPageBuffer() {
return pageBuffer;