Allow TermsEnum to express a preference for seekExact to FrozenBufferedUpdates (#15636)

For Terms implementations that have an approximate membership filter, the current scheme of repeated
seekCeil() calls when evaluating update/deletion terms can cause the membership filter to be skipped as
we must provide the term lexically after the target on a miss. Allow TermsEnum to express a preference for 
seekExact() so that approximate membership filters still work in this case.

Implement preferSeekExact() in BloomFilteringPostingsFormat where there is obvious benefit.

Author: mccullocht

lucene/CHANGES.txt

@@ -181,6 +181,9 @@ API Changes
 * GITHUB#15663: Allow subclasses of NumericComparator to implement their own
   CompetitiveDISIBuilder subtypes. (Alan Woodward)
 
+* GITHUB#15636: Introduce TermsEnum.preferSeekExact(). Update and delete processing obey this setting,
+  allowing bloom or other approximate membership filters to apply in these paths. (Trevor McCulloch)
+
 New Features
 ---------------------
 (No changes)

lucene/codecs/src/java/org/apache/lucene/codecs/bloom/BloomFilteringPostingsFormat.java

@@ -373,6 +373,13 @@ public ImpactsEnum impacts(int flags) throws IOException {
         return delegate().impacts(flags);
       }
 
+      @Override
+      public boolean preferSeekExact() {
+        // Prefer seekExact() to seekCeil() when processing updates and deletes,
+        // since seekExact() passes through the bloom filter.
+        return true;
+      }
+
       @Override
       public String toString() {
         return getClass().getSimpleName() + "(filter=" + filter.toString() + ")";

lucene/core/src/java/org/apache/lucene/index/FrozenBufferedUpdates.java

@@ -583,7 +583,7 @@ private void setField(String field) throws IOException {
     DocIdSetIterator nextTerm(String field, BytesRef term) throws IOException {
       setField(field);
       if (termsEnum != null) {
-        if (sortedTerms) {
+        if (sortedTerms && !termsEnum.preferSeekExact()) {
           assert assertSorted(term);
           // in the sorted case we can take advantage of the "seeking forward" property
           // this allows us depending on the term dict impl to reuse data-structures internally

lucene/core/src/java/org/apache/lucene/index/TermsEnum.java

@@ -188,6 +188,17 @@ public final PostingsEnum postings(PostingsEnum reuse) throws IOException {
    */
   public abstract TermState termState() throws IOException;
 
+  /**
+   * Expert: prefer using seekExact() to seekCeil().
+   *
+   * <p>This is consumed within Lucene when performing key lookups for update and delete operations.
+   * Override this for implementations that use an approximate membership filter to ensure that the
+   * membership filter is consulted.
+   */
+  public boolean preferSeekExact() {
+    return false;
+  }
+
   /**
    * An empty TermsEnum for quickly returning an empty instance e.g. in {@link
    * org.apache.lucene.search.MultiTermQuery}
@@ -196,11 +207,10 @@ public final PostingsEnum postings(PostingsEnum reuse) throws IOException {
    * Attributes to it. This should not be a problem, as the enum is always empty and the existence
    * of unused Attributes does not matter.
    */
-  // Avoid refactoring that results in a dependency on a subclass, like BaseTermsEnum.
-  // See: https://github.com/apache/lucene/issues/15317
+  // Avoid refactoring that results in a dependency on a subclass, like
+  // BaseTermsEnum. See: https://github.com/apache/lucene/issues/15317
   public static final TermsEnum EMPTY =
       new TermsEnum() {
-
         private AttributeSource atts;
 
         @Override

lucene/core/src/test/org/apache/lucene/index/TestFrozenBufferedUpdates.java

@@ -39,6 +39,36 @@
 import org.apache.lucene.util.FixedBitSet;
 
 public class TestFrozenBufferedUpdates extends LuceneTestCase {
+  private static class PreferSeekExactLeafReader extends FilterLeafReader {
+    public PreferSeekExactLeafReader(LeafReader in) {
+      super(in);
+    }
+
+    @Override
+    public Terms terms(String field) throws IOException {
+      return new FilterTerms(in.terms(field)) {
+        @Override
+        public TermsEnum iterator() throws IOException {
+          return new FilterTermsEnum(in.iterator()) {
+            @Override
+            public boolean preferSeekExact() {
+              return true;
+            }
+          };
+        }
+      };
+    }
+
+    @Override
+    public IndexReader.CacheHelper getCoreCacheHelper() {
+      return this.in.getCoreCacheHelper();
+    }
+
+    @Override
+    public IndexReader.CacheHelper getReaderCacheHelper() {
+      return this.in.getReaderCacheHelper();
+    }
+  }
 
   public void testTermDocsIterator() throws IOException {
     for (int j = 0; j < 5; j++) {
@@ -76,10 +106,15 @@ public void testTermDocsIterator() throws IOException {
         writer.commit();
         try (DirectoryReader reader = DirectoryReader.open(dir)) {
           boolean sorted = random().nextBoolean();
+          boolean preferSeekExact = random().nextBoolean();
           BytesRefIterator values =
               sorted ? array.iterator(Comparator.naturalOrder()) : array.iterator();
           assertEquals(1, reader.leaves().size());
-          TermDocsIterator iterator = new TermDocsIterator(reader.leaves().get(0).reader(), sorted);
+          LeafReader leafReader = reader.leaves().get(0).reader();
+          if (preferSeekExact) {
+            leafReader = new PreferSeekExactLeafReader(leafReader);
+          }
+          TermDocsIterator iterator = new TermDocsIterator(leafReader, sorted);
           FixedBitSet bitSet = new FixedBitSet(reader.maxDoc());
           BytesRef ref;
           while ((ref = values.next()) != null) {