This is an automated email from the ASF dual-hosted git repository.
haonan pushed a commit to branch tsfile_name
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/tsfile_name by this push:
new 58e8db5e6d [IOTDB-3100] Semantics change of TsFile filename (#6088)
58e8db5e6d is described below
commit 58e8db5e6d08c6115a07018e59d706dd51aa0c83
Author: Alan Choo <[email protected]>
AuthorDate: Tue May 31 14:52:52 2022 +0800
[IOTDB-3100] Semantics change of TsFile filename (#6088)
---
.../org/apache/iotdb/db/engine/StorageEngine.java | 8 -
.../compaction/inner/InnerSpaceCompactionTask.java | 7 +-
.../sizetiered/SizeTieredCompactionSelector.java | 23 +-
.../inner/utils/MultiTsFileDeviceIterator.java | 4 +-
.../iotdb/db/engine/storagegroup/DataRegion.java | 141 +++++-----
.../db/engine/storagegroup/TsFileManager.java | 193 ++++++++++---
.../iotdb/db/engine/storagegroup/TsFileName.java | 221 +++++++++++++++
.../engine/storagegroup/TsFileNameGenerator.java | 185 +++----------
.../db/engine/storagegroup/TsFileResource.java | 108 ++++----
.../db/engine/storagegroup/TsFileResourceList.java | 34 ++-
.../dataregion/StorageGroupManager.java | 9 -
.../cross/RewriteCompactionFileSelectorTest.java | 250 +++--------------
.../ReadChunkCompactionPerformerNoAlignedTest.java | 29 +-
.../utils/CompactionFileGeneratorUtils.java | 6 +-
.../db/engine/storagegroup/TsFileManagerTest.java | 300 +++++++++++++++++++--
.../tsfile/fileSystem/fsFactory/FSFactory.java | 8 +
.../tsfile/fileSystem/fsFactory/HDFSFactory.java | 5 +
.../fileSystem/fsFactory/LocalFSFactory.java | 11 +
.../org/apache/iotdb/tsfile/utils/TsFileUtils.java | 1 +
.../org/apache/iotdb/tsfile/write/PerfTest.java | 7 +-
20 files changed, 936 insertions(+), 614 deletions(-)
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/StorageEngine.java
b/server/src/main/java/org/apache/iotdb/db/engine/StorageEngine.java
index a91ef781ff..31dfdddfc9 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/StorageEngine.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/StorageEngine.java
@@ -958,14 +958,6 @@ public class StorageEngine implements IService {
return false;
}
- /**
- * Set the version of given partition to newMaxVersion if it is larger than
the current version.
- */
- public void setPartitionVersionToMax(
- PartialPath storageGroup, long partitionId, long newMaxVersion) {
- processorMap.get(storageGroup).setPartitionVersionToMax(partitionId,
newMaxVersion);
- }
-
public void removePartitions(PartialPath storageGroupPath,
TimePartitionFilter filter) {
if (processorMap.get(storageGroupPath) != null) {
processorMap.get(storageGroupPath).removePartitions(filter);
diff --git
a/server/src/main/java/org/apache/iotdb/db/engine/compaction/inner/InnerSpaceCompactionTask.java
b/server/src/main/java/org/apache/iotdb/db/engine/compaction/inner/InnerSpaceCompactionTask.java
index 8f9b538816..d175c71eca 100644
---
a/server/src/main/java/org/apache/iotdb/db/engine/compaction/inner/InnerSpaceCompactionTask.java
+++
b/server/src/main/java/org/apache/iotdb/db/engine/compaction/inner/InnerSpaceCompactionTask.java
@@ -26,6 +26,7 @@ import
org.apache.iotdb.db.engine.compaction.log.CompactionLogger;
import org.apache.iotdb.db.engine.compaction.performer.ICompactionPerformer;
import org.apache.iotdb.db.engine.compaction.task.AbstractCompactionTask;
import org.apache.iotdb.db.engine.storagegroup.TsFileManager;
+import org.apache.iotdb.db.engine.storagegroup.TsFileName;
import org.apache.iotdb.db.engine.storagegroup.TsFileNameGenerator;
import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
import org.apache.iotdb.db.engine.storagegroup.TsFileResourceList;
@@ -38,7 +39,6 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
-import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
@@ -267,8 +267,7 @@ public class InnerSpaceCompactionTask extends
AbstractCompactionTask {
for (TsFileResource resource : selectedTsFileResourceList) {
try {
selectedFileSize += resource.getTsFileSize();
- TsFileNameGenerator.TsFileName fileName =
- TsFileNameGenerator.getTsFileName(resource.getTsFile().getName());
+ TsFileName fileName = TsFileName.parse(resource.getTsFile().getName());
sumOfCompactionCount += fileName.getInnerCompactionCnt();
if (fileName.getInnerCompactionCnt() > maxCompactionCount) {
maxCompactionCount = fileName.getInnerCompactionCnt();
@@ -276,7 +275,7 @@ public class InnerSpaceCompactionTask extends
AbstractCompactionTask {
if (fileName.getVersion() > maxFileVersion) {
maxFileVersion = fileName.getVersion();
}
- } catch (IOException e) {
+ } catch (RuntimeException e) {
LOGGER.warn("Fail to get the tsfile name of {}", resource.getTsFile(),
e);
}
}
diff --git
a/server/src/main/java/org/apache/iotdb/db/engine/compaction/inner/sizetiered/SizeTieredCompactionSelector.java
b/server/src/main/java/org/apache/iotdb/db/engine/compaction/inner/sizetiered/SizeTieredCompactionSelector.java
index bb16f60c5a..48612d791b 100644
---
a/server/src/main/java/org/apache/iotdb/db/engine/compaction/inner/sizetiered/SizeTieredCompactionSelector.java
+++
b/server/src/main/java/org/apache/iotdb/db/engine/compaction/inner/sizetiered/SizeTieredCompactionSelector.java
@@ -24,7 +24,7 @@ import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.engine.compaction.CompactionTaskManager;
import org.apache.iotdb.db.engine.compaction.inner.IInnerSeqSpaceSelector;
import org.apache.iotdb.db.engine.compaction.inner.IInnerUnseqSpaceSelector;
-import org.apache.iotdb.db.engine.storagegroup.TsFileNameGenerator;
+import org.apache.iotdb.db.engine.storagegroup.TsFileName;
import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
import org.apache.iotdb.db.engine.storagegroup.TsFileResourceStatus;
import org.apache.iotdb.tsfile.utils.Pair;
@@ -32,7 +32,6 @@ import org.apache.iotdb.tsfile.utils.Pair;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
@@ -113,19 +112,16 @@ public class SizeTieredCompactionSelector
* @param taskPriorityQueue it stores the batches of files to be compacted
and the total size of
* each batch
* @return return whether to continue the search to higher levels
- * @throws IOException
*/
private boolean selectLevelTask(
- int level, PriorityQueue<Pair<List<TsFileResource>, Long>>
taskPriorityQueue)
- throws IOException {
+ int level, PriorityQueue<Pair<List<TsFileResource>, Long>>
taskPriorityQueue) {
boolean shouldContinueToSearch = true;
List<TsFileResource> selectedFileList = new ArrayList<>();
long selectedFileSize = 0L;
long targetCompactionFileSize = config.getTargetCompactionFileSize();
for (TsFileResource currentFile : tsFileResources) {
- TsFileNameGenerator.TsFileName currentName =
- TsFileNameGenerator.getTsFileName(currentFile.getTsFile().getName());
+ TsFileName currentName =
TsFileName.parse(currentFile.getTsFile().getName());
if (currentName.getInnerCompactionCnt() != level
|| currentFile.getStatus() != TsFileResourceStatus.CLOSED) {
selectedFileList.clear();
@@ -155,11 +151,10 @@ public class SizeTieredCompactionSelector
return shouldContinueToSearch;
}
- private int searchMaxFileLevel() throws IOException {
+ private int searchMaxFileLevel() {
int maxLevel = -1;
for (TsFileResource currentFile : tsFileResources) {
- TsFileNameGenerator.TsFileName currentName =
- TsFileNameGenerator.getTsFileName(currentFile.getTsFile().getName());
+ TsFileName currentName =
TsFileName.parse(currentFile.getTsFile().getName());
if (currentName.getInnerCompactionCnt() > maxLevel) {
maxLevel = currentName.getInnerCompactionCnt();
}
@@ -175,15 +170,13 @@ public class SizeTieredCompactionSelector
TsFileResource resourceOfO1 = o1.left.get(0);
TsFileResource resourceOfO2 = o2.left.get(0);
try {
- TsFileNameGenerator.TsFileName fileNameOfO1 =
-
TsFileNameGenerator.getTsFileName(resourceOfO1.getTsFile().getName());
- TsFileNameGenerator.TsFileName fileNameOfO2 =
-
TsFileNameGenerator.getTsFileName(resourceOfO2.getTsFile().getName());
+ TsFileName fileNameOfO1 =
TsFileName.parse(resourceOfO1.getTsFile().getName());
+ TsFileName fileNameOfO2 =
TsFileName.parse(resourceOfO2.getTsFile().getName());
if (fileNameOfO1.getInnerCompactionCnt() !=
fileNameOfO2.getInnerCompactionCnt()) {
return fileNameOfO2.getInnerCompactionCnt() -
fileNameOfO1.getInnerCompactionCnt();
}
return (int) (fileNameOfO2.getVersion() - fileNameOfO1.getVersion());
- } catch (IOException e) {
+ } catch (RuntimeException e) {
return 0;
}
}
diff --git
a/server/src/main/java/org/apache/iotdb/db/engine/compaction/inner/utils/MultiTsFileDeviceIterator.java
b/server/src/main/java/org/apache/iotdb/db/engine/compaction/inner/utils/MultiTsFileDeviceIterator.java
index be6d2c8691..7e2161f8e5 100644
---
a/server/src/main/java/org/apache/iotdb/db/engine/compaction/inner/utils/MultiTsFileDeviceIterator.java
+++
b/server/src/main/java/org/apache/iotdb/db/engine/compaction/inner/utils/MultiTsFileDeviceIterator.java
@@ -22,6 +22,7 @@ import
org.apache.iotdb.commons.exception.IllegalPathException;
import org.apache.iotdb.commons.path.PartialPath;
import org.apache.iotdb.db.engine.modification.Modification;
import org.apache.iotdb.db.engine.modification.ModificationFile;
+import org.apache.iotdb.db.engine.storagegroup.TsFileName;
import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
import org.apache.iotdb.db.query.control.FileReaderManager;
import org.apache.iotdb.db.utils.QueryUtils;
@@ -57,7 +58,8 @@ public class MultiTsFileDeviceIterator implements
AutoCloseable {
/** Used for inner space compaction. */
public MultiTsFileDeviceIterator(List<TsFileResource> tsFileResources)
throws IOException {
this.tsFileResources = new ArrayList<>(tsFileResources);
- Collections.sort(this.tsFileResources, TsFileResource::compareFileName);
+ this.tsFileResources.sort(
+ (r1, r2) -> TsFileName.compareFileName(r1.getTsFile(),
r2.getTsFile()));
try {
for (TsFileResource tsFileResource : this.tsFileResources) {
TsFileSequenceReader reader = new
TsFileSequenceReader(tsFileResource.getTsFilePath());
diff --git
a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/DataRegion.java
b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/DataRegion.java
index 7bb7abe855..55375b3e60 100755
---
a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/DataRegion.java
+++
b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/DataRegion.java
@@ -123,8 +123,8 @@ import java.util.Set;
import java.util.TreeMap;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
@@ -202,8 +202,6 @@ public class DataRegion {
private AtomicInteger upgradeFileCount = new AtomicInteger();
- private AtomicBoolean isSettling = new AtomicBoolean();
-
/** data region id */
private String dataRegionId;
/** logical storage group name */
@@ -232,12 +230,15 @@ public class DataRegion {
/** file flush policy */
private TsFileFlushPolicy fileFlushPolicy;
/**
- * The max file versions in each partition. By recording this, if several
IoTDB instances have the
- * same policy of closing file and their ingestion is identical, then files
of the same version in
- * different IoTDB instance will have identical data, providing convenience
for data comparison
- * across different instances. partition number -> max version number
+ * TODOļ¼delete this field when new load is completed The max file versions
in each partition. By
+ * recording this, if several IoTDB instances have the same policy of
closing file and their
+ * ingestion is identical, then files of the same version in different IoTDB
instance will have
+ * identical data, providing convenience for data comparison across
different instances. partition
+ * number -> max version number
*/
private Map<Long, Long> partitionMaxFileVersions = new HashMap<>();
+ /** The last file created time in each partition. partition number -> max
created time */
+ private final Map<Long, AtomicLong> partition2LastFileCreatedTime = new
HashMap<>();
/** storage group info for mem control */
private StorageGroupInfo storageGroupInfo = new StorageGroupInfo(this);
/** whether it's ready from recovery */
@@ -337,14 +338,6 @@ public class DataRegion {
return ret;
}
- public AtomicBoolean getIsSettling() {
- return isSettling;
- }
-
- public void setSettling(boolean isSettling) {
- this.isSettling.set(isSettling);
- }
-
/** this class is used to store recovering context */
private class DataRegionRecoveryContext {
/** number of files to be recovered */
@@ -471,18 +464,26 @@ public class DataRegion {
for (TsFileResource resource : tsFileManager.getTsFileList(true)) {
long partitionNum = resource.getTimePartition();
updatePartitionFileVersion(partitionNum, resource.getVersion());
+ updatePartitionFileCreatedTime(
+ partitionNum,
TsFileName.parseTime(resource.getTsFile().getName()));
}
for (TsFileResource resource : tsFileManager.getTsFileList(false)) {
long partitionNum = resource.getTimePartition();
updatePartitionFileVersion(partitionNum, resource.getVersion());
+ updatePartitionFileCreatedTime(
+ partitionNum,
TsFileName.parseTime(resource.getTsFile().getName()));
}
for (TsFileResource resource : upgradeSeqFileList) {
long partitionNum = resource.getTimePartition();
updatePartitionFileVersion(partitionNum, resource.getVersion());
+ updatePartitionFileCreatedTime(
+ partitionNum,
TsFileName.parseTime(resource.getTsFile().getName()));
}
for (TsFileResource resource : upgradeUnseqFileList) {
long partitionNum = resource.getTimePartition();
updatePartitionFileVersion(partitionNum, resource.getVersion());
+ updatePartitionFileCreatedTime(
+ partitionNum,
TsFileName.parseTime(resource.getTsFile().getName()));
}
updateLatestFlushedTime();
} catch (IOException e) {
@@ -524,7 +525,7 @@ public class DataRegion {
TimeUnit.MILLISECONDS);
}
- private void recoverCompaction() throws Exception {
+ private void recoverCompaction() {
CompactionRecoverManager compactionRecoverManager =
new CompactionRecoverManager(tsFileManager, logicalStorageGroupName,
dataRegionId);
compactionRecoverManager.recoverInnerSpaceCompaction(true);
@@ -539,6 +540,20 @@ public class DataRegion {
}
}
+ private void updatePartitionFileCreatedTime(long partitionNum, long
createdTime) {
+ AtomicLong maxCreatedTime =
+ partition2LastFileCreatedTime.computeIfAbsent(partitionNum, k -> new
AtomicLong());
+ boolean flag = true;
+ while (flag) {
+ long oldVal = maxCreatedTime.get();
+ if (createdTime > oldVal) {
+ flag = !maxCreatedTime.compareAndSet(oldVal, createdTime);
+ } else {
+ flag = false;
+ }
+ }
+ }
+
/**
* use old seq file to update latestTimeForEachDevice,
globalLatestFlushedTimeForEachDevice,
* partitionLatestFlushedTimeForEachDevice and
timePartitionIdVersionControllerMap
@@ -623,14 +638,14 @@ public class DataRegion {
}
}
- tsFiles.sort(this::compareFileName);
+ tsFiles.sort(TsFileName::compareFileName);
if (!tsFiles.isEmpty()) {
checkTsFileTime(tsFiles.get(tsFiles.size() - 1));
}
List<TsFileResource> ret = new ArrayList<>();
tsFiles.forEach(f -> ret.add(new TsFileResource(f)));
- upgradeFiles.sort(this::compareFileName);
+ upgradeFiles.sort(TsFileName::compareFileName);
if (!upgradeFiles.isEmpty()) {
checkTsFileTime(upgradeFiles.get(upgradeFiles.size() - 1));
}
@@ -751,7 +766,7 @@ public class DataRegion {
recoverPerformer.recover();
// pick up crashed compaction target files
if (recoverPerformer.hasCrashed()) {
- if
(TsFileResource.getInnerCompactionCount(sealedTsFile.getTsFile().getName()) >
0) {
+ if
(TsFileName.parseInnerCompactionCnt(sealedTsFile.getTsFile().getName()) > 0) {
tsFileManager.addForRecover(sealedTsFile, isSeq);
return;
} else {
@@ -761,7 +776,7 @@ public class DataRegion {
}
}
sealedTsFile.close();
- tsFileManager.add(sealedTsFile, isSeq);
+ tsFileManager.keepOrderInsert(sealedTsFile, isSeq);
tsFileResourceManager.registerSealedTsFileResource(sealedTsFile);
} catch (DataRegionException | IOException e) {
logger.error("Fail to recover sealed TsFile {}, skip it.",
sealedTsFile.getTsFilePath(), e);
@@ -771,20 +786,6 @@ public class DataRegion {
}
}
- // ({systemTime}-{versionNum}-{mergeNum}.tsfile)
- private int compareFileName(File o1, File o2) {
- String[] items1 = o1.getName().replace(TSFILE_SUFFIX,
"").split(FILE_NAME_SEPARATOR);
- String[] items2 = o2.getName().replace(TSFILE_SUFFIX,
"").split(FILE_NAME_SEPARATOR);
- long ver1 = Long.parseLong(items1[0]);
- long ver2 = Long.parseLong(items2[0]);
- int cmp = Long.compare(ver1, ver2);
- if (cmp == 0) {
- return Long.compare(Long.parseLong(items1[1]),
Long.parseLong(items2[1]));
- } else {
- return cmp;
- }
- }
-
/**
* insert one row of data
*
@@ -1416,17 +1417,42 @@ public class DataRegion {
private TsFileProcessor newTsFileProcessor(boolean sequence, long
timePartitionId)
throws IOException, DiskSpaceInsufficientException {
-
long version = partitionMaxFileVersions.getOrDefault(timePartitionId, 0L)
+ 1;
partitionMaxFileVersions.put(timePartitionId, version);
+
+ AtomicLong maxCreatedTime =
+ partition2LastFileCreatedTime.computeIfAbsent(timePartitionId, k ->
new AtomicLong());
+ long createdTime = System.currentTimeMillis();
+ boolean flag = true;
+ while (flag) {
+ long oldVal = maxCreatedTime.get();
+ createdTime = System.currentTimeMillis();
+ if (createdTime > oldVal) {
+ flag = !maxCreatedTime.compareAndSet(oldVal, createdTime);
+ } else {
+ logger.warn(
+ "System currentTimeMillis is smaller than time partition-{}'s max
file created time {}.",
+ timePartitionId,
+ oldVal);
+ try {
+ Thread.sleep(1_000);
+ } catch (InterruptedException e) {
+ logger.error(
+ "Interrupted when waiting for System currentTimeMillis increases
to bigger than {}.",
+ oldVal);
+ Thread.currentThread().interrupt();
+ }
+ }
+ }
+
String filePath =
TsFileNameGenerator.generateNewTsFilePathWithMkdir(
sequence,
logicalStorageGroupName,
dataRegionId,
timePartitionId,
- System.currentTimeMillis(),
- version,
+ createdTime,
+ version, // TODO: change version to 0L when field
partitionMaxFileVersions is removed
0,
0);
@@ -1469,21 +1495,6 @@ public class DataRegion {
return tsFileProcessor;
}
- /**
- * Create a new tsfile name
- *
- * @return file name
- */
- private String getNewTsFileName(long timePartitionId) {
- long version = partitionMaxFileVersions.getOrDefault(timePartitionId, 0L)
+ 1;
- partitionMaxFileVersions.put(timePartitionId, version);
- return getNewTsFileName(System.currentTimeMillis(), version, 0, 0);
- }
-
- private String getNewTsFileName(long time, long version, int mergeCnt, int
unseqCompactionCnt) {
- return TsFileNameGenerator.generateNewTsFileName(time, version, mergeCnt,
unseqCompactionCnt);
- }
-
/**
* close one tsfile processor
*
@@ -2498,21 +2509,6 @@ public class DataRegion {
}
}
- /**
- * Set the version in "partition" to "version" if "version" is larger than
the current version.
- */
- public void setPartitionFileVersionToMax(long partition, long version) {
- partitionMaxFileVersions.compute(
- partition, (prt, oldVer) -> computeMaxVersion(oldVer, version));
- }
-
- private long computeMaxVersion(Long oldVersion, Long newVersion) {
- if (oldVersion == null) {
- return newVersion;
- }
- return Math.max(oldVersion, newVersion);
- }
-
private Long getTsFileResourceEstablishTime(TsFileResource tsFileResource) {
String tsFileName = tsFileResource.getTsFile().getName();
return Long.parseLong(tsFileName.split(FILE_NAME_SEPARATOR)[0]);
@@ -2694,8 +2690,9 @@ public class DataRegion {
* Get an appropriate filename to ensure the order between files. The tsfile
is named after
*
({systemTime}-{versionNum}-{in_space_compaction_num}-{cross_space_compaction_num}.tsfile).
*
- * <p>The sorting rules for tsfile names @see {@link this#compareFileName},
we can restore the
- * list based on the file name and ensure the correctness of the order, so
there are three cases.
+ * <p>The sorting rules for tsfile names @see {@link
TsFileName#compareFileName} }, we can restore
+ * the list based on the file name and ensure the correctness of the order,
so there are three
+ * cases.
*
* <p>1. The tsfile is to be inserted in the first place of the list.
Timestamp can be set to half
* of the timestamp value in the file name of the first tsfile in the list ,
and the version
@@ -2718,7 +2715,7 @@ public class DataRegion {
List<TsFileResource> sequenceList) {
long timePartitionId = newTsFileResource.getTimePartition();
if (tsFileType == LoadTsFileType.LOAD_UNSEQUENCE || insertIndex ==
sequenceList.size() - 1) {
- return getNewTsFileName(
+ return TsFileName.getTsFileName(
System.currentTimeMillis(),
getAndSetNewVersion(timePartitionId, newTsFileResource),
0,
@@ -2730,7 +2727,7 @@ public class DataRegion {
long subsequenceTime =
getTsFileResourceEstablishTime(sequenceList.get(insertIndex + 1));
long meanTime = preTime + ((subsequenceTime - preTime) >> 1);
- return getNewTsFileName(
+ return TsFileName.getTsFileName(
meanTime, getAndSetNewVersion(timePartitionId, newTsFileResource), 0,
0);
}
@@ -3489,7 +3486,7 @@ public class DataRegion {
}
public List<Long> getTimePartitions() {
- return new ArrayList<>(partitionMaxFileVersions.keySet());
+ return new ArrayList<>(partition2LastFileCreatedTime.keySet());
}
public String getInsertWriteLockHolder() {
diff --git
a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileManager.java
b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileManager.java
index 009e151d87..6453ec1d88 100644
---
a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileManager.java
+++
b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileManager.java
@@ -29,6 +29,8 @@ import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
@@ -39,9 +41,6 @@ import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
-import static org.apache.iotdb.commons.conf.IoTDBConstant.FILE_NAME_SEPARATOR;
-import static
org.apache.iotdb.tsfile.common.constant.TsFileConstant.TSFILE_SUFFIX;
-
public class TsFileManager {
private static final Logger LOGGER =
LoggerFactory.getLogger(TsFileManager.class);
private String storageGroupName;
@@ -168,7 +167,7 @@ public class TsFileManager {
}
}
- public void keepOrderInsert(TsFileResource tsFileResource, boolean sequence)
throws IOException {
+ public void keepOrderInsert(TsFileResource tsFileResource, boolean sequence)
{
writeLock("keepOrderInsert");
try {
Map<Long, TsFileResourceList> selectedMap = sequence ? sequenceFiles :
unsequenceFiles;
@@ -199,6 +198,141 @@ public class TsFileManager {
}
}
+ /**
+ * Add files with same timestamp after target file in order, some files'
version field will be
+ * renamed when name conflicting occurs.
+ *
+ * @param addAfterThisFile files will be added after this file, null means
add to the beginning of
+ * corresponding TsFileResourceList
+ * @param filesToAdd files to add, add order will follow files order in the
list. File name format
+ * should like {@link TsFileName#TS_FILE_NAME_PATTERN } and their time
fields should be same.
+ * @param sequence files in filesToAdd are sequence or not
+ * @param timePartition the time partition of files in filesToAdd
+ * @return false if target file doesn't exist in the TsFileManger or files
to add don't share same
+ * timestamp
+ */
+ public boolean keepOrderAddAllAndRenameAfter(
+ TsFileResource addAfterThisFile,
+ List<TsFileResource> filesToAdd,
+ boolean sequence,
+ long timePartition) {
+ if (filesToAdd.isEmpty()) {
+ return true;
+ }
+ // all files to add should share the same timestamp
+ long targetTime = filesToAdd.get(0).getCreatedTime();
+ for (TsFileResource resource : filesToAdd) {
+ if (resource.getCreatedTime() != targetTime) {
+ LOGGER.warn(
+ "File {} and file {} don't share the same timestamp, please check
it.",
+ filesToAdd.get(0).getTsFile(),
+ resource.getTsFile());
+ return false;
+ }
+ }
+
+ writeLock("keepOrderAddAllAndRenameAfter");
+ try {
+ Map<Long, TsFileResourceList> targetMap = sequence ? sequenceFiles :
unsequenceFiles;
+ TsFileResourceList targetList =
+ targetMap.computeIfAbsent(timePartition, o -> new
TsFileResourceList());
+ Map<Long, TsFileResourceList> leftMap = sequence ? unsequenceFiles :
sequenceFiles;
+ TsFileResourceList leftList =
+ leftMap.computeIfAbsent(timePartition, o -> new
TsFileResourceList());
+
+ // check target file position
+ if (addAfterThisFile == null) {
+ // check time, make sure target time <= header.time
+ if (!targetList.isEmpty() && targetList.get(0).getCreatedTime() <
targetTime) {
+ LOGGER.warn(
+ "Files to add will destroy the order of TsFileResourceList,
please check the add position of file {}",
+ filesToAdd.get(0).getTsFile());
+ return false;
+ }
+ } else {
+ // target file doesn't exist
+ if (!targetList.contains(addAfterThisFile)) {
+ LOGGER.warn(
+ "TsFileManager doesn't contain file {}, cannot add files after
it.",
+ addAfterThisFile.getTsFile());
+ return false;
+ }
+ // check time, make sure prev.time <= target time <= next.time
+ if ((addAfterThisFile.prev != null &&
addAfterThisFile.prev.getCreatedTime() > targetTime)
+ || (addAfterThisFile.next != null
+ && addAfterThisFile.next.getCreatedTime() < targetTime)) {
+ LOGGER.warn(
+ "Files to add will destroy the order of TsFileResourceList,
please check the add position of file {}",
+ filesToAdd.get(0).getTsFile());
+ return false;
+ }
+ }
+
+ // filter files need renaming
+ List<TsFileResource> filesToRename = new ArrayList<>();
+ long startVersion =
+ addAfterThisFile != null && addAfterThisFile.getCreatedTime() ==
targetTime
+ ? addAfterThisFile.getVersion() + 1
+ : -1;
+ // 1. filter files need renaming from target list
+ List<TsFileResource> targetSameTimeList =
targetList.getFilesByTime(targetTime);
+ // e.g., seq: [1-0-0-0, add here with time=2, 2-0-0-0], unseq: [2-1-0-0]
+ if (startVersion == -1 && !targetSameTimeList.isEmpty()) {
+ startVersion = targetSameTimeList.get(0).getVersion();
+ }
+ for (TsFileResource resource : targetSameTimeList) {
+ if (resource.getVersion() >= startVersion) {
+ filesToRename.add(resource);
+ }
+ }
+ // 2. filter files need renaming from another list
+ List<TsFileResource> leftSameTimeList =
leftList.getFilesByTime(targetTime);
+ // e.g., seq: [1-0-0-0, add here with time=2, 3-0-0-0], unseq: [2-0-0-0,
2-1-0-0]
+ if (startVersion == -1 && !leftSameTimeList.isEmpty()) {
+ startVersion = leftSameTimeList.get(leftSameTimeList.size() -
1).getVersion() + 1;
+ }
+ for (TsFileResource resource : leftSameTimeList) {
+ if (resource.getVersion() >= startVersion) {
+ filesToRename.add(resource);
+ }
+ }
+
+ // rename existing files
+ filesToRename.sort(((Comparator<TsFileResource>)
(TsFileName::compareFileName)).reversed());
+ long offset = filesToAdd.size();
+ for (TsFileResource resource : filesToRename) {
+ resource.setVersion(resource.getVersion() + offset);
+ }
+
+ // add files
+ if (startVersion == -1) {
+ startVersion = 0;
+ }
+ int index = 0;
+ if (addAfterThisFile == null) {
+ addAfterThisFile = filesToAdd.get(0);
+ addAfterThisFile.setVersion(startVersion);
+ startVersion++;
+ index++;
+ targetList.set(0, addAfterThisFile);
+ }
+ TsFileResource prev = addAfterThisFile;
+ for (; index < filesToAdd.size(); index++) {
+ TsFileResource current = filesToAdd.get(index);
+ // update version
+ current.setVersion(startVersion);
+ startVersion++;
+ // add it to manager
+ targetList.insertAfter(prev, current);
+ prev = current;
+ }
+ } finally {
+ writeUnlock();
+ }
+
+ return true;
+ }
+
/** This method is called after compaction to update memory. */
public void replace(
List<TsFileResource> seqFileResources,
@@ -209,7 +343,16 @@ public class TsFileManager {
throws IOException {
writeLock("replace");
try {
+ Map<Long, List<TsFileResource>> time2TargetFiles = new HashMap<>();
+ for (TsFileResource resource : targetFileResources) {
+ time2TargetFiles
+ .computeIfAbsent(resource.getCreatedTime(), k -> new ArrayList<>())
+ .add(resource);
+ }
+ Map<Long, TsFileResource> time2TargetPosition = new HashMap<>();
+ // remove source
for (TsFileResource tsFileResource : seqFileResources) {
+ time2TargetPosition.put(tsFileResource.getCreatedTime(),
tsFileResource.prev);
if (sequenceFiles.get(timePartition).remove(tsFileResource)) {
TsFileResourceManager.getInstance().removeTsFileResource(tsFileResource);
}
@@ -219,20 +362,18 @@ public class TsFileManager {
TsFileResourceManager.getInstance().removeTsFileResource(tsFileResource);
}
}
- if (isTargetSequence) {
- // seq inner space compaction or cross space compaction
- for (TsFileResource resource : targetFileResources) {
-
TsFileResourceManager.getInstance().registerSealedTsFileResource(resource);
- sequenceFiles.get(timePartition).keepOrderInsert(resource);
- }
- } else {
- // unseq inner space compaction
- for (TsFileResource resource : targetFileResources) {
-
TsFileResourceManager.getInstance().registerSealedTsFileResource(resource);
- unsequenceFiles.get(timePartition).keepOrderInsert(resource);
- }
+ // add target
+ for (Long time : time2TargetFiles.keySet()) {
+ keepOrderAddAllAndRenameAfter(
+ time2TargetPosition.get(time),
+ time2TargetFiles.get(time),
+ isTargetSequence,
+ timePartition);
+ }
+ // register to TsFileResourceManager
+ for (TsFileResource resource : targetFileResources) {
+
TsFileResourceManager.getInstance().registerSealedTsFileResource(resource);
}
-
} finally {
writeUnlock();
}
@@ -407,22 +548,4 @@ public class TsFileManager {
}
}
}
-
- //
({systemTime}-{versionNum}-{innerCompactionNum}-{crossCompactionNum}.tsfile)
- public static int compareFileName(File o1, File o2) {
- String[] items1 = o1.getName().replace(TSFILE_SUFFIX,
"").split(FILE_NAME_SEPARATOR);
- String[] items2 = o2.getName().replace(TSFILE_SUFFIX,
"").split(FILE_NAME_SEPARATOR);
- long ver1 = Long.parseLong(items1[0]);
- long ver2 = Long.parseLong(items2[0]);
- int cmp = Long.compare(ver1, ver2);
- if (cmp == 0) {
- int cmpVersion = Long.compare(Long.parseLong(items1[1]),
Long.parseLong(items2[1]));
- if (cmpVersion == 0) {
- return Long.compare(Long.parseLong(items1[2]),
Long.parseLong(items2[2]));
- }
- return cmpVersion;
- } else {
- return cmp;
- }
- }
}
diff --git
a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileName.java
b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileName.java
new file mode 100644
index 0000000000..a7d848324e
--- /dev/null
+++
b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileName.java
@@ -0,0 +1,221 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.iotdb.db.engine.storagegroup;
+
+import java.io.File;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static
org.apache.iotdb.commons.conf.IoTDBConstant.CROSS_COMPACTION_TMP_FILE_SUFFIX;
+import static org.apache.iotdb.commons.conf.IoTDBConstant.FILE_NAME_SEPARATOR;
+import static
org.apache.iotdb.commons.conf.IoTDBConstant.INNER_COMPACTION_TMP_FILE_SUFFIX;
+import static
org.apache.iotdb.tsfile.common.constant.TsFileConstant.TSFILE_SUFFIX;
+
+public class TsFileName implements Comparable<TsFileName> {
+ /**
+ * The format is
{time}-{version}-{innerCompactionCnt}-{crossCompactionCnt}.tsfile. Field time
and
+ * version are used to guarantee the order of tsfiles, if two tsfiles have
the same time, then we
+ * use version to guarantee the order.
+ */
+ public static final Pattern TS_FILE_NAME_PATTERN =
+ Pattern.compile(
+ String.format(
+
"(?<time>\\d+)%s(?<version>\\d+)%s(?<innerCompactionCnt>\\d+)%s(?<crossCompactionCnt>\\d+)(?<suffix>\\%s|\\%s|\\%s)$",
+ FILE_NAME_SEPARATOR,
+ FILE_NAME_SEPARATOR,
+ FILE_NAME_SEPARATOR,
+ TSFILE_SUFFIX,
+ INNER_COMPACTION_TMP_FILE_SUFFIX,
+ CROSS_COMPACTION_TMP_FILE_SUFFIX));
+
+ public static final String TS_FILE_NAME_FORMAT =
+ "%d" + FILE_NAME_SEPARATOR + "%d" + FILE_NAME_SEPARATOR + "%d" +
FILE_NAME_SEPARATOR + "%d";
+
+ private volatile long time;
+ private volatile long version;
+ private int innerCompactionCnt;
+ private int crossCompactionCnt;
+ private final String suffix;
+
+ public TsFileName(
+ long time, long version, int innerCompactionCnt, int crossCompactionCnt,
String suffix) {
+ this.time = time;
+ this.version = version;
+ this.innerCompactionCnt = innerCompactionCnt;
+ this.crossCompactionCnt = crossCompactionCnt;
+ this.suffix = suffix;
+ }
+
+ public String toFileName() {
+ return formatPrefix(time, version, innerCompactionCnt, crossCompactionCnt)
+ suffix;
+ }
+
+ public long getTime() {
+ return time;
+ }
+
+ public void setTime(long time) {
+ this.time = time;
+ }
+
+ public long getVersion() {
+ return version;
+ }
+
+ public void setVersion(long version) {
+ this.version = version;
+ }
+
+ public int getInnerCompactionCnt() {
+ return innerCompactionCnt;
+ }
+
+ public void setInnerCompactionCnt(int innerCompactionCnt) {
+ this.innerCompactionCnt = innerCompactionCnt;
+ }
+
+ public int getCrossCompactionCnt() {
+ return crossCompactionCnt;
+ }
+
+ public void setCrossCompactionCnt(int crossCompactionCnt) {
+ this.crossCompactionCnt = crossCompactionCnt;
+ }
+
+ private static int compare(long time1, long version1, long time2, long
version2) {
+ int cmp = Long.compare(time1, time2);
+ if (cmp == 0) {
+ cmp = Long.compare(version1, version2);
+ }
+ return cmp;
+ }
+
+ @Override
+ public int compareTo(TsFileName other) {
+ return compare(this.time, this.version, other.time, other.version);
+ }
+
+ /** Compare tsfile name, first compare createdTime, then compare versionId */
+ public static int compareFileName(String tsFileName1, String tsFileName2) {
+ return parse(tsFileName1).compareTo(parse(tsFileName2));
+ }
+
+ /** Compare tsfile name, first compare createdTime, then compare versionId */
+ public static int compareFileName(File tsFile1, File tsFile2) {
+ return compareFileName(tsFile1.getName(), tsFile2.getName());
+ }
+
+ public static int compareFileName(TsFileResource resource1, TsFileResource
resource2) {
+ return compare(
+ resource1.getCreatedTime(),
+ resource1.getVersion(),
+ resource2.getCreatedTime(),
+ resource2.getVersion());
+ }
+
+ private static String formatPrefix(
+ long time, long version, int innerCompactionCnt, int crossCompactionCnt)
{
+ return String.format(
+ TS_FILE_NAME_FORMAT, time, version, innerCompactionCnt,
crossCompactionCnt);
+ }
+
+ /**
+ * Gets tsfile name, the format is
+ * {time}-{version}-{innerCompactionCnt}-{crossCompactionCnt}.tsfile
+ */
+ public static String getTsFileName(
+ long time, long version, int innerCompactionCnt, int crossCompactionCnt)
{
+ return formatPrefix(time, version, innerCompactionCnt, crossCompactionCnt)
+ TSFILE_SUFFIX;
+ }
+
+ /**
+ * Gets inner tsfile name, the format is
+ * {time}-{version}-{innerCompactionCnt}-{crossCompactionCnt}.inner
+ */
+ public static String getInnerTsFileName(
+ long time, long version, int innerCompactionCnt, int crossCompactionCnt)
{
+ return formatPrefix(time, version, innerCompactionCnt, crossCompactionCnt)
+ + INNER_COMPACTION_TMP_FILE_SUFFIX;
+ }
+
+ /**
+ * Gets cross tsfile name, the format is
+ * {time}-{version}-{innerCompactionCnt}-{crossCompactionCnt}.cross
+ */
+ public static String getCrossTsFileName(
+ long time, long version, int innerCompactionCnt, int crossCompactionCnt)
{
+ return formatPrefix(time, version, innerCompactionCnt, crossCompactionCnt)
+ + CROSS_COMPACTION_TMP_FILE_SUFFIX;
+ }
+
+ /** Judge whether the file name is valid */
+ public static boolean isNameValid(String fileName) {
+ return TS_FILE_NAME_PATTERN.matcher(fileName).find();
+ }
+
+ /** Parses info from tsfile name */
+ public static TsFileName parse(String tsFileName) {
+ Matcher matcher = TS_FILE_NAME_PATTERN.matcher(tsFileName);
+ if (!matcher.find()) {
+ throw new RuntimeException("TsFile file name format is incorrect: " +
tsFileName);
+ }
+ return new TsFileName(
+ Long.parseLong(matcher.group("time")),
+ Long.parseLong(matcher.group("version")),
+ Integer.parseInt(matcher.group("innerCompactionCnt")),
+ Integer.parseInt(matcher.group("crossCompactionCnt")),
+ matcher.group("suffix"));
+ }
+
+ /** Parses time from tsfile name */
+ public static long parseTime(String tsFileName) {
+ Matcher matcher = TS_FILE_NAME_PATTERN.matcher(tsFileName);
+ if (!matcher.find()) {
+ throw new RuntimeException("TsFile file name format is incorrect: " +
tsFileName);
+ }
+ return Long.parseLong(matcher.group("time"));
+ }
+
+ /** Parses version id from tsfile name */
+ public static long parseVersion(String tsFileName) {
+ Matcher matcher = TS_FILE_NAME_PATTERN.matcher(tsFileName);
+ if (!matcher.find()) {
+ throw new RuntimeException("TsFile file name format is incorrect: " +
tsFileName);
+ }
+ return Long.parseLong(matcher.group("version"));
+ }
+
+ /** Parses inner space merge num from tsfile name */
+ public static int parseInnerCompactionCnt(String tsFileName) {
+ Matcher matcher = TS_FILE_NAME_PATTERN.matcher(tsFileName);
+ if (!matcher.find()) {
+ throw new RuntimeException("TsFile file name format is incorrect: " +
tsFileName);
+ }
+ return Integer.parseInt(matcher.group("innerCompactionCnt"));
+ }
+
+ /** Parses cross space merge num from tsfile name */
+ public static int parseCrossCompactionCnt(String tsFileName) {
+ Matcher matcher = TS_FILE_NAME_PATTERN.matcher(tsFileName);
+ if (!matcher.find()) {
+ throw new RuntimeException("TsFile file name format is incorrect: " +
tsFileName);
+ }
+ return Integer.parseInt(matcher.group("crossCompactionCnt"));
+ }
+}
diff --git
a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileNameGenerator.java
b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileNameGenerator.java
index 946d827461..4374291beb 100644
---
a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileNameGenerator.java
+++
b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileNameGenerator.java
@@ -19,26 +19,18 @@
package org.apache.iotdb.db.engine.storagegroup;
-import org.apache.iotdb.commons.conf.IoTDBConstant;
import org.apache.iotdb.db.conf.directories.DirectoryManager;
import org.apache.iotdb.db.exception.DiskSpaceInsufficientException;
-import org.apache.iotdb.tsfile.common.constant.TsFileConstant;
import org.apache.iotdb.tsfile.fileSystem.FSFactoryProducer;
import org.apache.iotdb.tsfile.fileSystem.fsFactory.FSFactory;
import java.io.File;
-import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import static org.apache.iotdb.commons.conf.IoTDBConstant.FILE_NAME_SEPARATOR;
-import static
org.apache.iotdb.tsfile.common.constant.TsFileConstant.TSFILE_SUFFIX;
public class TsFileNameGenerator {
- private static FSFactory fsFactory = FSFactoryProducer.getFSFactory();
+ private static final FSFactory fsFactory = FSFactoryProducer.getFSFactory();
public static String generateNewTsFilePath(
String tsFileDir,
@@ -48,7 +40,7 @@ public class TsFileNameGenerator {
int crossSpaceCompactionCount) {
return tsFileDir
+ File.separator
- + generateNewTsFileName(
+ + TsFileName.getTsFileName(
time, version, innerSpaceCompactionCount,
crossSpaceCompactionCount);
}
@@ -67,7 +59,7 @@ public class TsFileNameGenerator {
fsFactory.getFile(tsFileDir).mkdirs();
return tsFileDir
+ File.separator
- + generateNewTsFileName(
+ + TsFileName.getTsFileName(
time, version, innerSpaceCompactionCount,
crossSpaceCompactionCount);
}
@@ -91,71 +83,20 @@ public class TsFileNameGenerator {
+ timePartitionId;
}
- public static String generateNewTsFileName(
- long time, long version, int innerSpaceCompactionCount, int
crossSpaceCompactionCount) {
- return time
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + version
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + innerSpaceCompactionCount
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + crossSpaceCompactionCount
- + TsFileConstant.TSFILE_SUFFIX;
- }
-
- public static TsFileName getTsFileName(String fileName) throws IOException {
- Matcher matcher = TsFileName.FILE_NAME_MATCHER.matcher(fileName);
- if (matcher.find()) {
- try {
- TsFileName tsFileName =
- new TsFileName(
- Long.parseLong(matcher.group(1)),
- Long.parseLong(matcher.group(2)),
- Integer.parseInt(matcher.group(3)),
- Integer.parseInt(matcher.group(4)));
- return tsFileName;
- } catch (NumberFormatException e) {
- throw new IOException("tsfile file name format is incorrect:" +
fileName);
- }
- } else {
- throw new IOException("tsfile file name format is incorrect:" +
fileName);
- }
- }
-
- public static TsFileResource increaseCrossCompactionCnt(TsFileResource
tsFileResource)
- throws IOException {
+ public static TsFileResource increaseCrossCompactionCnt(TsFileResource
tsFileResource) {
File tsFile = tsFileResource.getTsFile();
String path = tsFile.getParent();
- TsFileName tsFileName =
getTsFileName(tsFileResource.getTsFile().getName());
+ TsFileName tsFileName =
TsFileName.parse(tsFileResource.getTsFile().getName());
tsFileName.setCrossCompactionCnt(tsFileName.getCrossCompactionCnt() + 1);
- tsFileResource.setFile(
- new File(
- path,
- tsFileName.time
- + FILE_NAME_SEPARATOR
- + tsFileName.version
- + FILE_NAME_SEPARATOR
- + tsFileName.innerCompactionCnt
- + FILE_NAME_SEPARATOR
- + tsFileName.crossCompactionCnt
- + TSFILE_SUFFIX));
+ tsFileResource.setFile(new File(path, tsFileName.toFileName()));
return tsFileResource;
}
- public static File increaseCrossCompactionCnt(File tsFile) throws
IOException {
+ public static File increaseCrossCompactionCnt(File tsFile) {
String path = tsFile.getParent();
- TsFileName tsFileName = getTsFileName(tsFile.getName());
+ TsFileName tsFileName = TsFileName.parse(tsFile.getName());
tsFileName.setCrossCompactionCnt(tsFileName.getCrossCompactionCnt() + 1);
- return new File(
- path,
- tsFileName.time
- + FILE_NAME_SEPARATOR
- + tsFileName.version
- + FILE_NAME_SEPARATOR
- + tsFileName.innerCompactionCnt
- + FILE_NAME_SEPARATOR
- + tsFileName.crossCompactionCnt
- + TSFILE_SUFFIX);
+ return new File(path, tsFileName.toFileName());
}
/**
@@ -164,26 +105,22 @@ public class TsFileNameGenerator {
*
* @param seqResources
* @return tmp target file list, which is xxx.cross
- * @throws IOException
*/
public static List<TsFileResource> getCrossCompactionTargetFileResources(
- List<TsFileResource> seqResources) throws IOException {
+ List<TsFileResource> seqResources) {
List<TsFileResource> targetFileResources = new ArrayList<>();
for (TsFileResource resource : seqResources) {
- TsFileName tsFileName = getTsFileName(resource.getTsFile().getName());
+ TsFileName tsFileName = TsFileName.parse(resource.getTsFile().getName());
tsFileName.setCrossCompactionCnt(tsFileName.getCrossCompactionCnt() + 1);
targetFileResources.add(
new TsFileResource(
new File(
resource.getTsFile().getParent(),
- tsFileName.time
- + FILE_NAME_SEPARATOR
- + tsFileName.version
- + FILE_NAME_SEPARATOR
- + tsFileName.innerCompactionCnt
- + FILE_NAME_SEPARATOR
- + tsFileName.crossCompactionCnt
- + IoTDBConstant.CROSS_COMPACTION_TMP_FILE_SUFFIX)));
+ TsFileName.getCrossTsFileName(
+ tsFileName.getTime(),
+ tsFileName.getVersion(),
+ tsFileName.getInnerCompactionCnt(),
+ tsFileName.getCrossCompactionCnt()))));
}
return targetFileResources;
}
@@ -195,96 +132,34 @@ public class TsFileNameGenerator {
* @param tsFileResources
* @param sequence
* @return tmp target file, which is xxx.target
- * @throws IOException
*/
public static TsFileResource getInnerCompactionTargetFileResource(
- List<TsFileResource> tsFileResources, boolean sequence) throws
IOException {
+ List<TsFileResource> tsFileResources, boolean sequence) {
long minTime = Long.MAX_VALUE;
long maxTime = Long.MIN_VALUE;
long minVersion = Long.MAX_VALUE;
long maxVersion = Long.MIN_VALUE;
- long maxInnerMergeCount = Long.MIN_VALUE;
- long maxCrossMergeCount = Long.MIN_VALUE;
+ int maxInnerMergeCount = Integer.MIN_VALUE;
+ int maxCrossMergeCount = Integer.MIN_VALUE;
for (TsFileResource resource : tsFileResources) {
- TsFileName tsFileName = getTsFileName(resource.getTsFile().getName());
- minTime = Math.min(tsFileName.time, minTime);
- maxTime = Math.max(tsFileName.time, maxTime);
- minVersion = Math.min(tsFileName.version, minVersion);
- maxVersion = Math.max(tsFileName.version, maxVersion);
- maxInnerMergeCount = Math.max(tsFileName.innerCompactionCnt,
maxInnerMergeCount);
- maxCrossMergeCount = Math.max(tsFileName.crossCompactionCnt,
maxCrossMergeCount);
+ TsFileName tsFileName = TsFileName.parse(resource.getTsFile().getName());
+ minTime = Math.min(tsFileName.getTime(), minTime);
+ maxTime = Math.max(tsFileName.getTime(), maxTime);
+ minVersion = Math.min(tsFileName.getVersion(), minVersion);
+ maxVersion = Math.max(tsFileName.getVersion(), maxVersion);
+ maxInnerMergeCount = Math.max(tsFileName.getInnerCompactionCnt(),
maxInnerMergeCount);
+ maxCrossMergeCount = Math.max(tsFileName.getCrossCompactionCnt(),
maxCrossMergeCount);
}
return sequence
? new TsFileResource(
new File(
tsFileResources.get(0).getTsFile().getParent(),
- minTime
- + FILE_NAME_SEPARATOR
- + minVersion
- + FILE_NAME_SEPARATOR
- + (maxInnerMergeCount + 1)
- + FILE_NAME_SEPARATOR
- + maxCrossMergeCount
- + IoTDBConstant.INNER_COMPACTION_TMP_FILE_SUFFIX))
+ TsFileName.getInnerTsFileName(
+ minTime, minVersion, (maxInnerMergeCount + 1),
maxCrossMergeCount)))
: new TsFileResource(
new File(
tsFileResources.get(0).getTsFile().getParent(),
- maxTime
- + FILE_NAME_SEPARATOR
- + maxVersion
- + FILE_NAME_SEPARATOR
- + (maxInnerMergeCount + 1)
- + FILE_NAME_SEPARATOR
- + maxCrossMergeCount
- + IoTDBConstant.INNER_COMPACTION_TMP_FILE_SUFFIX));
- }
-
- public static class TsFileName {
- private static final String FILE_NAME_PATTERN =
"(\\d+)-(\\d+)-(\\d+)-(\\d+).tsfile$";
- private static final Pattern FILE_NAME_MATCHER =
Pattern.compile(TsFileName.FILE_NAME_PATTERN);
-
- private long time;
- private long version;
- private int innerCompactionCnt;
- private int crossCompactionCnt;
-
- public TsFileName(long time, long version, int innerCompactionCnt, int
crossCompactionCnt) {
- this.time = time;
- this.version = version;
- this.innerCompactionCnt = innerCompactionCnt;
- this.crossCompactionCnt = crossCompactionCnt;
- }
-
- public long getTime() {
- return time;
- }
-
- public long getVersion() {
- return version;
- }
-
- public int getInnerCompactionCnt() {
- return innerCompactionCnt;
- }
-
- public int getCrossCompactionCnt() {
- return crossCompactionCnt;
- }
-
- public void setTime(long time) {
- this.time = time;
- }
-
- public void setVersion(long version) {
- this.version = version;
- }
-
- public void setInnerCompactionCnt(int innerCompactionCnt) {
- this.innerCompactionCnt = innerCompactionCnt;
- }
-
- public void setCrossCompactionCnt(int crossCompactionCnt) {
- this.crossCompactionCnt = crossCompactionCnt;
- }
+ TsFileName.getInnerTsFileName(
+ maxTime, maxVersion, (maxInnerMergeCount + 1),
maxCrossMergeCount)));
}
}
diff --git
a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileResource.java
b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileResource.java
index 1a5cc07f3d..57ec1458c6 100644
---
a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileResource.java
+++
b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileResource.java
@@ -26,7 +26,6 @@ import
org.apache.iotdb.db.engine.modification.ModificationFile;
import org.apache.iotdb.db.engine.querycontext.ReadOnlyMemChunk;
import org.apache.iotdb.db.engine.storagegroup.DataRegion.SettleTsFileCallBack;
import
org.apache.iotdb.db.engine.storagegroup.DataRegion.UpgradeTsFileResourceCallBack;
-import org.apache.iotdb.db.engine.storagegroup.TsFileNameGenerator.TsFileName;
import org.apache.iotdb.db.engine.storagegroup.timeindex.DeviceTimeIndex;
import org.apache.iotdb.db.engine.storagegroup.timeindex.FileTimeIndex;
import org.apache.iotdb.db.engine.storagegroup.timeindex.ITimeIndex;
@@ -42,7 +41,6 @@ import
org.apache.iotdb.tsfile.file.metadata.ITimeSeriesMetadata;
import org.apache.iotdb.tsfile.fileSystem.FSFactoryProducer;
import org.apache.iotdb.tsfile.fileSystem.fsFactory.FSFactory;
import org.apache.iotdb.tsfile.read.filter.basic.Filter;
-import org.apache.iotdb.tsfile.utils.FilePathUtils;
import org.apache.iotdb.tsfile.utils.ReadWriteIOUtils;
import org.slf4j.Logger;
@@ -63,10 +61,6 @@ import java.util.Objects;
import java.util.Random;
import java.util.Set;
-import static org.apache.iotdb.commons.conf.IoTDBConstant.FILE_NAME_SEPARATOR;
-import static
org.apache.iotdb.db.engine.storagegroup.TsFileNameGenerator.getTsFileName;
-import static
org.apache.iotdb.tsfile.common.constant.TsFileConstant.TSFILE_SUFFIX;
-
@SuppressWarnings("java:S1135") // ignore todos
public class TsFileResource {
@@ -127,6 +121,8 @@ public class TsFileResource {
/** Minimum index of plans executed within this TsFile. */
protected long minPlanIndex = Long.MAX_VALUE;
+ private long createdTime = 0;
+
private long version = 0;
private long ramSize;
@@ -158,6 +154,9 @@ public class TsFileResource {
public TsFileResource(TsFileResource other) throws IOException {
this.file = other.file;
+ TsFileName tsFileName = TsFileName.parse(this.file.getName());
+ this.createdTime = tsFileName.getTime();
+ this.version = tsFileName.getVersion();
this.processor = other.processor;
this.timeIndex = other.timeIndex;
this.timeIndexType = other.timeIndexType;
@@ -170,14 +169,15 @@ public class TsFileResource {
this.fsFactory = other.fsFactory;
this.maxPlanIndex = other.maxPlanIndex;
this.minPlanIndex = other.minPlanIndex;
- this.version = FilePathUtils.splitAndGetTsFileVersion(this.file.getName());
this.tsFileSize = other.tsFileSize;
}
/** for sealed TsFile, call setClosed to close TsFileResource */
public TsFileResource(File file) {
this.file = file;
- this.version = FilePathUtils.splitAndGetTsFileVersion(this.file.getName());
+ TsFileName tsFileName = TsFileName.parse(this.file.getName());
+ this.createdTime = tsFileName.getTime();
+ this.version = tsFileName.getVersion();
this.timeIndex = CONFIG.getTimeIndexLevel().getTimeIndex();
this.timeIndexType = (byte) CONFIG.getTimeIndexLevel().ordinal();
}
@@ -185,7 +185,9 @@ public class TsFileResource {
/** unsealed TsFile, for writter */
public TsFileResource(File file, TsFileProcessor processor) {
this.file = file;
- this.version = FilePathUtils.splitAndGetTsFileVersion(this.file.getName());
+ TsFileName tsFileName = TsFileName.parse(this.file.getName());
+ this.createdTime = tsFileName.getTime();
+ this.version = tsFileName.getVersion();
this.timeIndex = CONFIG.getTimeIndexLevel().getTimeIndex();
this.timeIndexType = (byte) CONFIG.getTimeIndexLevel().ordinal();
this.processor = processor;
@@ -199,12 +201,14 @@ public class TsFileResource {
TsFileResource originTsFileResource)
throws IOException {
this.file = originTsFileResource.file;
+ TsFileName tsFileName = TsFileName.parse(this.file.getName());
+ this.createdTime = tsFileName.getTime();
+ this.version = tsFileName.getVersion();
this.timeIndex = originTsFileResource.timeIndex;
this.timeIndexType = originTsFileResource.timeIndexType;
this.pathToReadOnlyMemChunkMap.put(path, readOnlyMemChunk);
this.pathToChunkMetadataListMap.put(path, chunkMetadataList);
this.originTsFileResource = originTsFileResource;
- this.version = originTsFileResource.version;
}
/** unsealed TsFile, for query */
@@ -214,21 +218,15 @@ public class TsFileResource {
TsFileResource originTsFileResource)
throws IOException {
this.file = originTsFileResource.file;
+ TsFileName tsFileName = TsFileName.parse(this.file.getName());
+ this.createdTime = tsFileName.getTime();
+ this.version = tsFileName.getVersion();
this.timeIndex = originTsFileResource.timeIndex;
this.timeIndexType = originTsFileResource.timeIndexType;
this.pathToReadOnlyMemChunkMap = pathToReadOnlyMemChunkMap;
this.pathToChunkMetadataListMap = pathToChunkMetadataListMap;
generatePathToTimeSeriesMetadataMap();
this.originTsFileResource = originTsFileResource;
- this.version = originTsFileResource.version;
- }
-
- @TestOnly
- public TsFileResource(
- File file, Map<String, Integer> deviceToIndex, long[] startTimes, long[]
endTimes) {
- this.file = file;
- this.timeIndex = new DeviceTimeIndex(deviceToIndex, startTimes, endTimes);
- this.timeIndexType = 1;
}
public synchronized void serialize() throws IOException {
@@ -537,10 +535,15 @@ public class TsFileResource {
}
void moveTo(File targetDir) {
+ // .tsfile file
fsFactory.moveFile(file, fsFactory.getFile(targetDir, file.getName()));
- fsFactory.moveFile(
- fsFactory.getFile(file.getPath() + RESOURCE_SUFFIX),
- fsFactory.getFile(targetDir, file.getName() + RESOURCE_SUFFIX));
+ // .resource file
+ File originResourceFile = fsFactory.getFile(file.getPath() +
RESOURCE_SUFFIX);
+ if (originResourceFile.exists()) {
+ fsFactory.moveFile(
+ originResourceFile, fsFactory.getFile(targetDir, file.getName() +
RESOURCE_SUFFIX));
+ }
+ // .mods file
File originModFile = fsFactory.getFile(file.getPath() +
ModificationFile.FILE_SUFFIX);
if (originModFile.exists()) {
fsFactory.moveFile(
@@ -549,6 +552,26 @@ public class TsFileResource {
}
}
+ void renameTo(String targetFileName) {
+ File dir = file.getParentFile();
+ // .tsfile file
+ File targetFile = fsFactory.getFile(dir, targetFileName);
+ fsFactory.renameTo(file, targetFile);
+ // .resource file
+ File originResourceFile = fsFactory.getFile(file.getPath() +
RESOURCE_SUFFIX);
+ if (originResourceFile.exists()) {
+ fsFactory.renameTo(
+ originResourceFile, fsFactory.getFile(dir, targetFileName +
RESOURCE_SUFFIX));
+ }
+ // .mods file
+ File originModFile = fsFactory.getFile(file.getPath() +
ModificationFile.FILE_SUFFIX);
+ if (originModFile.exists()) {
+ fsFactory.renameTo(
+ originModFile, fsFactory.getFile(dir, targetFileName +
ModificationFile.FILE_SUFFIX));
+ }
+ file = targetFile;
+ }
+
@Override
public String toString() {
return String.format("file is %s, status: ", file.toString(), status);
@@ -892,11 +915,6 @@ public class TsFileResource {
}
}
- public static int getInnerCompactionCount(String fileName) throws
IOException {
- TsFileName tsFileName = getTsFileName(fileName);
- return tsFileName.getInnerCompactionCnt();
- }
-
/** For merge, the index range of the new file should be the union of all
files' in this merge. */
public void updatePlanIndexes(TsFileResource another) {
maxPlanIndex = Math.max(maxPlanIndex, another.maxPlanIndex);
@@ -919,40 +937,28 @@ public class TsFileResource {
this.minPlanIndex = minPlanIndex;
}
+ public int compareTsFileName(TsFileResource other) {
+ return TsFileName.compareFileName(this, other);
+ }
+
+ /** This method will rename file name of this tsfile */
public void setVersion(long version) {
+ TsFileName tsFileName = TsFileName.parse(file.getName());
this.version = version;
+ tsFileName.setVersion(version);
+ renameTo(tsFileName.toFileName());
}
public long getVersion() {
return version;
}
- public void setTimeIndex(ITimeIndex timeIndex) {
- this.timeIndex = timeIndex;
+ public long getCreatedTime() {
+ return createdTime;
}
- // ({systemTime}-{versionNum}-{innerMergeNum}-{crossMergeNum}.tsfile)
- public static int compareFileName(TsFileResource o1, TsFileResource o2) {
- String[] items1 =
- o1.getTsFile().getName().replace(TSFILE_SUFFIX,
"").split(FILE_NAME_SEPARATOR);
- String[] items2 =
- o2.getTsFile().getName().replace(TSFILE_SUFFIX,
"").split(FILE_NAME_SEPARATOR);
- long ver1 = Long.parseLong(items1[0]);
- long ver2 = Long.parseLong(items2[0]);
- int cmp = Long.compare(ver1, ver2);
- if (cmp == 0) {
- int cmpVersion = Long.compare(Long.parseLong(items1[1]),
Long.parseLong(items2[1]));
- if (cmpVersion == 0) {
- int cmpInnerCompact = Long.compare(Long.parseLong(items1[2]),
Long.parseLong(items2[2]));
- if (cmpInnerCompact == 0) {
- return Long.compare(Long.parseLong(items1[3]),
Long.parseLong(items2[3]));
- }
- return cmpInnerCompact;
- }
- return cmpVersion;
- } else {
- return cmp;
- }
+ public void setTimeIndex(ITimeIndex timeIndex) {
+ this.timeIndex = timeIndex;
}
public void setSeq(boolean seq) {
diff --git
a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileResourceList.java
b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileResourceList.java
index 091d8f180e..6a57608257 100644
---
a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileResourceList.java
+++
b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileResourceList.java
@@ -25,19 +25,16 @@ import
org.apache.iotdb.tsfile.exception.NotImplementedException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
public class TsFileResourceList implements List<TsFileResource> {
private static final Logger LOGGER =
LoggerFactory.getLogger(TsFileResourceList.class);
private TsFileResource header;
private TsFileResource tail;
- private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private int count = 0;
/**
@@ -137,7 +134,7 @@ public class TsFileResourceList implements
List<TsFileResource> {
* timestamp is greater than its. If there is no tsfile whose timestamp is
greater than the new
* node's, the new node will be inserted to the tail of the list.
*/
- public boolean keepOrderInsert(TsFileResource newNode) throws IOException {
+ public boolean keepOrderInsert(TsFileResource newNode) {
if (newNode.prev != null || newNode.next != null || (count == 1 && header
== newNode)) {
// this node already in a list
return false;
@@ -149,16 +146,13 @@ public class TsFileResourceList implements
List<TsFileResource> {
} else {
// find the position to insert of this node
// the list should be ordered by file timestamp
- long timeOfNewNode =
-
TsFileNameGenerator.getTsFileName(newNode.getTsFile().getName()).getTime();
+ long timeOfNewNode = newNode.getCreatedTime();
- if
(TsFileNameGenerator.getTsFileName(header.getTsFile().getName()).getTime()
- > timeOfNewNode) {
+ if (header.getCreatedTime() > timeOfNewNode) {
// the timestamp of head node is greater than the new node
// insert it before the head
insertBefore(header, newNode);
- } else if
(TsFileNameGenerator.getTsFileName(tail.getTsFile().getName()).getTime()
- < timeOfNewNode) {
+ } else if (tail.getCreatedTime() < timeOfNewNode) {
// the timestamp of new node is greater than the tail node
// insert it after the tail
insertAfter(tail, newNode);
@@ -168,14 +162,12 @@ public class TsFileResourceList implements
List<TsFileResource> {
// and insert the new node before this node
TsFileResource currNode = header;
while (currNode.next != null) {
- if
(TsFileNameGenerator.getTsFileName(currNode.getTsFile().getName()).getTime()
- > timeOfNewNode) {
+ if (currNode.compareTsFileName(newNode) > 0) {
break;
}
currNode = currNode.next;
}
- if
(TsFileNameGenerator.getTsFileName(currNode.getTsFile().getName()).getTime()
- < timeOfNewNode) {
+ if (currNode.compareTsFileName(newNode) < 0) {
LOGGER.error("Cannot find an appropriate place to insert {}",
newNode);
} else {
insertBefore(currNode, newNode);
@@ -369,6 +361,20 @@ public class TsFileResourceList implements
List<TsFileResource> {
return list;
}
+ public List<TsFileResource> getFilesByTime(long targetTime) {
+ List<TsFileResource> list = new ArrayList<>();
+ TsFileResource current = header;
+ while (current != null) {
+ if (current.getCreatedTime() == targetTime) {
+ list.add(current);
+ } else if (!list.isEmpty()) {
+ break;
+ }
+ current = current.next;
+ }
+ return list;
+ }
+
private class TsFileIterator implements Iterator<TsFileResource> {
List<TsFileResource> tsFileResourceList;
int currentIndex = 0;
diff --git
a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/dataregion/StorageGroupManager.java
b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/dataregion/StorageGroupManager.java
index aa7f8c2c26..fb00ff401b 100644
---
a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/dataregion/StorageGroupManager.java
+++
b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/dataregion/StorageGroupManager.java
@@ -413,15 +413,6 @@ public class StorageGroupManager {
}
}
- /** push setPartitionVersionToMax operation down to all virtual storage
group processors */
- public void setPartitionVersionToMax(long partitionId, long newMaxVersion) {
- for (DataRegion dataRegion : this.dataRegion) {
- if (dataRegion != null) {
- dataRegion.setPartitionFileVersionToMax(partitionId, newMaxVersion);
- }
- }
- }
-
/** push removePartitions operation down to all virtual storage group
processors */
public void removePartitions(TimePartitionFilter filter) {
for (DataRegion dataRegion : this.dataRegion) {
diff --git
a/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/RewriteCompactionFileSelectorTest.java
b/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/RewriteCompactionFileSelectorTest.java
index 42ea9adacc..b550b32a8b 100644
---
a/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/RewriteCompactionFileSelectorTest.java
+++
b/server/src/test/java/org/apache/iotdb/db/engine/compaction/cross/RewriteCompactionFileSelectorTest.java
@@ -19,12 +19,12 @@
package org.apache.iotdb.db.engine.compaction.cross;
-import org.apache.iotdb.commons.conf.IoTDBConstant;
import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.constant.TestConstant;
import
org.apache.iotdb.db.engine.compaction.cross.rewrite.CrossSpaceCompactionResource;
import
org.apache.iotdb.db.engine.compaction.cross.rewrite.selector.ICrossSpaceMergeFileSelector;
import
org.apache.iotdb.db.engine.compaction.cross.rewrite.selector.RewriteCompactionFileSelector;
+import org.apache.iotdb.db.engine.storagegroup.TsFileName;
import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
import org.apache.iotdb.db.engine.storagegroup.TsFileResourceStatus;
import org.apache.iotdb.db.engine.storagegroup.timeindex.ITimeIndex;
@@ -58,7 +58,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
LoggerFactory.getLogger(RewriteCompactionFileSelectorTest.class);
@Test
- public void testFullSelection() throws MergeException, IOException {
+ public void testFullSelection() throws MergeException {
CrossSpaceCompactionResource resource =
new CrossSpaceCompactionResource(seqResources, unseqResources);
ICrossSpaceMergeFileSelector mergeFileSelector =
@@ -87,7 +87,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
}
@Test
- public void testWithFewMemoryBudgeSelection() throws MergeException,
IOException {
+ public void testWithFewMemoryBudgeSelection() throws MergeException {
CrossSpaceCompactionResource resource =
new CrossSpaceCompactionResource(seqResources, unseqResources);
ICrossSpaceMergeFileSelector mergeFileSelector = new
RewriteCompactionFileSelector(resource, 1);
@@ -96,7 +96,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
}
@Test
- public void testRestrictedSelection() throws MergeException, IOException {
+ public void testRestrictedSelection() throws MergeException {
CrossSpaceCompactionResource resource =
new CrossSpaceCompactionResource(seqResources, unseqResources);
ICrossSpaceMergeFileSelector mergeFileSelector =
@@ -109,9 +109,9 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
}
/**
- * test unseq merge select with the following files: {0seq-0-0-0.tsfile
0-100 1seq-1-1-0.tsfile
- * 100-200 2seq-2-2-0.tsfile 200-300 3seq-3-3-0.tsfile 300-400
4seq-4-4-0.tsfile 400-500}
- * {10unseq-10-10-0.tsfile 0-500}
+ * test unseq merge select with the following files: {seq/0-0-0-0.tsfile
0-100 seq/1-1-1-0.tsfile
+ * 100-200 seq/2-2-2-0.tsfile 200-300 seq/3-3-3-0.tsfile 300-400
seq/4-4-4-0.tsfile 400-500}
+ * {unseq/10-10-10-0.tsfile 0-500}
*/
@Test
public void testFileOpenSelection()
@@ -119,16 +119,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
IllegalAccessException {
File file =
new File(
- TestConstant.BASE_OUTPUT_PATH.concat(
- 10
- + "unseq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("unseq"),
TsFileName.getTsFileName(10, 10, 10, 0));
TsFileResource largeUnseqTsFileResource = new TsFileResource(file);
unseqResources.add(largeUnseqTsFileResource);
largeUnseqTsFileResource.setStatus(TsFileResourceStatus.CLOSED);
@@ -163,25 +154,16 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
}
/**
- * test unseq merge select with the following files: {0seq-0-0-0.tsfile
0-100 1seq-1-1-0.tsfile
- * 100-200 2seq-2-2-0.tsfile 200-300 3seq-3-3-0.tsfile 300-400
4seq-4-4-0.tsfile 400-500}
- * {10unseq-10-10-0.tsfile 0-500}
+ * test unseq merge select with the following files: {seq/0-0-0-0.tsfile
0-100 seq/1-1-1-0.tsfile
+ * 100-200 seq/2-2-2-0.tsfile 200-300 seq/3-3-3-0.tsfile 300-400
seq/4-4-4-0.tsfile 400-500}
+ * {unseq/10-10-10-0.tsfile 0-500}
*/
@Test
public void testFileOpenSelectionFromCompaction()
throws IOException, WriteProcessException, NoSuchFieldException,
IllegalAccessException {
File file =
new File(
- TestConstant.BASE_OUTPUT_PATH.concat(
- 10
- + "unseq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("unseq"),
TsFileName.getTsFileName(10, 10, 10, 0));
TsFileResource largeUnseqTsFileResource = new TsFileResource(file);
unseqResources.add(largeUnseqTsFileResource);
largeUnseqTsFileResource.setStatus(TsFileResourceStatus.CLOSED);
@@ -215,25 +197,16 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
}
/**
- * test unseq merge select with the following files: {0seq-0-0-0.tsfile
0-100 1seq-1-1-0.tsfile
- * 100-200 2seq-2-2-0.tsfile 200-300 3seq-3-3-0.tsfile 300-400
4seq-4-4-0.tsfile 400-500}
- * {10unseq-10-10-0.tsfile 0-101}
+ * test unseq merge select with the following files: {seq/0-0-0-0.tsfile
0-100 seq/1-1-1-0.tsfile
+ * 100-200 seq/2-2-2-0.tsfile 200-300 seq/3-3-3-0.tsfile 300-400
seq/4-4-4-0.tsfile 400-500}
+ * {unseq/10-10-10-0.tsfile 0-101}
*/
@Test
public void testFileSelectionAboutLastSeqFile()
throws MergeException, IOException, WriteProcessException {
File file =
new File(
- TestConstant.BASE_OUTPUT_PATH.concat(
- 10
- + "unseq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("unseq"),
TsFileName.getTsFileName(10, 10, 10, 0));
TsFileResource largeUnseqTsFileResource = new TsFileResource(file);
largeUnseqTsFileResource.setStatus(TsFileResourceStatus.CLOSED);
largeUnseqTsFileResource.setMinPlanIndex(10);
@@ -263,16 +236,8 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
for (int i = 0; i < seqFileNum; i++) {
File file =
new File(
- TestConstant.BASE_OUTPUT_PATH.concat(
- 10
- + "seq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + i
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("seq"),
+ TsFileName.getTsFileName(10, i, 10, 0));
TsFileResource fileResource = new TsFileResource(file);
fileResource.setStatus(TsFileResourceStatus.CLOSED);
prepareFile(fileResource, i, 1, 0);
@@ -283,16 +248,8 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
for (int i = 0; i < unseqFileNum; i++) {
File file =
new File(
- TestConstant.BASE_OUTPUT_PATH.concat(
- 10
- + "unseq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + i
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("unseq"),
+ TsFileName.getTsFileName(10, i, 10, 0));
TsFileResource fileResource = new TsFileResource(file);
fileResource.setStatus(TsFileResourceStatus.CLOSED);
unseqList.add(fileResource);
@@ -341,16 +298,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
for (int i = 11; i < seqFileNum + 11; i++) {
File file =
new File(
- TestConstant.OUTPUT_DATA_DIR.concat(
- 10
- + "seq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + i
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("seq"),
TsFileName.getTsFileName(10, i, 10, 0));
TsFileResource fileResource = new TsFileResource(file);
fileResource.setStatus(TsFileResourceStatus.CLOSED);
prepareFile(fileResource, i, 1, i);
@@ -361,16 +309,8 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
for (int i = 0; i < unseqFileNum; i++) {
File file =
new File(
- TestConstant.OUTPUT_DATA_DIR.concat(
- 10
- + "unseq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + i
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("unseq"),
+ TsFileName.getTsFileName(10, i, 10, 0));
TsFileResource fileResource = new TsFileResource(file);
fileResource.setStatus(TsFileResourceStatus.CLOSED);
prepareFile(fileResource, i, 1, i);
@@ -404,16 +344,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
for (int i = 11; i < seqFileNum + 11; i++) {
File file =
new File(
- TestConstant.OUTPUT_DATA_DIR.concat(
- 10
- + "seq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + i
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("seq"),
TsFileName.getTsFileName(10, i, 10, 0));
TsFileResource fileResource = new TsFileResource(file);
fileResource.setStatus(TsFileResourceStatus.CLOSED);
prepareFile(fileResource, i, 1, i);
@@ -424,16 +355,8 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
for (int i = 0; i < unseqFileNum; i++) {
File file =
new File(
- TestConstant.OUTPUT_DATA_DIR.concat(
- 10
- + "unseq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + i
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("unseq"),
+ TsFileName.getTsFileName(10, i, 10, 0));
TsFileResource fileResource = new TsFileResource(file);
fileResource.setStatus(TsFileResourceStatus.CLOSED);
prepareFile(fileResource, i, 10, i);
@@ -466,16 +389,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
for (int i = 11; i < seqFileNum + 11; i++) {
File file =
new File(
- TestConstant.OUTPUT_DATA_DIR.concat(
- 10
- + "seq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + i
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("seq"),
TsFileName.getTsFileName(10, i, 10, 0));
TsFileResource fileResource = new TsFileResource(file);
fileResource.setStatus(TsFileResourceStatus.CLOSED);
prepareFile(fileResource, i, 1, i);
@@ -486,16 +400,8 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
for (int i = 0; i < unseqFileNum; i++) {
File file =
new File(
- TestConstant.OUTPUT_DATA_DIR.concat(
- 10
- + "unseq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + i
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("unseq"),
+ TsFileName.getTsFileName(10, i, 10, 0));
TsFileResource fileResource = new TsFileResource(file);
fileResource.setStatus(TsFileResourceStatus.CLOSED);
unseqList.add(fileResource);
@@ -530,16 +436,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
for (int i = 11; i < seqFileNum + 11; i++) {
File file =
new File(
- TestConstant.OUTPUT_DATA_DIR.concat(
- 10
- + "seq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + i
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("seq"),
TsFileName.getTsFileName(10, i, 10, 0));
TsFileResource fileResource = new TsFileResource(file);
fileResource.setStatus(TsFileResourceStatus.CLOSED);
prepareFile(fileResource, i, 1, i);
@@ -550,16 +447,8 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
for (int i = 0; i < unseqFileNum; i++) {
File file =
new File(
- TestConstant.OUTPUT_DATA_DIR.concat(
- 10
- + "unseq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + i
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("unseq"),
+ TsFileName.getTsFileName(10, i, 10, 0));
TsFileResource fileResource = new TsFileResource(file);
fileResource.setStatus(TsFileResourceStatus.CLOSED);
unseqList.add(fileResource);
@@ -597,16 +486,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
for (int i = 11; i < seqFileNum + 11; i++) {
File file =
new File(
- TestConstant.OUTPUT_DATA_DIR.concat(
- 10
- + "seq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + i
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("seq"),
TsFileName.getTsFileName(10, i, 10, 0));
TsFileResource fileResource = new TsFileResource(file);
if (i - 11 != 3) {
fileResource.setStatus(TsFileResourceStatus.CLOSED);
@@ -619,16 +499,8 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
for (int i = 0; i < unseqFileNum; i++) {
File file =
new File(
- TestConstant.OUTPUT_DATA_DIR.concat(
- 10
- + "unseq"
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + i
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 10
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ TestConstant.BASE_OUTPUT_PATH.concat("unseq"),
+ TsFileName.getTsFileName(10, i, 10, 0));
TsFileResource fileResource = new TsFileResource(file);
fileResource.setStatus(TsFileResourceStatus.CLOSED);
unseqList.add(fileResource);
@@ -657,17 +529,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
// first file [0, 10]
// first device [0, 5]
// second device [0, 10]
- File firstFile =
- new File(
- TestConstant.OUTPUT_DATA_DIR.concat(
- 1
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 1
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ File firstFile = new File(TestConstant.OUTPUT_DATA_DIR,
TsFileName.getTsFileName(1, 1, 0, 0));
TsFileResource firstTsFileResource = new TsFileResource(firstFile);
firstTsFileResource.setStatus(TsFileResourceStatus.CLOSED);
firstTsFileResource.setMinPlanIndex(1);
@@ -710,17 +572,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
// second file time range: [11, 20]
// first measurement: [11, 20]
// second measurement: [11, 20]
- File secondFile =
- new File(
- TestConstant.OUTPUT_DATA_DIR.concat(
- 2
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 2
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ File secondFile = new File(TestConstant.OUTPUT_DATA_DIR,
TsFileName.getTsFileName(2, 2, 0, 0));
TsFileResource secondTsFileResource = new TsFileResource(secondFile);
secondTsFileResource.setStatus(TsFileResourceStatus.CLOSED);
secondTsFileResource.setMinPlanIndex(2);
@@ -756,17 +608,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
fileWriter.close();
// unseq file: [0, 1]
- File thirdFile =
- new File(
- TestConstant.OUTPUT_DATA_DIR.concat(
- 3
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 3
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ File thirdFile = new File(TestConstant.OUTPUT_DATA_DIR,
TsFileName.getTsFileName(3, 3, 0, 0));
TsFileResource thirdTsFileResource = new TsFileResource(thirdFile);
thirdTsFileResource.setStatus(TsFileResourceStatus.CLOSED);
thirdTsFileResource.setMinPlanIndex(3);
@@ -802,17 +644,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
fileWriter.close();
// unseq file: [6, 14]
- File fourthFile =
- new File(
- TestConstant.OUTPUT_DATA_DIR.concat(
- 4
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 4
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + IoTDBConstant.FILE_NAME_SEPARATOR
- + 0
- + ".tsfile"));
+ File fourthFile = new File(TestConstant.OUTPUT_DATA_DIR,
TsFileName.getTsFileName(4, 4, 0, 0));
TsFileResource fourthTsFileResource = new TsFileResource(fourthFile);
fourthTsFileResource.setStatus(TsFileResourceStatus.CLOSED);
fourthTsFileResource.setMinPlanIndex(4);
@@ -871,7 +703,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
}
@Test
- public void testMaxFileSelection() throws MergeException, IOException {
+ public void testMaxFileSelection() throws MergeException {
int oldMaxCrossCompactionCandidateFileNum =
IoTDBDescriptor.getInstance().getConfig().getMaxCrossCompactionCandidateFileNum();
IoTDBDescriptor.getInstance().getConfig().setMaxCrossCompactionCandidateFileNum(5);
@@ -892,7 +724,7 @@ public class RewriteCompactionFileSelectorTest extends
MergeTest {
}
@Test
- public void testAtLeastOneUnseqFileBeenSelected() throws IOException,
MergeException {
+ public void testAtLeastOneUnseqFileBeenSelected() throws MergeException {
int maxCrossFilesNum =
IoTDBDescriptor.getInstance().getConfig().getMaxCrossCompactionCandidateFileNum();
IoTDBDescriptor.getInstance().getConfig().setMaxCrossCompactionCandidateFileNum(1);
diff --git
a/server/src/test/java/org/apache/iotdb/db/engine/compaction/inner/ReadChunkCompactionPerformerNoAlignedTest.java
b/server/src/test/java/org/apache/iotdb/db/engine/compaction/inner/ReadChunkCompactionPerformerNoAlignedTest.java
index a88a6e57d5..8122587ea7 100644
---
a/server/src/test/java/org/apache/iotdb/db/engine/compaction/inner/ReadChunkCompactionPerformerNoAlignedTest.java
+++
b/server/src/test/java/org/apache/iotdb/db/engine/compaction/inner/ReadChunkCompactionPerformerNoAlignedTest.java
@@ -29,7 +29,7 @@ import
org.apache.iotdb.db.engine.compaction.performer.impl.ReadChunkCompactionP
import org.apache.iotdb.db.engine.compaction.utils.CompactionCheckerUtils;
import org.apache.iotdb.db.engine.compaction.utils.CompactionConfigRestorer;
import
org.apache.iotdb.db.engine.compaction.utils.CompactionFileGeneratorUtils;
-import org.apache.iotdb.db.engine.storagegroup.TsFileNameGenerator;
+import org.apache.iotdb.db.engine.storagegroup.TsFileName;
import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
import org.apache.iotdb.db.metadata.path.MeasurementPath;
import org.apache.iotdb.db.service.IoTDB;
@@ -189,8 +189,7 @@ public class ReadChunkCompactionPerformerNoAlignedTest {
}
Map<PartialPath, List<TimeValuePair>> originData =
CompactionCheckerUtils.getDataByQuery(paths, schemaList,
sourceFiles, new ArrayList<>());
- TsFileNameGenerator.TsFileName tsFileName =
-
TsFileNameGenerator.getTsFileName(sourceFiles.get(0).getTsFile().getName());
+ TsFileName tsFileName =
TsFileName.parse(sourceFiles.get(0).getTsFile().getName());
TsFileResource targetResource =
new TsFileResource(
new File(
@@ -279,8 +278,7 @@ public class ReadChunkCompactionPerformerNoAlignedTest {
Map<PartialPath, List<TimeValuePair>> originData =
CompactionCheckerUtils.getDataByQuery(paths, schemaList,
sourceFiles, new ArrayList<>());
- TsFileNameGenerator.TsFileName tsFileName =
-
TsFileNameGenerator.getTsFileName(sourceFiles.get(0).getTsFile().getName());
+ TsFileName tsFileName =
TsFileName.parse(sourceFiles.get(0).getTsFile().getName());
TsFileResource targetResource =
new TsFileResource(
new File(
@@ -371,8 +369,7 @@ public class ReadChunkCompactionPerformerNoAlignedTest {
Map<PartialPath, List<TimeValuePair>> originData =
CompactionCheckerUtils.getDataByQuery(paths, schemaList,
sourceFiles, new ArrayList<>());
- TsFileNameGenerator.TsFileName tsFileName =
-
TsFileNameGenerator.getTsFileName(sourceFiles.get(0).getTsFile().getName());
+ TsFileName tsFileName =
TsFileName.parse(sourceFiles.get(0).getTsFile().getName());
TsFileResource targetResource =
new TsFileResource(
new File(
@@ -450,8 +447,7 @@ public class ReadChunkCompactionPerformerNoAlignedTest {
}
Map<PartialPath, List<TimeValuePair>> originData =
CompactionCheckerUtils.getDataByQuery(paths, schemaList,
sourceFiles, new ArrayList<>());
- TsFileNameGenerator.TsFileName tsFileName =
-
TsFileNameGenerator.getTsFileName(sourceFiles.get(0).getTsFile().getName());
+ TsFileName tsFileName =
TsFileName.parse(sourceFiles.get(0).getTsFile().getName());
TsFileResource targetResource =
new TsFileResource(
new File(
@@ -559,8 +555,7 @@ public class ReadChunkCompactionPerformerNoAlignedTest {
Map<PartialPath, List<TimeValuePair>> originData =
CompactionCheckerUtils.getDataByQuery(paths, schemaList,
sourceFiles, new ArrayList<>());
- TsFileNameGenerator.TsFileName tsFileName =
-
TsFileNameGenerator.getTsFileName(sourceFiles.get(0).getTsFile().getName());
+ TsFileName tsFileName =
TsFileName.parse(sourceFiles.get(0).getTsFile().getName());
TsFileResource targetResource =
new TsFileResource(
new File(
@@ -638,8 +633,7 @@ public class ReadChunkCompactionPerformerNoAlignedTest {
}
Map<PartialPath, List<TimeValuePair>> originData =
CompactionCheckerUtils.getDataByQuery(paths, schemaList,
sourceFiles, new ArrayList<>());
- TsFileNameGenerator.TsFileName tsFileName =
-
TsFileNameGenerator.getTsFileName(sourceFiles.get(0).getTsFile().getName());
+ TsFileName tsFileName =
TsFileName.parse(sourceFiles.get(0).getTsFile().getName());
TsFileResource targetResource =
new TsFileResource(
new File(
@@ -720,8 +714,7 @@ public class ReadChunkCompactionPerformerNoAlignedTest {
}
Map<PartialPath, List<TimeValuePair>> originData =
CompactionCheckerUtils.getDataByQuery(paths, schemaList,
sourceFiles, new ArrayList<>());
- TsFileNameGenerator.TsFileName tsFileName =
-
TsFileNameGenerator.getTsFileName(sourceFiles.get(0).getTsFile().getName());
+ TsFileName tsFileName =
TsFileName.parse(sourceFiles.get(0).getTsFile().getName());
TsFileResource targetResource =
new TsFileResource(
new File(
@@ -796,8 +789,7 @@ public class ReadChunkCompactionPerformerNoAlignedTest {
Map<PartialPath, List<TimeValuePair>> originData =
CompactionCheckerUtils.getDataByQuery(paths, schemaList,
sourceFiles, new ArrayList<>());
- TsFileNameGenerator.TsFileName tsFileName =
-
TsFileNameGenerator.getTsFileName(sourceFiles.get(0).getTsFile().getName());
+ TsFileName tsFileName =
TsFileName.parse(sourceFiles.get(0).getTsFile().getName());
TsFileResource targetResource =
new TsFileResource(
new File(
@@ -874,8 +866,7 @@ public class ReadChunkCompactionPerformerNoAlignedTest {
Map<PartialPath, List<TimeValuePair>> originData =
CompactionCheckerUtils.getDataByQuery(paths, schemaList,
sourceFiles, new ArrayList<>());
- TsFileNameGenerator.TsFileName tsFileName =
-
TsFileNameGenerator.getTsFileName(sourceFiles.get(0).getTsFile().getName());
+ TsFileName tsFileName =
TsFileName.parse(sourceFiles.get(0).getTsFile().getName());
TsFileResource targetResource =
new TsFileResource(
new File(
diff --git
a/server/src/test/java/org/apache/iotdb/db/engine/compaction/utils/CompactionFileGeneratorUtils.java
b/server/src/test/java/org/apache/iotdb/db/engine/compaction/utils/CompactionFileGeneratorUtils.java
index ad23d081d2..af4e094db1 100644
---
a/server/src/test/java/org/apache/iotdb/db/engine/compaction/utils/CompactionFileGeneratorUtils.java
+++
b/server/src/test/java/org/apache/iotdb/db/engine/compaction/utils/CompactionFileGeneratorUtils.java
@@ -25,8 +25,8 @@ import org.apache.iotdb.commons.path.PartialPath;
import org.apache.iotdb.db.constant.TestConstant;
import org.apache.iotdb.db.engine.modification.Deletion;
import org.apache.iotdb.db.engine.modification.ModificationFile;
+import org.apache.iotdb.db.engine.storagegroup.TsFileName;
import org.apache.iotdb.db.engine.storagegroup.TsFileNameGenerator;
-import org.apache.iotdb.db.engine.storagegroup.TsFileNameGenerator.TsFileName;
import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
import org.apache.iotdb.tsfile.common.conf.TSFileDescriptor;
import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
@@ -47,8 +47,8 @@ import java.util.Set;
public class CompactionFileGeneratorUtils {
public static TsFileResource getTargetTsFileResourceFromSourceResource(
- TsFileResource sourceResource) throws IOException {
- TsFileName tsFileName =
TsFileNameGenerator.getTsFileName(sourceResource.getTsFile().getName());
+ TsFileResource sourceResource) {
+ TsFileName tsFileName =
TsFileName.parse(sourceResource.getTsFile().getName());
return new TsFileResource(
new File(
TestConstant.BASE_OUTPUT_PATH.concat(
diff --git
a/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/TsFileManagerTest.java
b/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/TsFileManagerTest.java
index b7971c5174..eb3fd88de2 100644
---
a/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/TsFileManagerTest.java
+++
b/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/TsFileManagerTest.java
@@ -44,42 +44,54 @@ public class TsFileManagerTest {
File tempSGDir;
private TsFileManager tsFileManager;
- private List<TsFileResource> seqResources;
- private List<TsFileResource> unseqResources;
@Before
public void setUp() throws IOException, WriteProcessException,
MetadataException {
- tempSGDir = new File(TestConstant.BASE_OUTPUT_PATH.concat("tempSG"));
+ tempSGDir =
+ new File(
+ TestConstant.BASE_OUTPUT_PATH
+ .concat("tempSG")
+ .concat(File.separator)
+ .concat("0") // vsg
+ .concat(File.separator)
+ .concat("0")); // time partition
tempSGDir.mkdirs();
tsFileManager = new TsFileManager("test", "0",
tempSGDir.getAbsolutePath());
- seqResources = new ArrayList<>();
- for (int i = 0; i < 5; i++) {
- TsFileResource resource = generateTsFileResource(i);
- seqResources.add(resource);
- }
- unseqResources = new ArrayList<>();
- for (int i = 6; i < 10; i++) {
- TsFileResource resource = generateTsFileResource(i);
- unseqResources.add(resource);
- }
}
@After
public void tearDown() throws IOException, StorageEngineException {
- FileUtils.deleteDirectory(tempSGDir);
+ FileUtils.deleteDirectory(new File(TestConstant.BASE_OUTPUT_PATH));
}
private TsFileResource generateTsFileResource(int id) {
+ File file =
+ new
File(TsFileNameGenerator.generateNewTsFilePath(tempSGDir.getPath(), id, id, id,
id));
+ return new TsFileResource(file);
+ }
+
+ private TsFileResource generateTsFileResource(long time, long version)
throws IOException {
File file =
new File(
TsFileNameGenerator.generateNewTsFilePath(
- TestConstant.BASE_OUTPUT_PATH, id, id, id, id));
+ TestConstant.BASE_OUTPUT_PATH, time, version, 0, 0));
+ file.createNewFile();
return new TsFileResource(file);
}
/** just compaction once */
@Test
public void testAddRemoveAndIterator() {
+ List<TsFileResource> seqResources = new ArrayList<>();
+ for (int i = 0; i < 5; i++) {
+ TsFileResource resource = generateTsFileResource(i);
+ seqResources.add(resource);
+ }
+ List<TsFileResource> unseqResources = new ArrayList<>();
+ for (int i = 6; i < 10; i++) {
+ TsFileResource resource = generateTsFileResource(i);
+ unseqResources.add(resource);
+ }
for (TsFileResource tsFileResource : seqResources) {
tsFileManager.add(tsFileResource, true);
}
@@ -174,6 +186,11 @@ public class TsFileManagerTest {
@Test
public void testIteratorRemove() {
+ List<TsFileResource> seqResources = new ArrayList<>();
+ for (int i = 0; i < 5; i++) {
+ TsFileResource resource = generateTsFileResource(i);
+ seqResources.add(resource);
+ }
for (TsFileResource tsFileResource : seqResources) {
tsFileManager.add(tsFileResource, true);
}
@@ -237,4 +254,257 @@ public class TsFileManagerTest {
}
assertEquals(8, count);
}
+
+ /**
+ * seq: [1-0-0-0, 2-0-0-0, 6-0-0-0, 6-2-0-0, 10-0-0-0] unseq: [1-1-0-0,
4-0-0-0, 6-1-0-0, 8-0-0-0,
+ * 9-0-0-0] add 2 files with time=6 after seq/6-0-0-0
+ */
+ @Test
+ public void testKeepOrderAddAllAndRenameAfter01() throws IOException {
+ List<TsFileResource> seqResources = new ArrayList<>();
+ seqResources.add(generateTsFileResource(1, 0));
+ seqResources.add(generateTsFileResource(2, 0));
+ seqResources.add(generateTsFileResource(6, 0));
+ seqResources.add(generateTsFileResource(6, 2));
+ seqResources.add(generateTsFileResource(10, 0));
+ tsFileManager.addAll(seqResources, true);
+ List<TsFileResource> unseqResources = new ArrayList<>();
+ unseqResources.add(generateTsFileResource(1, 1));
+ unseqResources.add(generateTsFileResource(4, 0));
+ unseqResources.add(generateTsFileResource(6, 1));
+ unseqResources.add(generateTsFileResource(8, 0));
+ unseqResources.add(generateTsFileResource(9, 0));
+ tsFileManager.addAll(unseqResources, false);
+
+ List<TsFileResource> filesToAdd = new ArrayList<>();
+ filesToAdd.add(generateTsFileResource(6, 0));
+ filesToAdd.add(generateTsFileResource(6, 1));
+ tsFileManager.keepOrderAddAllAndRenameAfter(seqResources.get(2),
filesToAdd, true, 0);
+
+ List<TsFileResource> expect = new ArrayList<>();
+ expect.add(seqResources.get(2));
+ expect.addAll(filesToAdd);
+ expect.add(unseqResources.get(2));
+ expect.add(seqResources.get(3));
+ expect.addAll(filesToAdd);
+ List<TsFileResource> result = new ArrayList<>();
+ TsFileResourceList seqList =
tsFileManager.getSequenceListByTimePartition(0);
+ TsFileResourceList unseqList =
tsFileManager.getUnsequenceListByTimePartition(0);
+ result.add(seqList.get(2));
+ result.add(seqList.get(3));
+ result.add(seqList.get(4));
+ result.add(unseqList.get(2));
+ result.add(seqList.get(5));
+ for (int i = 0; i < result.size(); i++) {
+ assertEquals(expect.get(i), result.get(i));
+ assertEquals(6, result.get(i).getCreatedTime());
+ assertEquals(i, result.get(i).getVersion());
+ }
+ }
+
+ /**
+ * seq: [1-0-0-0, 2-0-0-0, 6-0-0-0, 6-2-0-0, 10-0-0-0] unseq: [1-1-0-0,
4-0-0-0, 6-1-0-0, 8-0-0-0,
+ * 9-0-0-0] add 2 files with time=1 before unseq/1-1-0-0
+ */
+ @Test
+ public void testKeepOrderAddAllAndRenameAfter02() throws IOException {
+ List<TsFileResource> seqResources = new ArrayList<>();
+ seqResources.add(generateTsFileResource(1, 0));
+ seqResources.add(generateTsFileResource(2, 0));
+ seqResources.add(generateTsFileResource(6, 0));
+ seqResources.add(generateTsFileResource(6, 2));
+ seqResources.add(generateTsFileResource(10, 0));
+ tsFileManager.addAll(seqResources, true);
+ List<TsFileResource> unseqResources = new ArrayList<>();
+ unseqResources.add(generateTsFileResource(1, 1));
+ unseqResources.add(generateTsFileResource(4, 0));
+ unseqResources.add(generateTsFileResource(6, 1));
+ unseqResources.add(generateTsFileResource(8, 0));
+ unseqResources.add(generateTsFileResource(9, 0));
+ tsFileManager.addAll(unseqResources, false);
+
+ List<TsFileResource> filesToAdd = new ArrayList<>();
+ filesToAdd.add(generateTsFileResource(1, 0));
+ filesToAdd.add(generateTsFileResource(1, 1));
+ tsFileManager.keepOrderAddAllAndRenameAfter(unseqResources.get(0),
filesToAdd, false, 0);
+
+ List<TsFileResource> expect = new ArrayList<>();
+ expect.add(seqResources.get(0));
+ expect.add(unseqResources.get(0));
+ expect.addAll(filesToAdd);
+ List<TsFileResource> result = new ArrayList<>();
+ TsFileResourceList seqList =
tsFileManager.getSequenceListByTimePartition(0);
+ TsFileResourceList unseqList =
tsFileManager.getUnsequenceListByTimePartition(0);
+ result.add(seqList.get(0));
+ result.add(unseqList.get(0));
+ result.add(unseqList.get(1));
+ result.add(unseqList.get(2));
+ for (int i = 0; i < result.size(); i++) {
+ assertEquals(expect.get(i), result.get(i));
+ assertEquals(1, result.get(i).getCreatedTime());
+ assertEquals(i, result.get(i).getVersion());
+ }
+ }
+
+ /**
+ * seq: [1-0-0-0, 2-0-0-0, 6-0-0-0, 6-2-0-0, 10-0-0-0] unseq: [1-1-0-0,
4-0-0-0, 6-1-0-0, 8-0-0-0,
+ * 9-0-0-0] add 2 files with time=10 after seq/10-0-0-0
+ */
+ @Test
+ public void testKeepOrderAddAllAndRenameAfter03() throws IOException {
+ List<TsFileResource> seqResources = new ArrayList<>();
+ seqResources.add(generateTsFileResource(1, 0));
+ seqResources.add(generateTsFileResource(2, 0));
+ seqResources.add(generateTsFileResource(6, 0));
+ seqResources.add(generateTsFileResource(6, 2));
+ seqResources.add(generateTsFileResource(10, 0));
+ tsFileManager.addAll(seqResources, true);
+ List<TsFileResource> unseqResources = new ArrayList<>();
+ unseqResources.add(generateTsFileResource(1, 1));
+ unseqResources.add(generateTsFileResource(4, 0));
+ unseqResources.add(generateTsFileResource(6, 1));
+ unseqResources.add(generateTsFileResource(8, 0));
+ unseqResources.add(generateTsFileResource(9, 0));
+ tsFileManager.addAll(unseqResources, false);
+
+ List<TsFileResource> filesToAdd = new ArrayList<>();
+ filesToAdd.add(generateTsFileResource(10, 0));
+ filesToAdd.add(generateTsFileResource(10, 1));
+ tsFileManager.keepOrderAddAllAndRenameAfter(seqResources.get(4),
filesToAdd, true, 0);
+
+ List<TsFileResource> expect = new ArrayList<>();
+ expect.add(seqResources.get(4));
+ expect.addAll(filesToAdd);
+ List<TsFileResource> result = new ArrayList<>();
+ TsFileResourceList seqList =
tsFileManager.getSequenceListByTimePartition(0);
+ result.add(seqList.get(4));
+ result.add(seqList.get(5));
+ result.add(seqList.get(6));
+ for (int i = 0; i < result.size(); i++) {
+ assertEquals(expect.get(i), result.get(i));
+ assertEquals(10, result.get(i).getCreatedTime());
+ assertEquals(i, result.get(i).getVersion());
+ }
+ }
+
+ /**
+ * seq: [1-0-0-0, 2-0-0-0, 6-0-0-0, 6-1-0-0, 10-0-0-0] unseq: [] add 2 files
with time=6 to unseq
+ */
+ @Test
+ public void testKeepOrderAddAllAndRenameAfter04() throws IOException {
+ List<TsFileResource> seqResources = new ArrayList<>();
+ seqResources.add(generateTsFileResource(1, 0));
+ seqResources.add(generateTsFileResource(2, 0));
+ seqResources.add(generateTsFileResource(6, 0));
+ seqResources.add(generateTsFileResource(6, 1));
+ seqResources.add(generateTsFileResource(10, 0));
+ tsFileManager.addAll(seqResources, true);
+
+ List<TsFileResource> filesToAdd = new ArrayList<>();
+ filesToAdd.add(generateTsFileResource(6, 0));
+ filesToAdd.add(generateTsFileResource(6, 1));
+ tsFileManager.keepOrderAddAllAndRenameAfter(null, filesToAdd, false, 0);
+
+ List<TsFileResource> expect = new ArrayList<>();
+ expect.add(seqResources.get(2));
+ expect.add(seqResources.get(3));
+ expect.addAll(filesToAdd);
+ List<TsFileResource> result = new ArrayList<>();
+ TsFileResourceList seqList =
tsFileManager.getSequenceListByTimePartition(0);
+ TsFileResourceList unseqList =
tsFileManager.getUnsequenceListByTimePartition(0);
+ result.add(seqList.get(2));
+ result.add(seqList.get(3));
+ result.add(unseqList.get(0));
+ result.add(unseqList.get(1));
+ for (int i = 0; i < result.size(); i++) {
+ assertEquals(expect.get(i), result.get(i));
+ assertEquals(6, result.get(i).getCreatedTime());
+ assertEquals(i, result.get(i).getVersion());
+ }
+ }
+
+ /**
+ * seq: [1-0-0-0, 2-0-0-0, 6-0-0-0, 6-2-0-0, 10-0-0-0] unseq: [1-1-0-0,
4-0-0-0, 6-1-0-0, 8-0-0-0,
+ * 9-0-0-0] add 2 files with time=6 after seq/2-0-0-0
+ */
+ @Test
+ public void testKeepOrderAddAllAndRenameAfter05() throws IOException {
+ List<TsFileResource> seqResources = new ArrayList<>();
+ seqResources.add(generateTsFileResource(1, 0));
+ seqResources.add(generateTsFileResource(2, 0));
+ seqResources.add(generateTsFileResource(6, 0));
+ seqResources.add(generateTsFileResource(6, 2));
+ seqResources.add(generateTsFileResource(10, 0));
+ tsFileManager.addAll(seqResources, true);
+ List<TsFileResource> unseqResources = new ArrayList<>();
+ unseqResources.add(generateTsFileResource(1, 1));
+ unseqResources.add(generateTsFileResource(4, 0));
+ unseqResources.add(generateTsFileResource(6, 1));
+ unseqResources.add(generateTsFileResource(8, 0));
+ unseqResources.add(generateTsFileResource(9, 0));
+ tsFileManager.addAll(unseqResources, false);
+
+ List<TsFileResource> filesToAdd = new ArrayList<>();
+ filesToAdd.add(generateTsFileResource(6, 0));
+ filesToAdd.add(generateTsFileResource(6, 1));
+ tsFileManager.keepOrderAddAllAndRenameAfter(seqResources.get(1),
filesToAdd, true, 0);
+
+ List<TsFileResource> expect = new ArrayList<>();
+ expect.addAll(filesToAdd);
+ expect.add(seqResources.get(2));
+ expect.add(unseqResources.get(2));
+ expect.add(seqResources.get(3));
+ List<TsFileResource> result = new ArrayList<>();
+ TsFileResourceList seqList =
tsFileManager.getSequenceListByTimePartition(0);
+ TsFileResourceList unseqList =
tsFileManager.getUnsequenceListByTimePartition(0);
+ result.add(seqList.get(2));
+ result.add(seqList.get(3));
+ result.add(seqList.get(4));
+ result.add(unseqList.get(2));
+ result.add(seqList.get(5));
+ for (int i = 0; i < result.size(); i++) {
+ assertEquals(expect.get(i), result.get(i));
+ assertEquals(6, result.get(i).getCreatedTime());
+ assertEquals(i, result.get(i).getVersion());
+ }
+ }
+
+ /**
+ * seq: [1-0-0-0, 2-0-0-0, 6-0-0-0, 6-2-0-0, 10-0-0-0] unseq: [1-1-0-0,
4-0-0-0, 6-1-0-0, 8-0-0-0,
+ * 9-0-0-0] add 2 files with time=5 after seq/2-0-0-0
+ */
+ @Test
+ public void testKeepOrderAddAllAndRenameAfter06() throws IOException {
+ List<TsFileResource> seqResources = new ArrayList<>();
+ seqResources.add(generateTsFileResource(1, 0));
+ seqResources.add(generateTsFileResource(2, 0));
+ seqResources.add(generateTsFileResource(6, 0));
+ seqResources.add(generateTsFileResource(6, 2));
+ seqResources.add(generateTsFileResource(10, 0));
+ tsFileManager.addAll(seqResources, true);
+ List<TsFileResource> unseqResources = new ArrayList<>();
+ unseqResources.add(generateTsFileResource(1, 1));
+ unseqResources.add(generateTsFileResource(4, 0));
+ unseqResources.add(generateTsFileResource(6, 1));
+ unseqResources.add(generateTsFileResource(8, 0));
+ unseqResources.add(generateTsFileResource(9, 0));
+ tsFileManager.addAll(unseqResources, false);
+
+ List<TsFileResource> filesToAdd = new ArrayList<>();
+ filesToAdd.add(generateTsFileResource(5, 0));
+ filesToAdd.add(generateTsFileResource(5, 1));
+ tsFileManager.keepOrderAddAllAndRenameAfter(seqResources.get(1),
filesToAdd, true, 0);
+
+ List<TsFileResource> expect = new ArrayList<>();
+ expect.addAll(filesToAdd);
+ List<TsFileResource> result = new ArrayList<>();
+ TsFileResourceList seqList =
tsFileManager.getSequenceListByTimePartition(0);
+ result.add(seqList.get(2));
+ result.add(seqList.get(3));
+ for (int i = 0; i < result.size(); i++) {
+ assertEquals(expect.get(i), result.get(i));
+ assertEquals(5, result.get(i).getCreatedTime());
+ assertEquals(i, result.get(i).getVersion());
+ }
+ }
}
diff --git
a/tsfile/src/main/java/org/apache/iotdb/tsfile/fileSystem/fsFactory/FSFactory.java
b/tsfile/src/main/java/org/apache/iotdb/tsfile/fileSystem/fsFactory/FSFactory.java
index 804e880090..f8ab622854 100644
---
a/tsfile/src/main/java/org/apache/iotdb/tsfile/fileSystem/fsFactory/FSFactory.java
+++
b/tsfile/src/main/java/org/apache/iotdb/tsfile/fileSystem/fsFactory/FSFactory.java
@@ -112,6 +112,14 @@ public interface FSFactory {
*/
void moveFile(File srcFile, File destFile);
+ /**
+ * rename file
+ *
+ * @param srcFile src file
+ * @param destFile dest file
+ */
+ void renameTo(File srcFile, File destFile);
+
/**
* list file by suffix
*
diff --git
a/tsfile/src/main/java/org/apache/iotdb/tsfile/fileSystem/fsFactory/HDFSFactory.java
b/tsfile/src/main/java/org/apache/iotdb/tsfile/fileSystem/fsFactory/HDFSFactory.java
index b1197bffa1..c3cafc5946 100644
---
a/tsfile/src/main/java/org/apache/iotdb/tsfile/fileSystem/fsFactory/HDFSFactory.java
+++
b/tsfile/src/main/java/org/apache/iotdb/tsfile/fileSystem/fsFactory/HDFSFactory.java
@@ -188,6 +188,11 @@ public class HDFSFactory implements FSFactory {
@Override
public void moveFile(File srcFile, File destFile) {
+ renameTo(srcFile, destFile);
+ }
+
+ @Override
+ public void renameTo(File srcFile, File destFile) {
try {
renameTo.invoke(constructorWithPathname.newInstance(srcFile.getAbsolutePath()),
destFile);
} catch (InstantiationException | InvocationTargetException |
IllegalAccessException e) {
diff --git
a/tsfile/src/main/java/org/apache/iotdb/tsfile/fileSystem/fsFactory/LocalFSFactory.java
b/tsfile/src/main/java/org/apache/iotdb/tsfile/fileSystem/fsFactory/LocalFSFactory.java
index 365ded1b9d..93ae187d92 100644
---
a/tsfile/src/main/java/org/apache/iotdb/tsfile/fileSystem/fsFactory/LocalFSFactory.java
+++
b/tsfile/src/main/java/org/apache/iotdb/tsfile/fileSystem/fsFactory/LocalFSFactory.java
@@ -123,6 +123,17 @@ public class LocalFSFactory implements FSFactory {
}
}
+ @Override
+ public void renameTo(File srcFile, File destFile) {
+ boolean success = srcFile.renameTo(destFile);
+ if (!success) {
+ logger.error(
+ "Failed to rename file from {} to {}. ",
+ srcFile.getAbsolutePath(),
+ destFile.getAbsolutePath());
+ }
+ }
+
@Override
public File[] listFilesBySuffix(String fileFolder, String suffix) {
return new File(fileFolder).listFiles(file ->
file.getName().endsWith(suffix));
diff --git
a/tsfile/src/main/java/org/apache/iotdb/tsfile/utils/TsFileUtils.java
b/tsfile/src/main/java/org/apache/iotdb/tsfile/utils/TsFileUtils.java
index 03ba354c82..7953cd893b 100644
--- a/tsfile/src/main/java/org/apache/iotdb/tsfile/utils/TsFileUtils.java
+++ b/tsfile/src/main/java/org/apache/iotdb/tsfile/utils/TsFileUtils.java
@@ -23,6 +23,7 @@ import java.io.File;
import java.io.IOException;
public class TsFileUtils {
+ private TsFileUtils() {}
/**
* decides whether a TsFile is complete (the head magic and tail magic
string exists.)
diff --git a/tsfile/src/test/java/org/apache/iotdb/tsfile/write/PerfTest.java
b/tsfile/src/test/java/org/apache/iotdb/tsfile/write/PerfTest.java
index 65fa8d6e3a..c70e38ce74 100755
--- a/tsfile/src/test/java/org/apache/iotdb/tsfile/write/PerfTest.java
+++ b/tsfile/src/test/java/org/apache/iotdb/tsfile/write/PerfTest.java
@@ -114,7 +114,7 @@ public class PerfTest {
}
}
- private static void write() throws IOException, InterruptedException {
+ private static void write() throws IOException {
File file = new File(outputDataFile);
File errorFile = new File(errorOutputDataFile);
if (file.exists()) {
@@ -148,8 +148,7 @@ public class PerfTest {
}
}
- private static void writeToFile(Schema schema)
- throws InterruptedException, IOException, WriteProcessException {
+ private static void writeToFile(Schema schema) throws IOException,
WriteProcessException {
Scanner in = getDataFile(inputDataFile);
assert in != null;
while (in.hasNextLine()) {
@@ -228,7 +227,7 @@ public class PerfTest {
}
@Test
- public void writeTest() throws IOException, InterruptedException,
WriteProcessException {
+ public void writeTest() throws IOException {
write();
}
}
