You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by ja...@apache.org on 2024/09/10 11:02:46 UTC
(iotdb) branch KeepAllNullRows created (now 256965b2540)
This is an automated email from the ASF dual-hosted git repository.
jackietien pushed a change to branch KeepAllNullRows
in repository https://gitbox.apache.org/repos/asf/iotdb.git
at 256965b2540 init
This branch includes the following new commits:
new 256965b2540 init
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
(iotdb) 01/01: init
Posted by ja...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
jackietien pushed a commit to branch KeepAllNullRows
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit 256965b2540a36e4d9b08d8ecdf539b851001389
Author: JackieTien97 <ja...@gmail.com>
AuthorDate: Tue Sep 10 19:02:32 2024 +0800
init
---
data.zip | Bin 101329 -> 0 bytes
.../execution/fragment/QueryContext.java | 12 ++
.../operator/source/AlignedSeriesScanOperator.java | 3 +-
.../operator/source/AlignedSeriesScanUtil.java | 24 ++-
.../execution/operator/source/FileLoaderUtils.java | 145 ++++++++++++-----
.../source/relational/TableScanOperator.java | 3 +-
.../plan/analyze/LoadTsFileAnalyzer.java | 2 +-
.../plan/planner/LocalExecutionPlanner.java | 2 +
.../schemaregion/utils/ResourceByPathUtils.java | 60 +++++--
.../memtable/AlignedReadOnlyMemChunk.java | 7 +-
.../read/reader/chunk/DiskAlignedChunkLoader.java | 13 +-
.../metadata/DiskAlignedChunkMetadataLoader.java | 30 +++-
.../metadata/MemAlignedChunkMetadataLoader.java | 10 +-
.../apache/iotdb/db/utils/ModificationUtils.java | 175 +++++++++++++++------
.../db/utils/datastructure/AlignedTVList.java | 5 +-
.../MemAlignedChunkMetadataLoaderTest.java | 2 +-
pom.xml | 2 +-
17 files changed, 364 insertions(+), 131 deletions(-)
diff --git a/data.zip b/data.zip
deleted file mode 100644
index 331d31fd2dc..00000000000
Binary files a/data.zip and /dev/null differ
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/fragment/QueryContext.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/fragment/QueryContext.java
index 74563d0da64..089150624ce 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/fragment/QueryContext.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/fragment/QueryContext.java
@@ -61,6 +61,10 @@ public class QueryContext {
private volatile boolean isInterrupted = false;
+ // for table model, it will be false
+ // for tree model, it will be true
+ private boolean ignoreAllNullRows = true;
+
private final Set<TsFileID> nonExistentModFiles = new CopyOnWriteArraySet<>();
public QueryContext() {}
@@ -183,4 +187,12 @@ public class QueryContext {
public void setQueryStatistics(QueryStatistics queryStatistics) {
this.queryStatistics = queryStatistics;
}
+
+ public boolean isIgnoreAllNullRows() {
+ return ignoreAllNullRows;
+ }
+
+ public void setIgnoreAllNullRows(boolean ignoreAllNullRows) {
+ this.ignoreAllNullRows = ignoreAllNullRows;
+ }
}
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AlignedSeriesScanOperator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AlignedSeriesScanOperator.java
index 1fc8014b3ea..51fe0b0e952 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AlignedSeriesScanOperator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AlignedSeriesScanOperator.java
@@ -64,7 +64,8 @@ public class AlignedSeriesScanOperator extends AbstractSeriesScanOperator {
seriesScanOptions,
context.getInstanceContext(),
queryAllSensors,
- dataTypes);
+ dataTypes,
+ true);
this.valueColumnCount = seriesPath.getColumnNum();
this.maxReturnSize =
Math.min(
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AlignedSeriesScanUtil.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AlignedSeriesScanUtil.java
index 59116a0371a..6dff940b800 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AlignedSeriesScanUtil.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/AlignedSeriesScanUtil.java
@@ -30,7 +30,7 @@ import org.apache.iotdb.db.storageengine.dataregion.read.reader.common.PriorityM
import org.apache.iotdb.db.storageengine.dataregion.tsfile.TsFileResource;
import org.apache.tsfile.enums.TSDataType;
-import org.apache.tsfile.file.metadata.AlignedTimeSeriesMetadata;
+import org.apache.tsfile.file.metadata.AbstractAlignedTimeSeriesMetadata;
import org.apache.tsfile.file.metadata.IMetadata;
import org.apache.tsfile.read.common.block.TsBlock;
import org.apache.tsfile.read.reader.IPointReader;
@@ -47,14 +47,19 @@ public class AlignedSeriesScanUtil extends SeriesScanUtil {
// only used for limit and offset push down optimizer, if we select all columns from aligned
// device, we can use statistics to skip.
// it's only exact while using limit & offset push down
+ // for table scan, it should always be true
private final boolean queryAllSensors;
+ // for table model, it will be false
+ // for tree model, it will be true
+ private final boolean ignoreAllNullRows;
+
public AlignedSeriesScanUtil(
AlignedFullPath seriesPath,
Ordering scanOrder,
SeriesScanOptions scanOptions,
FragmentInstanceContext context) {
- this(seriesPath, scanOrder, scanOptions, context, false, null);
+ this(seriesPath, scanOrder, scanOptions, context, false, null, true);
}
public AlignedSeriesScanUtil(
@@ -63,7 +68,8 @@ public class AlignedSeriesScanUtil extends SeriesScanUtil {
SeriesScanOptions scanOptions,
FragmentInstanceContext context,
boolean queryAllSensors,
- List<TSDataType> givenDataTypes) {
+ List<TSDataType> givenDataTypes,
+ boolean ignoreAllNullRows) {
super(seriesPath, scanOrder, scanOptions, context);
isAligned = true;
this.dataTypes =
@@ -73,6 +79,7 @@ public class AlignedSeriesScanUtil extends SeriesScanUtil {
.map(IMeasurementSchema::getType)
.collect(Collectors.toList());
this.queryAllSensors = queryAllSensors;
+ this.ignoreAllNullRows = ignoreAllNullRows;
}
@Override
@@ -86,10 +93,15 @@ public class AlignedSeriesScanUtil extends SeriesScanUtil {
}
@Override
- protected AlignedTimeSeriesMetadata loadTimeSeriesMetadata(TsFileResource resource, boolean isSeq)
- throws IOException {
+ protected AbstractAlignedTimeSeriesMetadata loadTimeSeriesMetadata(
+ TsFileResource resource, boolean isSeq) throws IOException {
return FileLoaderUtils.loadAlignedTimeSeriesMetadata(
- resource, (AlignedFullPath) seriesPath, context, scanOptions.getGlobalTimeFilter(), isSeq);
+ resource,
+ (AlignedFullPath) seriesPath,
+ context,
+ scanOptions.getGlobalTimeFilter(),
+ isSeq,
+ ignoreAllNullRows);
}
@Override
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/FileLoaderUtils.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/FileLoaderUtils.java
index e26e7510d4e..e4f4459f41d 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/FileLoaderUtils.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/FileLoaderUtils.java
@@ -34,11 +34,14 @@ import org.apache.iotdb.db.storageengine.dataregion.read.reader.chunk.metadata.M
import org.apache.iotdb.db.storageengine.dataregion.read.reader.chunk.metadata.MemChunkMetadataLoader;
import org.apache.iotdb.db.storageengine.dataregion.tsfile.TsFileResource;
import org.apache.iotdb.db.storageengine.dataregion.tsfile.timeindex.ITimeIndex;
+import org.apache.iotdb.db.utils.ModificationUtils;
+import org.apache.tsfile.file.metadata.AbstractAlignedTimeSeriesMetadata;
import org.apache.tsfile.file.metadata.AlignedTimeSeriesMetadata;
import org.apache.tsfile.file.metadata.IChunkMetadata;
import org.apache.tsfile.file.metadata.IDeviceID;
import org.apache.tsfile.file.metadata.ITimeSeriesMetadata;
+import org.apache.tsfile.file.metadata.TableDeviceMetadata;
import org.apache.tsfile.file.metadata.TimeseriesMetadata;
import org.apache.tsfile.read.controller.IChunkLoader;
import org.apache.tsfile.read.filter.basic.Filter;
@@ -172,28 +175,31 @@ public class FileLoaderUtils {
* [root.sg1.d1.vector.s1, root.sg1.d1.vector.s2])
* @throws IOException IOException may be thrown while reading it from disk.
*/
- public static AlignedTimeSeriesMetadata loadAlignedTimeSeriesMetadata(
+ public static AbstractAlignedTimeSeriesMetadata loadAlignedTimeSeriesMetadata(
TsFileResource resource,
AlignedFullPath alignedPath,
QueryContext context,
Filter globalTimeFilter,
- boolean isSeq)
+ boolean isSeq,
+ boolean ignoreAllNullRows)
throws IOException {
final long t1 = System.nanoTime();
boolean loadFromMem = false;
try {
- AlignedTimeSeriesMetadata alignedTimeSeriesMetadata;
+ AbstractAlignedTimeSeriesMetadata alignedTimeSeriesMetadata;
// If the tsfile is closed, we need to load from tsfile
if (resource.isClosed()) {
alignedTimeSeriesMetadata =
- loadAlignedTimeSeriesMetadataFromDisk(resource, alignedPath, context, globalTimeFilter);
+ loadAlignedTimeSeriesMetadataFromDisk(
+ resource, alignedPath, context, globalTimeFilter, ignoreAllNullRows);
} else { // if the tsfile is unclosed, we just get it directly from TsFileResource
loadFromMem = true;
alignedTimeSeriesMetadata =
- (AlignedTimeSeriesMetadata) resource.getTimeSeriesMetadata(alignedPath);
+ (AbstractAlignedTimeSeriesMetadata) resource.getTimeSeriesMetadata(alignedPath);
if (alignedTimeSeriesMetadata != null) {
alignedTimeSeriesMetadata.setChunkMetadataLoader(
- new MemAlignedChunkMetadataLoader(resource, alignedPath, context, globalTimeFilter));
+ new MemAlignedChunkMetadataLoader(
+ resource, alignedPath, context, globalTimeFilter, ignoreAllNullRows));
// mem's modification already done in generating chunkmetadata
}
}
@@ -245,13 +251,14 @@ public class FileLoaderUtils {
}
}
- private static AlignedTimeSeriesMetadata loadAlignedTimeSeriesMetadataFromDisk(
+ private static AbstractAlignedTimeSeriesMetadata loadAlignedTimeSeriesMetadataFromDisk(
TsFileResource resource,
AlignedFullPath alignedPath,
QueryContext context,
- Filter globalTimeFilter)
+ Filter globalTimeFilter,
+ boolean ignoreAllNullRows)
throws IOException {
- AlignedTimeSeriesMetadata alignedTimeSeriesMetadata = null;
+ AbstractAlignedTimeSeriesMetadata alignedTimeSeriesMetadata = null;
// load all the TimeseriesMetadata of vector, the first one is for time column and the
// remaining is for sub sensors
// the order of timeSeriesMetadata list is same as subSensorList's order
@@ -275,11 +282,17 @@ public class FileLoaderUtils {
if (timeColumn != null) {
// only need time column, like count_time aggregation
if (valueMeasurementList.isEmpty()) {
+ // whatever for table or tree model, if we only need time column, that means that we
+ // shouldn't ignore all null rows
alignedTimeSeriesMetadata =
- new AlignedTimeSeriesMetadata(timeColumn, Collections.emptyList());
- alignedTimeSeriesMetadata.setChunkMetadataLoader(
- new DiskAlignedChunkMetadataLoader(
- resource, context, globalTimeFilter, Collections.emptyList()));
+ setModifications(
+ resource,
+ timeColumn,
+ Collections.emptyList(),
+ alignedPath,
+ context,
+ globalTimeFilter,
+ false);
} else {
List<TimeseriesMetadata> valueTimeSeriesMetadataList =
new ArrayList<>(valueMeasurementList.size());
@@ -297,52 +310,104 @@ public class FileLoaderUtils {
exist = (exist || (valueColumn != null));
valueTimeSeriesMetadataList.add(valueColumn);
}
- if (exist) {
- // set modifications to each aligned path
+ if (!ignoreAllNullRows || exist) {
alignedTimeSeriesMetadata =
- new AlignedTimeSeriesMetadata(timeColumn, valueTimeSeriesMetadataList);
- List<List<Modification>> pathModifications =
- setModifications(resource, alignedTimeSeriesMetadata, alignedPath, context);
-
- alignedTimeSeriesMetadata.setChunkMetadataLoader(
- new DiskAlignedChunkMetadataLoader(
- resource, context, globalTimeFilter, pathModifications));
+ setModifications(
+ resource,
+ timeColumn,
+ valueTimeSeriesMetadataList,
+ alignedPath,
+ context,
+ globalTimeFilter,
+ ignoreAllNullRows);
}
}
}
return alignedTimeSeriesMetadata;
}
- private static List<List<Modification>> setModifications(
+ private static AbstractAlignedTimeSeriesMetadata setModifications(
TsFileResource resource,
- AlignedTimeSeriesMetadata alignedTimeSeriesMetadata,
+ TimeseriesMetadata timeColumnMetadata,
+ List<TimeseriesMetadata> valueColumnMetadataList,
AlignedFullPath alignedPath,
- QueryContext context) {
+ QueryContext context,
+ Filter globalTimeFilter,
+ boolean ignoreAllNullRows) {
long startTime = System.nanoTime();
- List<TimeseriesMetadata> valueTimeSeriesMetadataList =
- alignedTimeSeriesMetadata.getValueTimeseriesMetadataList();
- List<List<Modification>> res = new ArrayList<>();
- boolean modified = false;
- for (TimeseriesMetadata timeseriesMetadata : valueTimeSeriesMetadataList) {
- if (timeseriesMetadata != null) {
- List<Modification> pathModifications =
+
+ // deal with time column
+ List<Modification> timeModifications =
+ context.getPathModifications(
+ resource, alignedPath.getDeviceId(), timeColumnMetadata.getMeasurementId());
+ // all rows are deleted, just return null to skip device data in this file
+ if (ModificationUtils.isAllDeletedByMods(
+ timeModifications,
+ timeColumnMetadata.getStatistics().getStartTime(),
+ timeColumnMetadata.getStatistics().getEndTime())) {
+ return null;
+ }
+ boolean modified = !timeModifications.isEmpty();
+ timeColumnMetadata.setModified(modified);
+ context
+ .getQueryStatistics()
+ .getAlignedTimeSeriesMetadataModificationCount()
+ .getAndAdd(timeModifications.size());
+
+ // deal with value columns
+ boolean hasNonNullValueColumns = false;
+ List<List<Modification>> valueColumnsModifications = new ArrayList<>();
+ for (int i = 0, size = valueColumnMetadataList.size(); i < size; i++) {
+ TimeseriesMetadata valueColumnMetadata = valueColumnMetadataList.get(i);
+ if (valueColumnMetadata != null) {
+ List<Modification> modifications =
context.getPathModifications(
- resource, alignedPath.getDeviceId(), timeseriesMetadata.getMeasurementId());
- timeseriesMetadata.setModified(!pathModifications.isEmpty());
- res.add(pathModifications);
- modified = (modified || !pathModifications.isEmpty());
+ resource, alignedPath.getDeviceId(), valueColumnMetadata.getMeasurementId());
+ valueColumnMetadata.setModified(!modifications.isEmpty());
+ valueColumnsModifications.add(modifications);
+ modified = (modified || !modifications.isEmpty());
context
.getQueryStatistics()
.getAlignedTimeSeriesMetadataModificationCount()
- .getAndAdd(pathModifications.size());
+ .getAndAdd(modifications.size());
+
+ // this value column is all deleted
+ if (ModificationUtils.isAllDeletedByMods(
+ modifications,
+ valueColumnMetadata.getStatistics().getStartTime(),
+ valueColumnMetadata.getStatistics().getEndTime())) {
+ valueColumnMetadataList.set(i, null);
+ } else {
+ hasNonNullValueColumns = true;
+ }
} else {
- res.add(Collections.emptyList());
+ valueColumnsModifications.add(Collections.emptyList());
}
}
- alignedTimeSeriesMetadata.getTimeseriesMetadata().setModified(modified);
+
+ if (ignoreAllNullRows && !hasNonNullValueColumns) {
+ return null;
+ }
+
+ timeColumnMetadata.setModified(modified);
+
+ AbstractAlignedTimeSeriesMetadata alignedTimeSeriesMetadata =
+ ignoreAllNullRows
+ ? new AlignedTimeSeriesMetadata(timeColumnMetadata, valueColumnMetadataList)
+ : new TableDeviceMetadata(timeColumnMetadata, valueColumnMetadataList);
+
+ alignedTimeSeriesMetadata.setChunkMetadataLoader(
+ new DiskAlignedChunkMetadataLoader(
+ resource,
+ context,
+ globalTimeFilter,
+ timeModifications,
+ valueColumnsModifications,
+ ignoreAllNullRows));
+
long costTime = System.nanoTime() - startTime;
context.getQueryStatistics().getAlignedTimeSeriesMetadataModificationTime().getAndAdd(costTime);
- return res;
+ return alignedTimeSeriesMetadata;
}
/**
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/TableScanOperator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/TableScanOperator.java
index 90982549716..d3efac0a1e3 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/TableScanOperator.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/relational/TableScanOperator.java
@@ -306,7 +306,8 @@ public class TableScanOperator extends AbstractSeriesScanOperator {
seriesScanOptions,
operatorContext.getInstanceContext(),
true,
- measurementColumnTSDataTypes);
+ measurementColumnTSDataTypes,
+ false);
}
public static AlignedFullPath constructAlignedPath(
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/LoadTsFileAnalyzer.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/LoadTsFileAnalyzer.java
index 34f99c64388..b6983ff39b8 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/LoadTsFileAnalyzer.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/LoadTsFileAnalyzer.java
@@ -811,7 +811,7 @@ public class LoadTsFileAnalyzer implements AutoCloseable {
public boolean isDeviceDeletedByMods(IDeviceID device) throws IllegalPathException {
return currentTimeIndex != null
- && ModificationUtils.isDeviceDeletedByMods(
+ && ModificationUtils.isAllDeletedByMods(
currentModifications,
device,
currentTimeIndex.getStartTime(device),
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LocalExecutionPlanner.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LocalExecutionPlanner.java
index 79d89b86d9b..ecb18e919c9 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LocalExecutionPlanner.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LocalExecutionPlanner.java
@@ -157,9 +157,11 @@ public class LocalExecutionPlanner {
: instanceContext.getSessionInfo().getSqlDialect();
switch (sqlDialect) {
case TREE:
+ instanceContext.setIgnoreAllNullRows(true);
root = node.accept(new OperatorTreeGenerator(), context);
break;
case TABLE:
+ instanceContext.setIgnoreAllNullRows(false);
root = node.accept(new TableOperatorGenerator(metadata), context);
break;
default:
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/utils/ResourceByPathUtils.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/utils/ResourceByPathUtils.java
index dfa45ef7617..650c6dac561 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/utils/ResourceByPathUtils.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/utils/ResourceByPathUtils.java
@@ -181,7 +181,7 @@ class AlignedResourceByPathUtils extends ResourceByPathUtils {
IMemTable memTable,
List<Pair<Modification, IMemTable>> modsToMemtable,
long timeLowerBound)
- throws QueryProcessException, IOException {
+ throws QueryProcessException {
Map<IDeviceID, IWritableMemChunkGroup> memTableMap = memTable.getMemTableMap();
IDeviceID deviceID = alignedFullPath.getDeviceId();
@@ -191,22 +191,35 @@ class AlignedResourceByPathUtils extends ResourceByPathUtils {
}
AlignedWritableMemChunk alignedMemChunk =
((AlignedWritableMemChunkGroup) memTableMap.get(deviceID)).getAlignedMemChunk();
- boolean containsMeasurement = false;
- for (String measurement : alignedFullPath.getMeasurementList()) {
- if (alignedMemChunk.containsMeasurement(measurement)) {
- containsMeasurement = true;
- break;
+ // only need to do this check for tree model
+ if (context.isIgnoreAllNullRows()) {
+ boolean containsMeasurement = false;
+ for (String measurement : alignedFullPath.getMeasurementList()) {
+ if (alignedMemChunk.containsMeasurement(measurement)) {
+ containsMeasurement = true;
+ break;
+ }
+ }
+ if (!containsMeasurement) {
+ return null;
}
}
- if (!containsMeasurement) {
- return null;
- }
+
// get sorted tv list is synchronized so different query can get right sorted list reference
TVList alignedTvListCopy =
alignedMemChunk.getSortedTvListForQuery(alignedFullPath.getSchemaList());
- List<List<TimeRange>> deletionList = null;
+ List<TimeRange> timeColumnDeletion = null;
+ List<List<TimeRange>> valueColumnsDeletionList = null;
if (modsToMemtable != null) {
- deletionList =
+ timeColumnDeletion =
+ ModificationUtils.constructDeletionList(
+ alignedFullPath.getDeviceId(),
+ Collections.singletonList(AlignedFullPath.VECTOR_PLACEHOLDER),
+ memTable,
+ modsToMemtable,
+ timeLowerBound)
+ .get(0);
+ valueColumnsDeletionList =
ModificationUtils.constructDeletionList(
alignedFullPath.getDeviceId(),
alignedFullPath.getMeasurementList(),
@@ -215,7 +228,11 @@ class AlignedResourceByPathUtils extends ResourceByPathUtils {
timeLowerBound);
}
return new AlignedReadOnlyMemChunk(
- context, getMeasurementSchema(), alignedTvListCopy, deletionList);
+ context,
+ getMeasurementSchema(),
+ alignedTvListCopy,
+ timeColumnDeletion,
+ valueColumnsDeletionList);
}
public VectorMeasurementSchema getMeasurementSchema() {
@@ -245,9 +262,6 @@ class AlignedResourceByPathUtils extends ResourceByPathUtils {
TsFileResource tsFileResource,
QueryContext context,
long timeLowerBound) {
- List<List<Modification>> modifications =
- context.getPathModifications(
- tsFileResource, alignedFullPath.getDeviceId(), alignedFullPath.getMeasurementList());
List<AlignedChunkMetadata> chunkMetadataList = new ArrayList<>();
List<ChunkMetadata> timeChunkMetadataList =
@@ -277,14 +291,26 @@ class AlignedResourceByPathUtils extends ResourceByPathUtils {
exits = (exits || currentExist);
valueChunkMetadata.add(currentExist ? chunkMetadata.get(i) : null);
}
- if (exits) {
+ if (!context.isIgnoreAllNullRows() || exits) {
chunkMetadataList.add(
new AlignedChunkMetadata(timeChunkMetadataList.get(i), valueChunkMetadata));
}
}
}
- ModificationUtils.modifyAlignedChunkMetaData(chunkMetadataList, modifications);
+ List<Modification> timeColumnModifications =
+ context.getPathModifications(
+ tsFileResource, alignedFullPath.getDeviceId(), AlignedFullPath.VECTOR_PLACEHOLDER);
+
+ List<List<Modification>> valueColumnsModifications =
+ context.getPathModifications(
+ tsFileResource, alignedFullPath.getDeviceId(), alignedFullPath.getMeasurementList());
+
+ ModificationUtils.modifyAlignedChunkMetaData(
+ chunkMetadataList,
+ timeColumnModifications,
+ valueColumnsModifications,
+ context.isIgnoreAllNullRows());
chunkMetadataList.removeIf(x -> x.getEndTime() < timeLowerBound);
return new ArrayList<>(chunkMetadataList);
}
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/memtable/AlignedReadOnlyMemChunk.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/memtable/AlignedReadOnlyMemChunk.java
index 8082f66d8df..29462c993ff 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/memtable/AlignedReadOnlyMemChunk.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/memtable/AlignedReadOnlyMemChunk.java
@@ -58,7 +58,8 @@ public class AlignedReadOnlyMemChunk extends ReadOnlyMemChunk {
QueryContext context,
IMeasurementSchema schema,
TVList tvList,
- List<List<TimeRange>> deletionList)
+ List<TimeRange> timeColumnDeletion,
+ List<List<TimeRange>> valueColumnsDeletionList)
throws QueryProcessException {
super(context);
this.timeChunkName = schema.getMeasurementId();
@@ -67,7 +68,9 @@ public class AlignedReadOnlyMemChunk extends ReadOnlyMemChunk {
int floatPrecision = TSFileDescriptor.getInstance().getConfig().getFloatPrecision();
List<TSEncoding> encodingList = schema.getSubMeasurementsTSEncodingList();
this.tsBlock =
- ((AlignedTVList) tvList).buildTsBlock(floatPrecision, encodingList, deletionList);
+ ((AlignedTVList) tvList)
+ .buildTsBlock(
+ floatPrecision, encodingList, timeColumnDeletion, valueColumnsDeletionList);
initAlignedChunkMetaFromTsBlock();
}
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/DiskAlignedChunkLoader.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/DiskAlignedChunkLoader.java
index 87495548913..d2f2a2da02f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/DiskAlignedChunkLoader.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/DiskAlignedChunkLoader.java
@@ -33,6 +33,7 @@ import org.apache.tsfile.read.controller.IChunkLoader;
import org.apache.tsfile.read.filter.basic.Filter;
import org.apache.tsfile.read.reader.IChunkReader;
import org.apache.tsfile.read.reader.chunk.AlignedChunkReader;
+import org.apache.tsfile.read.reader.chunk.TableChunkReader;
import java.io.IOException;
import java.util.ArrayList;
@@ -47,13 +48,19 @@ public class DiskAlignedChunkLoader implements IChunkLoader {
private final TsFileResource resource;
+ // for table model, it will be false
+ // for tree model, it will be true
+ private final boolean ignoreAllNullRows;
+
private static final SeriesScanCostMetricSet SERIES_SCAN_COST_METRIC_SET =
SeriesScanCostMetricSet.getInstance();
- public DiskAlignedChunkLoader(QueryContext context, TsFileResource resource) {
+ public DiskAlignedChunkLoader(
+ QueryContext context, TsFileResource resource, boolean ignoreAllNullRows) {
this.context = context;
this.debug = context.isDebug();
this.resource = resource;
+ this.ignoreAllNullRows = ignoreAllNullRows;
}
@Override
@@ -103,7 +110,9 @@ public class DiskAlignedChunkLoader implements IChunkLoader {
long t2 = System.nanoTime();
IChunkReader chunkReader =
- new AlignedChunkReader(timeChunk, valueChunkList, globalTimeFilter);
+ ignoreAllNullRows
+ ? new AlignedChunkReader(timeChunk, valueChunkList, globalTimeFilter)
+ : new TableChunkReader(timeChunk, valueChunkList, globalTimeFilter);
SERIES_SCAN_COST_METRIC_SET.recordSeriesScanCost(
INIT_CHUNK_READER_ALIGNED_DISK, System.nanoTime() - t2);
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/metadata/DiskAlignedChunkMetadataLoader.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/metadata/DiskAlignedChunkMetadataLoader.java
index 3d17c955d12..da9895406eb 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/metadata/DiskAlignedChunkMetadataLoader.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/metadata/DiskAlignedChunkMetadataLoader.java
@@ -50,8 +50,15 @@ public class DiskAlignedChunkMetadataLoader implements IChunkMetadataLoader {
// global time filter, only used to check time range
private final Filter globalTimeFilter;
+ // time column's modifications, means deletion for entire row
+ private final List<Modification> timeColumnModifications;
+
// all sub sensors' modifications
- private final List<List<Modification>> pathModifications;
+ private final List<List<Modification>> valueColumnsModifications;
+
+ // for table model, it will be false
+ // for tree model, it will be true
+ private final boolean ignoreAllNullRows;
private static final Logger DEBUG_LOGGER = LoggerFactory.getLogger("QUERY_DEBUG");
private static final SeriesScanCostMetricSet SERIES_SCAN_COST_METRIC_SET =
@@ -61,11 +68,15 @@ public class DiskAlignedChunkMetadataLoader implements IChunkMetadataLoader {
TsFileResource resource,
QueryContext context,
Filter globalTimeFilter,
- List<List<Modification>> pathModifications) {
+ List<Modification> timeModifications,
+ List<List<Modification>> valueColumnsModifications,
+ boolean ignoreAllNullRows) {
this.resource = resource;
this.context = context;
this.globalTimeFilter = globalTimeFilter;
- this.pathModifications = pathModifications;
+ this.timeColumnModifications = timeModifications;
+ this.valueColumnsModifications = valueColumnsModifications;
+ this.ignoreAllNullRows = ignoreAllNullRows;
}
@Override
@@ -99,13 +110,17 @@ public class DiskAlignedChunkMetadataLoader implements IChunkMetadataLoader {
if (context.isDebug()) {
DEBUG_LOGGER.info(
"Modifications size is {} for file Path: {} ",
- pathModifications.size(),
+ valueColumnsModifications.size(),
resource.getTsFilePath());
- pathModifications.forEach(c -> DEBUG_LOGGER.info(c.toString()));
+ valueColumnsModifications.forEach(c -> DEBUG_LOGGER.info(c.toString()));
}
// remove ChunkMetadata that have been deleted
- ModificationUtils.modifyAlignedChunkMetaData(alignedChunkMetadataList, pathModifications);
+ ModificationUtils.modifyAlignedChunkMetaData(
+ alignedChunkMetadataList,
+ timeColumnModifications,
+ valueColumnsModifications,
+ ignoreAllNullRows);
if (context.isDebug()) {
DEBUG_LOGGER.info("After modification Chunk meta data list is: ");
@@ -121,7 +136,8 @@ public class DiskAlignedChunkMetadataLoader implements IChunkMetadataLoader {
if (chunkMetadata.needSetChunkLoader()) {
chunkMetadata.setVersion(resource.getVersion());
chunkMetadata.setClosed(resource.isClosed());
- chunkMetadata.setChunkLoader(new DiskAlignedChunkLoader(context, resource));
+ chunkMetadata.setChunkLoader(
+ new DiskAlignedChunkLoader(context, resource, ignoreAllNullRows));
}
});
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/metadata/MemAlignedChunkMetadataLoader.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/metadata/MemAlignedChunkMetadataLoader.java
index 0ee30670b9d..5f88b1cfb4f 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/metadata/MemAlignedChunkMetadataLoader.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/metadata/MemAlignedChunkMetadataLoader.java
@@ -42,6 +42,9 @@ public class MemAlignedChunkMetadataLoader implements IChunkMetadataLoader {
private final AlignedFullPath seriesPath;
private final QueryContext context;
private final Filter globalTimeFilter;
+ // for table model, it will be false
+ // for tree model, it will be true
+ private final boolean ignoreAllNullRows;
private static final SeriesScanCostMetricSet SERIES_SCAN_COST_METRIC_SET =
SeriesScanCostMetricSet.getInstance();
@@ -50,11 +53,13 @@ public class MemAlignedChunkMetadataLoader implements IChunkMetadataLoader {
TsFileResource resource,
AlignedFullPath seriesPath,
QueryContext context,
- Filter globalTimeFilter) {
+ Filter globalTimeFilter,
+ boolean ignoreAllNullRows) {
this.resource = resource;
this.seriesPath = seriesPath;
this.context = context;
this.globalTimeFilter = globalTimeFilter;
+ this.ignoreAllNullRows = ignoreAllNullRows;
}
@Override
@@ -70,7 +75,8 @@ public class MemAlignedChunkMetadataLoader implements IChunkMetadataLoader {
if (chunkMetadata.needSetChunkLoader()) {
chunkMetadata.setVersion(resource.getVersion());
chunkMetadata.setClosed(resource.isClosed());
- chunkMetadata.setChunkLoader(new DiskAlignedChunkLoader(context, resource));
+ chunkMetadata.setChunkLoader(
+ new DiskAlignedChunkLoader(context, resource, ignoreAllNullRows));
}
});
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/ModificationUtils.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/ModificationUtils.java
index 9e7b6f7ecb8..4bb66a620ba 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/ModificationUtils.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/ModificationUtils.java
@@ -87,66 +87,129 @@ public class ModificationUtils {
public static void modifyAlignedChunkMetaData(
List<AlignedChunkMetadata> chunkMetaData, List<List<Modification>> modifications) {
for (AlignedChunkMetadata metaData : chunkMetaData) {
- List<IChunkMetadata> valueChunkMetadataList = metaData.getValueChunkMetadataList();
- // deal with each sub sensor
- for (int i = 0; i < valueChunkMetadataList.size(); i++) {
- IChunkMetadata v = valueChunkMetadataList.get(i);
- if (v != null) {
- List<Modification> modificationList = modifications.get(i);
- for (Modification modification : modificationList) {
- // The case modification.getFileOffset() == metaData.getOffsetOfChunkHeader()
- // is not supposed to exist as getFileOffset() is offset containing full chunk,
- // while getOffsetOfChunkHeader() returns the chunk header offset
- if (modification.getFileOffset() > v.getOffsetOfChunkHeader()) {
- doModifyChunkMetaData(modification, v);
+ modifyValueColumns(metaData, modifications);
+ }
+ // if all sub sensors' chunk metadata are deleted, then remove the aligned chunk metadata
+ // otherwise, set the deleted chunk metadata of some sensors to null
+ chunkMetaData.removeIf(
+ alignedChunkMetadata -> {
+ // the whole aligned path need to be removed, only set to be true if all the sub sensors
+ // are deleted
+ // the whole aligned path is modified, set to be true if any sub sensor is modified
+ return areAllValueColumnsDeleted(alignedChunkMetadata, false);
+ });
+ }
+
+ private static void modifyValueColumns(
+ AlignedChunkMetadata metaData, List<List<Modification>> valueColumnsModifications) {
+ List<IChunkMetadata> valueChunkMetadataList = metaData.getValueChunkMetadataList();
+ // deal with each sub sensor
+ for (int j = 0; j < valueChunkMetadataList.size(); j++) {
+ IChunkMetadata v = valueChunkMetadataList.get(j);
+ if (v != null) {
+ List<Modification> modificationList = valueColumnsModifications.get(j);
+ for (Modification modification : modificationList) {
+ // The case modification.getFileOffset() == metaData.getOffsetOfChunkHeader()
+ // is not supposed to exist as getFileOffset() is offset containing full chunk,
+ // while getOffsetOfChunkHeader() returns the chunk header offset
+ if (modification.getFileOffset() > v.getOffsetOfChunkHeader()) {
+ doModifyChunkMetaData(modification, v);
+ }
+ }
+ }
+ }
+ }
+
+ private static boolean areAllValueColumnsDeleted(
+ AlignedChunkMetadata alignedChunkMetadata, boolean modified) {
+
+ // the whole aligned path need to be removed, only set to be true if all the sub sensors
+ // are deleted and ignoreAllNullRows is true
+ boolean allValueColumnsAreDeleted = true;
+ List<IChunkMetadata> valueChunkMetadataList = alignedChunkMetadata.getValueChunkMetadataList();
+ for (int i = 0; i < valueChunkMetadataList.size(); i++) {
+ IChunkMetadata valueChunkMetadata = valueChunkMetadataList.get(i);
+ if (valueChunkMetadata == null) {
+ continue;
+ }
+ // current sub sensor's chunk metadata is completely removed
+ boolean currentRemoved = false;
+ if (valueChunkMetadata.getDeleteIntervalList() != null) {
+ for (TimeRange range : valueChunkMetadata.getDeleteIntervalList()) {
+ if (range.contains(valueChunkMetadata.getStartTime(), valueChunkMetadata.getEndTime())) {
+ valueChunkMetadataList.set(i, null);
+ currentRemoved = true;
+ break;
+ } else {
+ if (range.overlaps(
+ new TimeRange(
+ valueChunkMetadata.getStartTime(), valueChunkMetadata.getEndTime()))) {
+ valueChunkMetadata.setModified(true);
+ modified = true;
}
}
}
}
+ // current sub sensor's chunk metadata is not completely removed,
+ // so the whole aligned path don't need to be removed from list
+ if (!currentRemoved) {
+ allValueColumnsAreDeleted = false;
+ }
}
- // if all sub sensors' chunk metadata are deleted, then remove the aligned chunk metadata
+ alignedChunkMetadata.setModified(modified);
+ return allValueColumnsAreDeleted;
+ }
+
+ public static void modifyAlignedChunkMetaData(
+ List<AlignedChunkMetadata> chunkMetaData,
+ List<Modification> timeColumnModifications,
+ List<List<Modification>> valueColumnsModifications,
+ boolean ignoreAllNullRows) {
+ for (AlignedChunkMetadata metaData : chunkMetaData) {
+ IChunkMetadata timeColumnChunkMetadata = metaData.getTimeChunkMetadata();
+
+ for (Modification modification : timeColumnModifications) {
+ // The case modification.getFileOffset() == metaData.getOffsetOfChunkHeader()
+ // is not supposed to exist as getFileOffset() is offset containing full chunk,
+ // while getOffsetOfChunkHeader() returns the chunk header offset
+ if (modification.getFileOffset() > timeColumnChunkMetadata.getOffsetOfChunkHeader()) {
+ doModifyChunkMetaData(modification, timeColumnChunkMetadata);
+ }
+ }
+ modifyValueColumns(metaData, valueColumnsModifications);
+ }
+
+ // if all sub sensors' chunk metadata are deleted and ignoreAllNullRows is true, then remove the
+ // aligned chunk metadata
// otherwise, set the deleted chunk metadata of some sensors to null
chunkMetaData.removeIf(
alignedChunkMetadata -> {
- // the whole aligned path need to be removed, only set to be true if all the sub sensors
- // are deleted
- boolean removed = true;
// the whole aligned path is modified, set to be true if any sub sensor is modified
boolean modified = false;
- List<IChunkMetadata> valueChunkMetadataList =
- alignedChunkMetadata.getValueChunkMetadataList();
- for (int i = 0; i < valueChunkMetadataList.size(); i++) {
- IChunkMetadata valueChunkMetadata = valueChunkMetadataList.get(i);
- if (valueChunkMetadata == null) {
- continue;
- }
- // current sub sensor's chunk metadata is completely removed
- boolean currentRemoved = false;
- if (valueChunkMetadata.getDeleteIntervalList() != null) {
- for (TimeRange range : valueChunkMetadata.getDeleteIntervalList()) {
- if (range.contains(
- valueChunkMetadata.getStartTime(), valueChunkMetadata.getEndTime())) {
- valueChunkMetadataList.set(i, null);
- currentRemoved = true;
- break;
- } else {
- if (range.overlaps(
- new TimeRange(
- valueChunkMetadata.getStartTime(), valueChunkMetadata.getEndTime()))) {
- valueChunkMetadata.setModified(true);
- modified = true;
- }
+
+ // deal with time column
+ IChunkMetadata timeColumnChunkMetadata = alignedChunkMetadata.getTimeChunkMetadata();
+ if (timeColumnChunkMetadata.getDeleteIntervalList() != null) {
+ for (TimeRange range : timeColumnChunkMetadata.getDeleteIntervalList()) {
+ if (range.contains(
+ timeColumnChunkMetadata.getStartTime(), timeColumnChunkMetadata.getEndTime())) {
+ // all rows are deleted
+ return true;
+ } else {
+ if (range.overlaps(
+ new TimeRange(
+ timeColumnChunkMetadata.getStartTime(),
+ timeColumnChunkMetadata.getEndTime()))) {
+ timeColumnChunkMetadata.setModified(true);
+ modified = true;
}
}
}
- // current sub sensor's chunk metadata is not completely removed,
- // so the whole aligned path don't need to be removed from list
- if (!currentRemoved) {
- removed = false;
- }
}
- alignedChunkMetadata.setModified(modified);
- return removed;
+
+ boolean allValueColumnsAreDeleted =
+ areAllValueColumnsDeleted(alignedChunkMetadata, modified);
+ return ignoreAllNullRows && allValueColumnsAreDeleted;
});
}
@@ -191,7 +254,7 @@ public class ModificationUtils {
* Check whether the device with start time and end time is completely deleted by mods or not.
* There are some slight differences from that in {@link SettleSelectorImpl}.
*/
- public static boolean isDeviceDeletedByMods(
+ public static boolean isAllDeletedByMods(
Collection<Modification> modifications, IDeviceID device, long startTime, long endTime)
throws IllegalPathException {
for (Modification modification : modifications) {
@@ -204,6 +267,19 @@ public class ModificationUtils {
return false;
}
+ public static boolean isAllDeletedByMods(
+ Collection<Modification> modifications, long startTime, long endTime) {
+ if (modifications == null || modifications.isEmpty()) {
+ return false;
+ }
+ for (Modification modification : modifications) {
+ if (((Deletion) modification).getTimeRange().contains(startTime, endTime)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
public static boolean isTimeseriesDeletedByMods(
Collection<Modification> modifications,
IDeviceID device,
@@ -235,12 +311,13 @@ public class ModificationUtils {
IMemTable memTable,
List<Pair<Modification, IMemTable>> modsToMemtable,
long timeLowerBound) {
+ List<Modification> modifications =
+ ModificationUtils.getModificationsForMemtable(memTable, modsToMemtable);
List<List<TimeRange>> deletionList = new ArrayList<>();
for (String measurement : measurementList) {
List<TimeRange> columnDeletionList = new ArrayList<>();
columnDeletionList.add(new TimeRange(Long.MIN_VALUE, timeLowerBound));
- for (Modification modification :
- ModificationUtils.getModificationsForMemtable(memTable, modsToMemtable)) {
+ for (Modification modification : modifications) {
if (modification instanceof Deletion) {
Deletion deletion = (Deletion) modification;
if (deletion.getPath().matchFullPath(deviceID, measurement)
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/datastructure/AlignedTVList.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/datastructure/AlignedTVList.java
index c09bd62b619..0db4a53b0d4 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/datastructure/AlignedTVList.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/datastructure/AlignedTVList.java
@@ -945,7 +945,10 @@ public abstract class AlignedTVList extends TVList {
/** Build TsBlock by column. */
public TsBlock buildTsBlock(
- int floatPrecision, List<TSEncoding> encodingList, List<List<TimeRange>> deletionList) {
+ int floatPrecision,
+ List<TSEncoding> encodingList,
+ List<TimeRange> timeColumnDeletion,
+ List<List<TimeRange>> deletionList) {
TsBlockBuilder builder = new TsBlockBuilder(dataTypes);
// Time column
TimeColumnBuilder timeBuilder = builder.getTimeColumnBuilder();
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/metadata/MemAlignedChunkMetadataLoaderTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/metadata/MemAlignedChunkMetadataLoaderTest.java
index 2ba5261afa4..9b9c348979f 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/metadata/MemAlignedChunkMetadataLoaderTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/storageengine/dataregion/read/reader/chunk/metadata/MemAlignedChunkMetadataLoaderTest.java
@@ -65,7 +65,7 @@ public class MemAlignedChunkMetadataLoaderTest {
Mockito.when(resource.getVersion()).thenReturn(1L);
MemAlignedChunkMetadataLoader loader =
- new MemAlignedChunkMetadataLoader(resource, path, context, null);
+ new MemAlignedChunkMetadataLoader(resource, path, context, null, true);
ITimeSeriesMetadata timeSeriesMetadata = Mockito.mock(AlignedTimeSeriesMetadata.class);
List<IChunkMetadata> chunkMetadataList = loader.loadChunkMetadataList(timeSeriesMetadata);
diff --git a/pom.xml b/pom.xml
index a5729178ec4..6c546320fe2 100644
--- a/pom.xml
+++ b/pom.xml
@@ -166,7 +166,7 @@
<thrift.version>0.14.1</thrift.version>
<xz.version>1.9</xz.version>
<zstd-jni.version>1.5.6-3</zstd-jni.version>
- <tsfile.version>1.2.0-240904-SNAPSHOT</tsfile.version>
+ <tsfile.version>1.2.0-SNAPSHOT</tsfile.version>
</properties>
<!--
if we claim dependencies in dependencyManagement, then we do not claim