aokolnychyi commented on code in PR #9251:
URL: https://github.com/apache/iceberg/pull/9251#discussion_r1427628834


##########
core/src/main/java/org/apache/iceberg/DeleteFileIndex.java:
##########
@@ -582,93 +513,187 @@ private 
Iterable<CloseableIterable<ManifestEntry<DeleteFile>>> deleteManifestRea
     }
   }
 
-  // a group of indexed delete files sorted by the sequence number they apply 
to
-  private static class DeleteFileGroup {
-    private final long[] seqs;
-    private final IndexedDeleteFile[] files;
-
-    DeleteFileGroup(IndexedDeleteFile[] files) {
-      this.seqs = 
Arrays.stream(files).mapToLong(IndexedDeleteFile::applySequenceNumber).toArray();
-      this.files = files;
+  private static int findStartIndex(long[] seqs, long seq) {
+    int pos = Arrays.binarySearch(seqs, seq);
+    int start;
+    if (pos < 0) {
+      // the sequence number was not found, where it would be inserted is 
-(pos + 1)
+      start = -(pos + 1);
+    } else {
+      // the sequence number was found, but may not be the first
+      // find the first delete file with the given sequence number by 
decrementing the position
+      start = pos;
+      while (start > 0 && seqs[start - 1] >= seq) {
+        start -= 1;
+      }
     }
 
-    DeleteFileGroup(long[] seqs, IndexedDeleteFile[] files) {
-      this.seqs = seqs;
-      this.files = files;
+    return start;
+  }
+
+  private static DeleteFile[] concat(DeleteFile[]... deletes) {
+    return ArrayUtil.concat(DeleteFile.class, deletes);
+  }
+
+  // a group of position delete files sorted by the sequence number they apply 
to
+  private static class PositionDeletes {
+    private static final Comparator<DeleteFile> SEQ_COMPARATOR =
+        Comparator.comparingLong(DeleteFile::dataSequenceNumber);
+
+    private long[] seqs = null;
+    private DeleteFile[] files = null;
+    private volatile List<DeleteFile> buffer = Lists.newArrayList();

Review Comment:
   I do like using `System.arraycopy` and binary search on arrays for lookups. 
I don't think we will beat that in terms of performance. The extra pass will 
also be expensive for path-based deletes and it will mean indexing of all 
deletes rather than indexing only what's covered by the query.
   
   Let me start with a few comments and a precondition. I am going to think 
more about this.



-- 
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: issues-unsubscr...@iceberg.apache.org

For queries about this service, please contact Infrastructure at:
us...@infra.apache.org


---------------------------------------------------------------------
To unsubscribe, e-mail: issues-unsubscr...@iceberg.apache.org
For additional commands, e-mail: issues-h...@iceberg.apache.org

Reply via email to