Replace the key in FileReaderManager to TsFileID

Author: shuwenwei

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/buffer/BloomFilterCache.java

@@ -210,7 +210,12 @@ public BloomFilter apply(BloomFilterCacheKey bloomFilterCacheKey) {
       try {
         cacheMiss = true;
         TsFileSequenceReader reader =
-            FileReaderManager.getInstance().get(bloomFilterCacheKey.filePath, true, ioSizeRecorder);
+            FileReaderManager.getInstance()
+                .get(
+                    bloomFilterCacheKey.filePath,
+                    bloomFilterCacheKey.tsFileID,
+                    true,
+                    ioSizeRecorder);
         return reader.readBloomFilter(ioSizeRecorder);
       } catch (IOException e) {
         throw new IoTDBIORuntimeException(e);

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/buffer/ChunkCache.java

@@ -307,7 +307,8 @@ public Chunk apply(ChunkCacheKey key) {
       try {
         cacheMiss = true;
         TsFileSequenceReader reader =
-            FileReaderManager.getInstance().get(key.getFilePath(), key.closed, ioSizeRecorder);
+            FileReaderManager.getInstance()
+                .get(key.getFilePath(), key.tsFileID, key.closed, ioSizeRecorder);
         Chunk chunk = reader.readMemChunk(key.offsetOfChunkHeader, ioSizeRecorder);
         // to save memory footprint, we don't save measurementId in ChunkHeader of Chunk
         chunk.getHeader().setMeasurementID(null);

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/buffer/TimeSeriesMetadataCache.java

@@ -132,7 +132,8 @@ public TimeseriesMetadata get(
 
         // bloom filter part
         TsFileSequenceReader reader =
-            FileReaderManager.getInstance().get(filePath, true, bloomFilterIoSizeRecorder);
+            FileReaderManager.getInstance()
+                .get(filePath, key.tsFileID, true, bloomFilterIoSizeRecorder);
         BloomFilter bloomFilter = reader.readBloomFilter(bloomFilterIoSizeRecorder);
         queryContext.getQueryStatistics().getLoadBloomFilterFromDiskCount().incrementAndGet();
         if (bloomFilter != null
@@ -193,7 +194,7 @@ public TimeseriesMetadata get(
             loadBloomFilterTime = System.nanoTime() - loadBloomFilterStartTime;
             TsFileSequenceReader reader =
                 FileReaderManager.getInstance()
-                    .get(filePath, true, timeSeriesMetadataIoSizeRecorder);
+                    .get(filePath, key.tsFileID, true, timeSeriesMetadataIoSizeRecorder);
             List<TimeseriesMetadata> timeSeriesMetadataList =
                 reader.readTimeseriesMetadata(
                     key.device,

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java

@@ -2998,7 +2998,7 @@ private void settleTsFileCallBack(
       if (!oldTsFileResource.getTsFile().exists()) {
         tsFileManager.remove(oldTsFileResource, oldTsFileResource.isSeq());
       }
-      FileReaderManager.getInstance().closeFileAndRemoveReader(oldTsFileResource.getTsFilePath());
+      FileReaderManager.getInstance().closeFileAndRemoveReader(oldTsFileResource.getTsFileID());
       oldTsFileResource.setSettleTsFileCallBack(null);
       SettleService.getINSTANCE().getFilesToBeSettledCount().addAndGet(-1);
     } catch (IOException e) {

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/compaction/execute/utils/MultiTsFileDeviceIterator.java

@@ -121,7 +121,8 @@ public MultiTsFileDeviceIterator(
         this.tsFileResourcesSortedByDesc, TsFileResource::compareFileCreationOrderByDesc);
     for (TsFileResource tsFileResource : tsFileResourcesSortedByDesc) {
       TsFileSequenceReader reader =
-          FileReaderManager.getInstance().get(tsFileResource.getTsFilePath(), true);
+          FileReaderManager.getInstance()
+              .get(tsFileResource.getTsFilePath(), tsFileResource.getTsFileID(), true);
       readerMap.put(tsFileResource, reader);
       deviceIteratorMap.put(tsFileResource, reader.getAllDevicesIteratorWithIsAligned());
     }

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/compaction/execute/utils/writer/ReadPointCrossCompactionWriter.java

@@ -73,7 +73,8 @@ public void write(TsBlock tsBlock, int subTaskId) throws IOException {
 
   @Override
   protected TsFileSequenceReader getFileReader(TsFileResource resource) throws IOException {
-    return FileReaderManager.getInstance().get(resource.getTsFilePath(), true);
+    return FileReaderManager.getInstance()
+        .get(resource.getTsFilePath(), resource.getTsFileID(), true);
   }
 
   @Override

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/memtable/TsFileProcessor.java

@@ -1825,6 +1825,7 @@ private void processAlignedChunkMetaDataFromFlushedMemTable(
                   deviceID,
                   measurement,
                   filePath,
+                  tsFileResource.getTsFileID(),
                   false,
                   valueChunkMetaData.getOffsetOfChunkHeader(),
                   valueChunkMetaData.getStatistics(),
@@ -1849,6 +1850,7 @@ private void processChunkMetaDataFromFlushedMemTable(
                 deviceID,
                 measurement,
                 filePath,
+                tsFileResource.getTsFileID(),
                 false,
                 chunkMetadata.getOffsetOfChunkHeader(),
                 chunkMetadata.getStatistics()));

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/control/FileReaderManager.java

@@ -20,6 +20,7 @@
 package org.apache.iotdb.db.storageengine.dataregion.read.control;
 
 import org.apache.iotdb.commons.utils.TestOnly;
+import org.apache.iotdb.db.storageengine.dataregion.tsfile.TsFileID;
 import org.apache.iotdb.db.storageengine.dataregion.tsfile.TsFileResource;
 
 import org.apache.tsfile.read.TsFileSequenceReader;
@@ -57,25 +58,25 @@ public class FileReaderManager {
    * the key of closedFileReaderMap is the file path and the value of closedFileReaderMap is the
    * corresponding reader.
    */
-  private Map<String, TsFileSequenceReader> closedFileReaderMap;
+  private Map<TsFileID, TsFileSequenceReader> closedFileReaderMap;
 
   /**
    * the key of unclosedFileReaderMap is the file path and the value of unclosedFileReaderMap is the
    * corresponding reader.
    */
-  private Map<String, TsFileSequenceReader> unclosedFileReaderMap;
+  private Map<TsFileID, TsFileSequenceReader> unclosedFileReaderMap;
 
   /**
    * the key of closedFileReaderMap is the file path and the value of closedFileReaderMap is the
    * file's reference count.
    */
-  private Map<String, AtomicInteger> closedReferenceMap;
+  private Map<TsFileID, AtomicInteger> closedReferenceMap;
 
   /**
    * the key of unclosedFileReaderMap is the file path and the value of unclosedFileReaderMap is the
    * file's reference count.
    */
-  private Map<String, AtomicInteger> unclosedReferenceMap;
+  private Map<TsFileID, AtomicInteger> unclosedReferenceMap;
 
   private FileReaderManager() {
     closedFileReaderMap = new ConcurrentHashMap<>();
@@ -88,14 +89,14 @@ public static FileReaderManager getInstance() {
     return FileReaderManagerHelper.INSTANCE;
   }
 
-  public synchronized void closeFileAndRemoveReader(String filePath) throws IOException {
-    closedReferenceMap.remove(filePath);
-    TsFileSequenceReader reader = closedFileReaderMap.remove(filePath);
+  public synchronized void closeFileAndRemoveReader(TsFileID tsFileID) throws IOException {
+    closedReferenceMap.remove(tsFileID);
+    TsFileSequenceReader reader = closedFileReaderMap.remove(tsFileID);
     if (reader != null) {
       reader.close();
     }
-    unclosedReferenceMap.remove(filePath);
-    reader = unclosedFileReaderMap.remove(filePath);
+    unclosedReferenceMap.remove(tsFileID);
+    reader = unclosedFileReaderMap.remove(tsFileID);
     if (reader != null) {
       reader.close();
     }
@@ -106,35 +107,38 @@ public synchronized void closeFileAndRemoveReader(String filePath) throws IOExce
    * exists, just get it from closedFileReaderMap or unclosedFileReaderMap depending on isClosing .
    * Otherwise a new reader will be created and cached.
    *
-   * @param filePath the path of the file, of which the reader is desired.
+   * @param filePath the path of the tsfile
+   * @param tsFileID the id of the tsfile, of which the reader is desired.
    * @param isClosed whether the corresponding file still receives insertions or not.
    * @return the reader of the file specified by filePath.
    * @throws IOException when reader cannot be created.
    */
   @SuppressWarnings("squid:S2095")
-  public synchronized TsFileSequenceReader get(String filePath, boolean isClosed)
+  public synchronized TsFileSequenceReader get(String filePath, TsFileID tsFileID, boolean isClosed)
       throws IOException {
-    return get(filePath, isClosed, null);
+    return get(filePath, tsFileID, isClosed, null);
   }
 
   /**
    * Get the reader of the file(tsfile or unseq tsfile) indicated by filePath. If the reader already
    * exists, just get it from closedFileReaderMap or unclosedFileReaderMap depending on isClosing .
    * Otherwise a new reader will be created and cached.
    *
-   * @param filePath the path of the file, of which the reader is desired.
+   * @param filePath the path of the tsfile
+   * @param tsFileID the id of the tsfile, of which the reader is desired.
    * @param isClosed whether the corresponding file still receives insertions or not.
    * @param ioSizeRecorder can be null
    * @return the reader of the file specified by filePath.
    * @throws IOException when reader cannot be created.
    */
   @SuppressWarnings("squid:S2095")
   public synchronized TsFileSequenceReader get(
-      String filePath, boolean isClosed, LongConsumer ioSizeRecorder) throws IOException {
+      String filePath, TsFileID tsFileID, boolean isClosed, LongConsumer ioSizeRecorder)
+      throws IOException {
 
-    Map<String, TsFileSequenceReader> readerMap =
+    Map<TsFileID, TsFileSequenceReader> readerMap =
         !isClosed ? unclosedFileReaderMap : closedFileReaderMap;
-    if (!readerMap.containsKey(filePath)) {
+    if (!readerMap.containsKey(tsFileID)) {
       int currentOpenedReaderCount = readerMap.size();
       if (currentOpenedReaderCount >= MAX_CACHED_FILE_SIZE
           && (currentOpenedReaderCount % PRINT_INTERVAL == 0)) {
@@ -149,11 +153,11 @@ public synchronized TsFileSequenceReader get(
         // already do the version check in TsFileSequenceReader's constructor
         tsFileReader = new TsFileSequenceReader(filePath, ioSizeRecorder);
       }
-      readerMap.put(filePath, tsFileReader);
+      readerMap.put(tsFileID, tsFileReader);
       return tsFileReader;
     }
 
-    return readerMap.get(filePath);
+    return readerMap.get(tsFileID);
   }
 
   /**
@@ -165,11 +169,11 @@ public void increaseFileReaderReference(TsFileResource tsFile, boolean isClosed)
     synchronized (this) {
       if (!isClosed) {
         unclosedReferenceMap
-            .computeIfAbsent(tsFile.getTsFilePath(), k -> new AtomicInteger())
+            .computeIfAbsent(tsFile.getTsFileID(), k -> new AtomicInteger())
             .getAndIncrement();
       } else {
         closedReferenceMap
-            .computeIfAbsent(tsFile.getTsFilePath(), k -> new AtomicInteger())
+            .computeIfAbsent(tsFile.getTsFileID(), k -> new AtomicInteger())
             .getAndIncrement();
       }
     }
@@ -181,38 +185,39 @@ public void increaseFileReaderReference(TsFileResource tsFile, boolean isClosed)
    */
   public void decreaseFileReaderReference(TsFileResource tsFile, boolean isClosed) {
     synchronized (this) {
-      if (!isClosed && unclosedReferenceMap.containsKey(tsFile.getTsFilePath())) {
-        if (unclosedReferenceMap.get(tsFile.getTsFilePath()).decrementAndGet() == 0) {
-          closeUnUsedReaderAndRemoveRef(tsFile.getTsFilePath(), false);
+      if (!isClosed && unclosedReferenceMap.containsKey(tsFile.getTsFileID())) {
+        if (unclosedReferenceMap.get(tsFile.getTsFileID()).decrementAndGet() == 0) {
+          closeUnUsedReaderAndRemoveRef(tsFile.getTsFilePath(), tsFile.getTsFileID(), false);
         }
-      } else if (closedReferenceMap.containsKey(tsFile.getTsFilePath())
-          && (closedReferenceMap.get(tsFile.getTsFilePath()).decrementAndGet() == 0)) {
-        closeUnUsedReaderAndRemoveRef(tsFile.getTsFilePath(), true);
+      } else if (closedReferenceMap.containsKey(tsFile.getTsFileID())
+          && (closedReferenceMap.get(tsFile.getTsFileID()).decrementAndGet() == 0)) {
+        closeUnUsedReaderAndRemoveRef(tsFile.getTsFilePath(), tsFile.getTsFileID(), true);
       }
     }
     tsFile.readUnlock();
   }
 
-  private void closeUnUsedReaderAndRemoveRef(String tsFilePath, boolean isClosed) {
-    Map<String, TsFileSequenceReader> readerMap =
+  private void closeUnUsedReaderAndRemoveRef(
+      String tsFilePath, TsFileID tsFileID, boolean isClosed) {
+    Map<TsFileID, TsFileSequenceReader> readerMap =
         isClosed ? closedFileReaderMap : unclosedFileReaderMap;
-    Map<String, AtomicInteger> refMap = isClosed ? closedReferenceMap : unclosedReferenceMap;
+    Map<TsFileID, AtomicInteger> refMap = isClosed ? closedReferenceMap : unclosedReferenceMap;
     synchronized (this) {
       // check ref num again
-      if (refMap.get(tsFilePath).get() != 0) {
+      if (refMap.get(tsFileID).get() != 0) {
         return;
       }
 
-      TsFileSequenceReader reader = readerMap.get(tsFilePath);
+      TsFileSequenceReader reader = readerMap.get(tsFileID);
       if (reader != null) {
         try {
           reader.close();
         } catch (IOException e) {
           logger.error("Can not close TsFileSequenceReader {} !", reader.getFileName(), e);
         }
       }
-      readerMap.remove(tsFilePath);
-      refMap.remove(tsFilePath);
+      readerMap.remove(tsFileID);
+      refMap.remove(tsFileID);
       if (resourceLogger.isDebugEnabled()) {
         resourceLogger.debug("{} TsFileReader is closed because of no reference.", tsFilePath);
       }
@@ -226,10 +231,10 @@ private void closeUnUsedReaderAndRemoveRef(String tsFilePath, boolean isClosed)
    * @throws IOException if failed to close file handlers, IOException will be thrown
    */
   public synchronized void closeAndRemoveAllOpenedReaders() throws IOException {
-    Iterator<Map.Entry<String, TsFileSequenceReader>> iterator =
+    Iterator<Map.Entry<TsFileID, TsFileSequenceReader>> iterator =
         closedFileReaderMap.entrySet().iterator();
     while (iterator.hasNext()) {
-      Map.Entry<String, TsFileSequenceReader> entry = iterator.next();
+      Map.Entry<TsFileID, TsFileSequenceReader> entry = iterator.next();
       entry.getValue().close();
       if (resourceLogger.isDebugEnabled()) {
         resourceLogger.debug("{} closedTsFileReader is closed.", entry.getKey());
@@ -239,7 +244,7 @@ public synchronized void closeAndRemoveAllOpenedReaders() throws IOException {
     }
     iterator = unclosedFileReaderMap.entrySet().iterator();
     while (iterator.hasNext()) {
-      Map.Entry<String, TsFileSequenceReader> entry = iterator.next();
+      Map.Entry<TsFileID, TsFileSequenceReader> entry = iterator.next();
       entry.getValue().close();
       if (resourceLogger.isDebugEnabled()) {
         resourceLogger.debug("{} unclosedTsFileReader is closed.", entry.getKey());
@@ -251,17 +256,17 @@ public synchronized void closeAndRemoveAllOpenedReaders() throws IOException {
 
   /** This method is only for unit tests. */
   public synchronized boolean contains(TsFileResource tsFile, boolean isClosed) {
-    return (isClosed && closedFileReaderMap.containsKey(tsFile.getTsFilePath()))
-        || (!isClosed && unclosedFileReaderMap.containsKey(tsFile.getTsFilePath()));
+    return (isClosed && closedFileReaderMap.containsKey(tsFile.getTsFileID()))
+        || (!isClosed && unclosedFileReaderMap.containsKey(tsFile.getTsFileID()));
   }
 
   @TestOnly
-  public Map<String, TsFileSequenceReader> getClosedFileReaderMap() {
+  public Map<TsFileID, TsFileSequenceReader> getClosedFileReaderMap() {
     return closedFileReaderMap;
   }
 
   @TestOnly
-  public Map<String, TsFileSequenceReader> getUnclosedFileReaderMap() {
+  public Map<TsFileID, TsFileSequenceReader> getUnclosedFileReaderMap() {
     return unclosedFileReaderMap;
   }
 

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/filescan/impl/ClosedFileScanHandleImpl.java

@@ -29,6 +29,7 @@
 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.DeviceChunkMetaData;
+import org.apache.iotdb.db.storageengine.dataregion.tsfile.TsFileID;
 import org.apache.iotdb.db.storageengine.dataregion.tsfile.TsFileResource;
 import org.apache.iotdb.db.storageengine.dataregion.tsfile.timeindex.ArrayDeviceTimeIndex;
 import org.apache.iotdb.db.storageengine.dataregion.tsfile.timeindex.ITimeIndex;
@@ -108,7 +109,8 @@ public boolean isTimeSeriesTimeDeleted(IDeviceID deviceID, String timeSeriesName
   @Override
   public Iterator<AbstractDeviceChunkMetaData> getAllDeviceChunkMetaData() throws IOException {
 
-    TsFileSequenceReader tsFileReader = FileReaderManager.getInstance().get(getFilePath(), true);
+    TsFileSequenceReader tsFileReader =
+        FileReaderManager.getInstance().get(getFilePath(), tsFileResource.getTsFileID(), true);
     TsFileDeviceIterator deviceIterator = tsFileReader.getAllDevicesIteratorWithIsAligned();
 
     List<AbstractDeviceChunkMetaData> deviceChunkMetaDataList = new LinkedList<>();
@@ -161,10 +163,12 @@ public Iterator<IChunkHandle> getChunkHandles(
       List<Statistics<? extends Serializable>> statisticsList,
       List<Integer> orderedIndexList) {
     String filePath = tsFileResource.getTsFilePath();
+    TsFileID tsFileID = tsFileResource.getTsFileID();
     List<IChunkHandle> chunkHandleList = new ArrayList<>();
     for (int i : orderedIndexList) {
       AbstractChunkOffset chunkOffset = chunkInfoList.get(i);
-      chunkHandleList.add(chunkOffset.generateChunkHandle(filePath, statisticsList.get(i)));
+      chunkHandleList.add(
+          chunkOffset.generateChunkHandle(filePath, tsFileID, statisticsList.get(i)));
     }
     return chunkHandleList.iterator();
   }

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/read/filescan/impl/DiskAlignedChunkHandleImpl.java

@@ -19,6 +19,7 @@
 
 package org.apache.iotdb.db.storageengine.dataregion.read.filescan.impl;
 
+import org.apache.iotdb.db.storageengine.dataregion.tsfile.TsFileID;
 import org.apache.iotdb.db.storageengine.dataregion.utils.SharedTimeDataBuffer;
 
 import org.apache.tsfile.encrypt.EncryptParameter;
@@ -45,11 +46,12 @@ public DiskAlignedChunkHandleImpl(
       IDeviceID deviceID,
       String measurement,
       String filePath,
+      TsFileID tsFileID,
       boolean isTsFileClosed,
       long offset,
       Statistics<? extends Serializable> chunkStatistic,
       SharedTimeDataBuffer sharedTimeDataBuffer) {
-    super(deviceID, measurement, filePath, isTsFileClosed, offset, chunkStatistic);
+    super(deviceID, measurement, filePath, tsFileID, isTsFileClosed, offset, chunkStatistic);
     this.sharedTimeDataBuffer = sharedTimeDataBuffer;
   }