ycycse commented on code in PR #12539: URL: https://github.com/apache/iotdb/pull/12539#discussion_r1606149671
########## iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/filescan/impl/ClosedFileScanHandleImpl.java: ########## @@ -0,0 +1,174 @@ +/* + * 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.storageengine.dataregion.read.filescan.impl; + +import org.apache.iotdb.db.storageengine.dataregion.modification.Deletion; +import org.apache.iotdb.db.storageengine.dataregion.modification.Modification; +import org.apache.iotdb.db.storageengine.dataregion.read.control.FileReaderManager; +import org.apache.iotdb.db.storageengine.dataregion.read.filescan.IChunkHandle; +import org.apache.iotdb.db.storageengine.dataregion.read.filescan.IFileScanHandle; +import org.apache.iotdb.db.storageengine.dataregion.read.filescan.model.AbstractDeviceChunkMetaData; +import org.apache.iotdb.db.storageengine.dataregion.read.filescan.model.AlignedDeviceChunkMetaData; +import org.apache.iotdb.db.storageengine.dataregion.read.filescan.model.ChunkOffsetInfo; +import org.apache.iotdb.db.storageengine.dataregion.read.filescan.model.DeviceChunkMetaData; +import org.apache.iotdb.db.storageengine.dataregion.tsfile.TsFileResource; +import org.apache.iotdb.db.storageengine.dataregion.tsfile.timeindex.DeviceTimeIndex; +import org.apache.iotdb.db.storageengine.dataregion.tsfile.timeindex.ITimeIndex; +import org.apache.iotdb.db.storageengine.dataregion.utils.TsFileDeviceStartEndTimeIterator; + +import org.apache.tsfile.file.metadata.AlignedChunkMetadata; +import org.apache.tsfile.file.metadata.IChunkMetadata; +import org.apache.tsfile.file.metadata.IDeviceID; +import org.apache.tsfile.file.metadata.statistics.Statistics; +import org.apache.tsfile.read.TsFileDeviceIterator; +import org.apache.tsfile.read.TsFileSequenceReader; +import org.apache.tsfile.utils.Pair; + +import java.io.IOException; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +public class ClosedFileScanHandleImpl implements IFileScanHandle { + + private final TsFileResource tsFileResource; + private final Map<IDeviceID, Map<String, List<Modification>>> deviceToModifications; + + public ClosedFileScanHandleImpl( + TsFileResource tsFileResource, + Map<IDeviceID, Map<String, List<Modification>>> deviceToModifications) { + this.tsFileResource = tsFileResource; + this.deviceToModifications = deviceToModifications; + } + + @Override + public TsFileDeviceStartEndTimeIterator getDeviceStartEndTimeIterator() throws IOException { + ITimeIndex timeIndex = tsFileResource.getTimeIndex(); + return timeIndex instanceof DeviceTimeIndex + ? new TsFileDeviceStartEndTimeIterator((DeviceTimeIndex) timeIndex) + : new TsFileDeviceStartEndTimeIterator(tsFileResource.buildDeviceTimeIndex()); + } + + @Override + public boolean isDeviceTimeDeleted(IDeviceID deviceID, long timestamp) { + for (List<Modification> modificationList : deviceToModifications.get(deviceID).values()) { + if (modificationList.stream() + .anyMatch( + modification -> Review Comment: Yes, they are similar. We can store List<TimeRange> to reuse this method. ########## iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/memtable/AbstractMemTable.java: ########## @@ -465,6 +481,278 @@ public ReadOnlyMemChunk query( .getReadOnlyMemChunkFromMemTable(context, this, modsToMemtable, ttlLowerBound); } + @Override + public void queryForSeriesRegionScan( + PartialPath fullPath, + long ttlLowerBound, + Map<String, List<IChunkMetadata>> chunkMetaDataMap, + Map<String, List<IChunkHandle>> memChunkHandleMap, + List<Pair<Modification, IMemTable>> modsToMemTabled) { + + IDeviceID deviceID = DeviceIDFactory.getInstance().getDeviceID(fullPath.getDevicePath()); + String measurementId = fullPath.getMeasurement(); + Map<IDeviceID, IWritableMemChunkGroup> memTableMap = getMemTableMap(); + + // check If MemTable Contains this path + if (!memTableMap.containsKey(deviceID) || !memTableMap.get(deviceID).contains(measurementId)) { + return; + } + + if (fullPath instanceof MeasurementPath) { + List<TimeRange> deletionList = new ArrayList<>(); + if (modsToMemTabled != null) { + deletionList = + ModificationUtils.constructDeletionList( + (MeasurementPath) fullPath, this, modsToMemTabled, ttlLowerBound); + } + getMemChunkHandleFromMemTable( + deviceID, measurementId, chunkMetaDataMap, memChunkHandleMap, deletionList); + } else { + List<List<TimeRange>> deletionList = new ArrayList<>(); + if (modsToMemTabled != null) { + deletionList = + ModificationUtils.constructDeletionList( + (AlignedPath) fullPath, this, modsToMemTabled, ttlLowerBound); + } + + getMemAlignedChunkHandleFromMemTable( + deviceID, + ((AlignedPath) fullPath).getSchemaList(), + chunkMetaDataMap, + memChunkHandleMap, + deletionList); + } + } + + @Override + public void queryForDeviceRegionScan( + IDeviceID deviceID, + boolean isAligned, + long ttlLowerBound, + Map<String, List<IChunkMetadata>> chunkMetadataMap, + Map<String, List<IChunkHandle>> memChunkHandleMap, + List<Pair<Modification, IMemTable>> modsToMemTabled) + throws MetadataException { + + Map<IDeviceID, IWritableMemChunkGroup> memTableMap = getMemTableMap(); + + // check If MemTable Contains this path + if (!memTableMap.containsKey(deviceID)) { + return; + } + + IWritableMemChunkGroup writableMemChunkGroup = memTableMap.get(deviceID); + if (isAligned) { + getMemAlignedChunkHandleFromMemTable( + ((PlainDeviceID) deviceID).toStringID(), + (AlignedWritableMemChunkGroup) writableMemChunkGroup, + chunkMetadataMap, + memChunkHandleMap, + ttlLowerBound, + modsToMemTabled); + } else { + getMemChunkHandleFromMemTable( + ((PlainDeviceID) deviceID).toStringID(), + (WritableMemChunkGroup) writableMemChunkGroup, + chunkMetadataMap, + memChunkHandleMap, + ttlLowerBound, + modsToMemTabled); + } + } + + private void getMemChunkHandleFromMemTable( + IDeviceID deviceID, + String measurementId, + Map<String, List<IChunkMetadata>> chunkMetadataMap, + Map<String, List<IChunkHandle>> memChunkHandleMap, + List<TimeRange> deletionList) { + + IWritableMemChunk memChunk = memTableMap.get(deviceID).getMemChunkMap().get(measurementId); + + TVList tvListCopy = memChunk.getSortedTvListForQuery(); + long[] timestamps = filterDeletedTimestamp(tvListCopy, deletionList); + + chunkMetadataMap + .computeIfAbsent(measurementId, k -> new ArrayList<>()) + .add( + buildChunkMetaDataForMemoryChunk( + measurementId, + timestamps[0], + timestamps[timestamps.length - 1], + Collections.emptyList())); + memChunkHandleMap + .computeIfAbsent(measurementId, k -> new ArrayList<>()) + .add(new MemChunkHandleImpl(timestamps)); + } + + private void getMemAlignedChunkHandleFromMemTable( + IDeviceID deviceID, + List<IMeasurementSchema> schemaList, + Map<String, List<IChunkMetadata>> chunkMetadataList, + Map<String, List<IChunkHandle>> memChunkHandleMap, + List<List<TimeRange>> deletionList) { + + AlignedWritableMemChunk alignedMemChunk = + ((AlignedWritableMemChunkGroup) memTableMap.get(deviceID)).getAlignedMemChunk(); + AlignedTVList alignedTVListCopy = + (AlignedTVList) alignedMemChunk.getSortedTvListForQuery(schemaList); + + buildAlignedMemChunkHandle( + alignedTVListCopy, deletionList, schemaList, chunkMetadataList, memChunkHandleMap); + } + + private void getMemAlignedChunkHandleFromMemTable( + String deviceID, + AlignedWritableMemChunkGroup writableMemChunkGroup, + Map<String, List<IChunkMetadata>> chunkMetadataList, + Map<String, List<IChunkHandle>> memChunkHandleMap, + long ttlLowerBound, + List<Pair<Modification, IMemTable>> modsToMemTabled) { + + AlignedWritableMemChunk memChunk = writableMemChunkGroup.getAlignedMemChunk(); + List<IMeasurementSchema> schemaList = memChunk.getSchemaList(); + + AlignedTVList alignedTVListCopy = (AlignedTVList) memChunk.getSortedTvListForQuery(schemaList); + + List<List<TimeRange>> deletionList = new ArrayList<>(); + for (IMeasurementSchema schema : schemaList) { + deletionList.add( + ModificationUtils.constructDeletionList( + deviceID, schema.getMeasurementId(), this, modsToMemTabled, ttlLowerBound)); + } + buildAlignedMemChunkHandle( + alignedTVListCopy, deletionList, schemaList, chunkMetadataList, memChunkHandleMap); + } + + private void getMemChunkHandleFromMemTable( + String deviceID, + WritableMemChunkGroup writableMemChunkGroup, + Map<String, List<IChunkMetadata>> chunkMetadataMap, + Map<String, List<IChunkHandle>> memChunkHandleMap, + long ttlLowerBound, + List<Pair<Modification, IMemTable>> modsToMemTabled) { + + for (Entry<String, IWritableMemChunk> entry : + writableMemChunkGroup.getMemChunkMap().entrySet()) { + + IWritableMemChunk writableMemChunk = entry.getValue(); + TVList tvListCopy = writableMemChunk.getSortedTvListForQuery(); + + List<TimeRange> deletionList = new ArrayList<>(); + if (modsToMemTabled != null) { + deletionList = + ModificationUtils.constructDeletionList( + deviceID, entry.getKey(), this, modsToMemTabled, ttlLowerBound); + } + long[] timestamps = filterDeletedTimestamp(tvListCopy, deletionList); + + String measurementId = entry.getKey(); + chunkMetadataMap + .computeIfAbsent(measurementId, k -> new ArrayList<>()) + .add( + buildChunkMetaDataForMemoryChunk( + measurementId, + timestamps[0], + timestamps[timestamps.length - 1], + Collections.emptyList())); + memChunkHandleMap + .computeIfAbsent(measurementId, k -> new ArrayList<>()) + .add(new MemChunkHandleImpl(timestamps)); + } + } + + private void buildAlignedMemChunkHandle( + AlignedTVList alignedTVList, + List<List<TimeRange>> deletionList, + List<IMeasurementSchema> schemaList, + Map<String, List<IChunkMetadata>> chunkMetadataList, + Map<String, List<IChunkHandle>> chunkHandleMap) { + + List<List<BitMap>> bitMaps = alignedTVList.getBitMaps(); + long[] timestamps = + alignedTVList.getTimestamps().stream().flatMapToLong(LongStream::of).toArray(); + for (int i = 0; i < schemaList.size(); i++) { + String measurement = schemaList.get(i).getMeasurementId(); + long[] startEndTime = calculateStartEndTime(timestamps, bitMaps.get(i)); + chunkMetadataList + .computeIfAbsent(measurement, k -> new ArrayList<>()) + .add( + buildChunkMetaDataForMemoryChunk( + measurement, startEndTime[0], startEndTime[1], deletionList.get(i))); + chunkHandleMap + .computeIfAbsent(measurement, k -> new ArrayList<>()) + .add( + new MemAlignedChunkHandleImpl( + timestamps, bitMaps.get(i), deletionList.get(i), startEndTime)); + } + } + + private long[] calculateStartEndTime(long[] timestamps, List<BitMap> bitMaps) { + long startTime = -1; + for (int i = 0; i < bitMaps.size(); i++) { + BitMap bitMap = bitMaps.get(i); + for (int j = 0; j < bitMap.getSize(); j++) { + if (!bitMap.isMarked(j)) { + startTime = timestamps[i]; + break; + } + } + if (startTime != -1) { + break; + } + } + + long endTime = -1; + for (int i = bitMaps.size() - 1; i >= 0; i--) { + BitMap bitMap = bitMaps.get(i); + for (int j = bitMap.getSize() - 1; j >= 0; j--) { + if (!bitMap.isMarked(j)) { + endTime = timestamps[i]; + break; + } + } + if (endTime != -1) { + break; + } + } + return new long[] {startTime, endTime}; + } + + private IChunkMetadata buildChunkMetaDataForMemoryChunk( + String measurement, long startTime, long endTime, List<TimeRange> deletionList) { + TimeStatistics timeStatistics = new TimeStatistics(); + timeStatistics.setStartTime(startTime); + timeStatistics.setEndTime(endTime); + IChunkMetadata chunkMetadata = Review Comment: I think dataType here is not important, and in AlignedReadOnlyMemChunk, timeStatistics is defined as VECTOR. ########## iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/memtable/AbstractMemTable.java: ########## @@ -465,6 +481,278 @@ public ReadOnlyMemChunk query( .getReadOnlyMemChunkFromMemTable(context, this, modsToMemtable, ttlLowerBound); } + @Override + public void queryForSeriesRegionScan( + PartialPath fullPath, + long ttlLowerBound, + Map<String, List<IChunkMetadata>> chunkMetaDataMap, + Map<String, List<IChunkHandle>> memChunkHandleMap, + List<Pair<Modification, IMemTable>> modsToMemTabled) { + + IDeviceID deviceID = DeviceIDFactory.getInstance().getDeviceID(fullPath.getDevicePath()); + String measurementId = fullPath.getMeasurement(); + Map<IDeviceID, IWritableMemChunkGroup> memTableMap = getMemTableMap(); + + // check If MemTable Contains this path + if (!memTableMap.containsKey(deviceID) || !memTableMap.get(deviceID).contains(measurementId)) { + return; + } + + if (fullPath instanceof MeasurementPath) { + List<TimeRange> deletionList = new ArrayList<>(); + if (modsToMemTabled != null) { + deletionList = + ModificationUtils.constructDeletionList( + (MeasurementPath) fullPath, this, modsToMemTabled, ttlLowerBound); + } + getMemChunkHandleFromMemTable( + deviceID, measurementId, chunkMetaDataMap, memChunkHandleMap, deletionList); + } else { + List<List<TimeRange>> deletionList = new ArrayList<>(); + if (modsToMemTabled != null) { + deletionList = + ModificationUtils.constructDeletionList( + (AlignedPath) fullPath, this, modsToMemTabled, ttlLowerBound); + } + + getMemAlignedChunkHandleFromMemTable( + deviceID, + ((AlignedPath) fullPath).getSchemaList(), + chunkMetaDataMap, + memChunkHandleMap, + deletionList); + } + } + + @Override + public void queryForDeviceRegionScan( + IDeviceID deviceID, + boolean isAligned, + long ttlLowerBound, + Map<String, List<IChunkMetadata>> chunkMetadataMap, + Map<String, List<IChunkHandle>> memChunkHandleMap, + List<Pair<Modification, IMemTable>> modsToMemTabled) + throws MetadataException { + + Map<IDeviceID, IWritableMemChunkGroup> memTableMap = getMemTableMap(); + + // check If MemTable Contains this path + if (!memTableMap.containsKey(deviceID)) { + return; + } + + IWritableMemChunkGroup writableMemChunkGroup = memTableMap.get(deviceID); + if (isAligned) { + getMemAlignedChunkHandleFromMemTable( + ((PlainDeviceID) deviceID).toStringID(), + (AlignedWritableMemChunkGroup) writableMemChunkGroup, + chunkMetadataMap, + memChunkHandleMap, + ttlLowerBound, + modsToMemTabled); + } else { + getMemChunkHandleFromMemTable( + ((PlainDeviceID) deviceID).toStringID(), + (WritableMemChunkGroup) writableMemChunkGroup, + chunkMetadataMap, + memChunkHandleMap, + ttlLowerBound, + modsToMemTabled); + } + } + + private void getMemChunkHandleFromMemTable( + IDeviceID deviceID, + String measurementId, + Map<String, List<IChunkMetadata>> chunkMetadataMap, + Map<String, List<IChunkHandle>> memChunkHandleMap, + List<TimeRange> deletionList) { + + IWritableMemChunk memChunk = memTableMap.get(deviceID).getMemChunkMap().get(measurementId); + + TVList tvListCopy = memChunk.getSortedTvListForQuery(); + long[] timestamps = filterDeletedTimestamp(tvListCopy, deletionList); + + chunkMetadataMap + .computeIfAbsent(measurementId, k -> new ArrayList<>()) + .add( + buildChunkMetaDataForMemoryChunk( + measurementId, + timestamps[0], + timestamps[timestamps.length - 1], + Collections.emptyList())); + memChunkHandleMap + .computeIfAbsent(measurementId, k -> new ArrayList<>()) + .add(new MemChunkHandleImpl(timestamps)); + } + + private void getMemAlignedChunkHandleFromMemTable( + IDeviceID deviceID, + List<IMeasurementSchema> schemaList, + Map<String, List<IChunkMetadata>> chunkMetadataList, + Map<String, List<IChunkHandle>> memChunkHandleMap, + List<List<TimeRange>> deletionList) { + + AlignedWritableMemChunk alignedMemChunk = + ((AlignedWritableMemChunkGroup) memTableMap.get(deviceID)).getAlignedMemChunk(); + AlignedTVList alignedTVListCopy = + (AlignedTVList) alignedMemChunk.getSortedTvListForQuery(schemaList); + + buildAlignedMemChunkHandle( + alignedTVListCopy, deletionList, schemaList, chunkMetadataList, memChunkHandleMap); + } + + private void getMemAlignedChunkHandleFromMemTable( + String deviceID, + AlignedWritableMemChunkGroup writableMemChunkGroup, + Map<String, List<IChunkMetadata>> chunkMetadataList, + Map<String, List<IChunkHandle>> memChunkHandleMap, + long ttlLowerBound, + List<Pair<Modification, IMemTable>> modsToMemTabled) { + + AlignedWritableMemChunk memChunk = writableMemChunkGroup.getAlignedMemChunk(); + List<IMeasurementSchema> schemaList = memChunk.getSchemaList(); + + AlignedTVList alignedTVListCopy = (AlignedTVList) memChunk.getSortedTvListForQuery(schemaList); + + List<List<TimeRange>> deletionList = new ArrayList<>(); + for (IMeasurementSchema schema : schemaList) { + deletionList.add( + ModificationUtils.constructDeletionList( + deviceID, schema.getMeasurementId(), this, modsToMemTabled, ttlLowerBound)); + } + buildAlignedMemChunkHandle( + alignedTVListCopy, deletionList, schemaList, chunkMetadataList, memChunkHandleMap); + } + + private void getMemChunkHandleFromMemTable( + String deviceID, + WritableMemChunkGroup writableMemChunkGroup, + Map<String, List<IChunkMetadata>> chunkMetadataMap, + Map<String, List<IChunkHandle>> memChunkHandleMap, + long ttlLowerBound, + List<Pair<Modification, IMemTable>> modsToMemTabled) { + + for (Entry<String, IWritableMemChunk> entry : + writableMemChunkGroup.getMemChunkMap().entrySet()) { + + IWritableMemChunk writableMemChunk = entry.getValue(); + TVList tvListCopy = writableMemChunk.getSortedTvListForQuery(); + + List<TimeRange> deletionList = new ArrayList<>(); + if (modsToMemTabled != null) { + deletionList = + ModificationUtils.constructDeletionList( + deviceID, entry.getKey(), this, modsToMemTabled, ttlLowerBound); + } + long[] timestamps = filterDeletedTimestamp(tvListCopy, deletionList); + + String measurementId = entry.getKey(); + chunkMetadataMap + .computeIfAbsent(measurementId, k -> new ArrayList<>()) + .add( + buildChunkMetaDataForMemoryChunk( + measurementId, + timestamps[0], + timestamps[timestamps.length - 1], + Collections.emptyList())); + memChunkHandleMap + .computeIfAbsent(measurementId, k -> new ArrayList<>()) + .add(new MemChunkHandleImpl(timestamps)); + } + } + + private void buildAlignedMemChunkHandle( + AlignedTVList alignedTVList, + List<List<TimeRange>> deletionList, + List<IMeasurementSchema> schemaList, + Map<String, List<IChunkMetadata>> chunkMetadataList, + Map<String, List<IChunkHandle>> chunkHandleMap) { + + List<List<BitMap>> bitMaps = alignedTVList.getBitMaps(); + long[] timestamps = + alignedTVList.getTimestamps().stream().flatMapToLong(LongStream::of).toArray(); + for (int i = 0; i < schemaList.size(); i++) { + String measurement = schemaList.get(i).getMeasurementId(); + long[] startEndTime = calculateStartEndTime(timestamps, bitMaps.get(i)); + chunkMetadataList + .computeIfAbsent(measurement, k -> new ArrayList<>()) + .add( + buildChunkMetaDataForMemoryChunk( Review Comment: The original intention of this design was to unify the implementation of getAllChunkMetaData in UnClosedFileScanHandle. ########## iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/memtable/AbstractMemTable.java: ########## @@ -465,6 +481,278 @@ public ReadOnlyMemChunk query( .getReadOnlyMemChunkFromMemTable(context, this, modsToMemtable, ttlLowerBound); } + @Override + public void queryForSeriesRegionScan( + PartialPath fullPath, + long ttlLowerBound, + Map<String, List<IChunkMetadata>> chunkMetaDataMap, + Map<String, List<IChunkHandle>> memChunkHandleMap, + List<Pair<Modification, IMemTable>> modsToMemTabled) { + + IDeviceID deviceID = DeviceIDFactory.getInstance().getDeviceID(fullPath.getDevicePath()); + String measurementId = fullPath.getMeasurement(); + Map<IDeviceID, IWritableMemChunkGroup> memTableMap = getMemTableMap(); + + // check If MemTable Contains this path + if (!memTableMap.containsKey(deviceID) || !memTableMap.get(deviceID).contains(measurementId)) { + return; + } + + if (fullPath instanceof MeasurementPath) { + List<TimeRange> deletionList = new ArrayList<>(); + if (modsToMemTabled != null) { + deletionList = + ModificationUtils.constructDeletionList( + (MeasurementPath) fullPath, this, modsToMemTabled, ttlLowerBound); + } + getMemChunkHandleFromMemTable( + deviceID, measurementId, chunkMetaDataMap, memChunkHandleMap, deletionList); + } else { + List<List<TimeRange>> deletionList = new ArrayList<>(); + if (modsToMemTabled != null) { + deletionList = + ModificationUtils.constructDeletionList( + (AlignedPath) fullPath, this, modsToMemTabled, ttlLowerBound); + } + + getMemAlignedChunkHandleFromMemTable( + deviceID, + ((AlignedPath) fullPath).getSchemaList(), + chunkMetaDataMap, + memChunkHandleMap, + deletionList); + } + } + + @Override + public void queryForDeviceRegionScan( + IDeviceID deviceID, + boolean isAligned, + long ttlLowerBound, + Map<String, List<IChunkMetadata>> chunkMetadataMap, + Map<String, List<IChunkHandle>> memChunkHandleMap, + List<Pair<Modification, IMemTable>> modsToMemTabled) + throws MetadataException { + + Map<IDeviceID, IWritableMemChunkGroup> memTableMap = getMemTableMap(); + + // check If MemTable Contains this path + if (!memTableMap.containsKey(deviceID)) { + return; + } + + IWritableMemChunkGroup writableMemChunkGroup = memTableMap.get(deviceID); + if (isAligned) { + getMemAlignedChunkHandleFromMemTable( + ((PlainDeviceID) deviceID).toStringID(), + (AlignedWritableMemChunkGroup) writableMemChunkGroup, + chunkMetadataMap, + memChunkHandleMap, + ttlLowerBound, + modsToMemTabled); + } else { + getMemChunkHandleFromMemTable( + ((PlainDeviceID) deviceID).toStringID(), + (WritableMemChunkGroup) writableMemChunkGroup, + chunkMetadataMap, + memChunkHandleMap, + ttlLowerBound, + modsToMemTabled); + } + } + + private void getMemChunkHandleFromMemTable( + IDeviceID deviceID, + String measurementId, + Map<String, List<IChunkMetadata>> chunkMetadataMap, + Map<String, List<IChunkHandle>> memChunkHandleMap, + List<TimeRange> deletionList) { + + IWritableMemChunk memChunk = memTableMap.get(deviceID).getMemChunkMap().get(measurementId); + + TVList tvListCopy = memChunk.getSortedTvListForQuery(); + long[] timestamps = filterDeletedTimestamp(tvListCopy, deletionList); + + chunkMetadataMap + .computeIfAbsent(measurementId, k -> new ArrayList<>()) + .add( + buildChunkMetaDataForMemoryChunk( + measurementId, + timestamps[0], + timestamps[timestamps.length - 1], + Collections.emptyList())); + memChunkHandleMap + .computeIfAbsent(measurementId, k -> new ArrayList<>()) + .add(new MemChunkHandleImpl(timestamps)); + } + + private void getMemAlignedChunkHandleFromMemTable( + IDeviceID deviceID, + List<IMeasurementSchema> schemaList, + Map<String, List<IChunkMetadata>> chunkMetadataList, + Map<String, List<IChunkHandle>> memChunkHandleMap, + List<List<TimeRange>> deletionList) { + + AlignedWritableMemChunk alignedMemChunk = + ((AlignedWritableMemChunkGroup) memTableMap.get(deviceID)).getAlignedMemChunk(); + AlignedTVList alignedTVListCopy = + (AlignedTVList) alignedMemChunk.getSortedTvListForQuery(schemaList); + + buildAlignedMemChunkHandle( + alignedTVListCopy, deletionList, schemaList, chunkMetadataList, memChunkHandleMap); + } + + private void getMemAlignedChunkHandleFromMemTable( + String deviceID, + AlignedWritableMemChunkGroup writableMemChunkGroup, + Map<String, List<IChunkMetadata>> chunkMetadataList, + Map<String, List<IChunkHandle>> memChunkHandleMap, + long ttlLowerBound, + List<Pair<Modification, IMemTable>> modsToMemTabled) { + + AlignedWritableMemChunk memChunk = writableMemChunkGroup.getAlignedMemChunk(); + List<IMeasurementSchema> schemaList = memChunk.getSchemaList(); + + AlignedTVList alignedTVListCopy = (AlignedTVList) memChunk.getSortedTvListForQuery(schemaList); Review Comment: We don't have measurement info here. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
