Extract interface

Author: fcofdez

server/src/main/java/org/elasticsearch/index/codec/bloomfilter/ES93BloomFilterStoredFieldsFormat.java

@@ -275,7 +275,7 @@ private boolean isBloomFilterField(FieldInfo info) {
         }
 
         private void addToBloomFilter(FieldInfo info, BytesRef value) {
-            assert info.getName().equals(bloomFilterFieldName): "Expected " + bloomFilterFieldName + " but got " + info;
+            assert info.getName().equals(bloomFilterFieldName) : "Expected " + bloomFilterFieldName + " but got " + info;
             bloomFilterFieldInfo = info;
             var termHashes = hashTerm(value, hashes);
             for (int hash : termHashes) {
@@ -338,7 +338,7 @@ public long ramBytesUsed() {
         }
     }
 
-    public static class Reader extends StoredFieldsReader {
+    private static class Reader extends StoredFieldsReader implements BloomFilterProvider {
         @Nullable
         private final BloomFilterFieldReader bloomFilterFieldReader;
         private final StoredFieldsReader delegateReader;
@@ -386,8 +386,8 @@ public void document(int docID, StoredFieldVisitor visitor) throws IOException {
             delegateReader.document(docID, visitor);
         }
 
-        @Nullable
-        BloomFilterFieldReader getBloomFilterFieldReader() {
+        @Override
+        public BloomFilter getBloomFilter() throws IOException {
             return bloomFilterFieldReader;
         }
     }
@@ -418,21 +418,16 @@ static BloomFilterMetadata readFrom(IndexInput in, FieldInfos fieldInfos) throws
         }
     }
 
-    public static class BloomFilterFieldReader implements Closeable {
+    static class BloomFilterFieldReader implements BloomFilter {
         private final FieldInfo fieldInfo;
         private final IndexInput bloomFilterData;
         private final RandomAccessInput bloomFilterIn;
         private final int bloomFilterSizeInBits;
         private final int[] hashes;
 
         @Nullable
-        public static BloomFilterFieldReader open(
-            Directory directory,
-            SegmentInfo si,
-            FieldInfos fn,
-            IOContext context,
-            String segmentSuffix
-        ) throws IOException {
+        static BloomFilterFieldReader open(Directory directory, SegmentInfo si, FieldInfos fn, IOContext context, String segmentSuffix)
+            throws IOException {
             List<Closeable> toClose = new ArrayList<>();
             boolean success = false;
             try (var metaInput = directory.openChecksumInput(bloomFilterMetadataFileName(si, segmentSuffix))) {
@@ -486,7 +481,7 @@ public static BloomFilterFieldReader open(
             }
         }
 
-        public BloomFilterFieldReader(
+        BloomFilterFieldReader(
             FieldInfo fieldInfo,
             RandomAccessInput bloomFilterIn,
             int bloomFilterSizeInBits,
@@ -551,4 +546,20 @@ private static String bloomFilterMetadataFileName(SegmentInfo segmentInfo, Strin
     private static String bloomFilterFileName(SegmentInfo segmentInfo, String segmentSuffix) {
         return IndexFileNames.segmentFileName(segmentInfo.name, segmentSuffix, STORED_FIELDS_BLOOM_FILTER_EXTENSION);
     }
+
+    public interface BloomFilter extends Closeable {
+        /**
+         * Tests whether the given term may exist in the specified field.
+         *
+         * @param field the field name to check
+         * @param term the term to test for membership
+         * @return true if term may be present, false if definitely absent
+         */
+        boolean mayContainTerm(String field, BytesRef term) throws IOException;
+    }
+
+    public interface BloomFilterProvider extends Closeable {
+        @Nullable
+        BloomFilter getBloomFilter() throws IOException;
+    }
 }

server/src/test/java/org/elasticsearch/index/codec/bloomfilter/ES93BloomFilterStoredFieldsFormatTests.java

@@ -105,23 +105,17 @@ public void testBloomFilterFieldIsNotStoredAndBloomFilterCanBeChecked() throws I
 
                 try (var directoryReader = StandardDirectoryReader.open(writer)) {
                     for (LeafReaderContext leaf : directoryReader.leaves()) {
-                        try (ES93BloomFilterStoredFieldsFormat.Reader fieldReader = getBloomFilterReaderFrom(leaf)) {
-                            var bloomFilterFieldReader = fieldReader.getBloomFilterFieldReader();
+                        try (ES93BloomFilterStoredFieldsFormat.BloomFilterProvider fieldReader = getBloomFilterProvider(leaf)) {
+                            var bloomFilter = fieldReader.getBloomFilter();
                             // the bloom filter reader is null only if the _id field is not stored during indexing
-                            assertThat(bloomFilterFieldReader, is(not(nullValue())));
+                            assertThat(bloomFilter, is(not(nullValue())));
 
                             for (BytesRef indexedId : indexedIds) {
-                                assertThat(bloomFilterFieldReader.mayContainTerm(IdFieldMapper.NAME, indexedId), is(true));
+                                assertThat(bloomFilter.mayContainTerm(IdFieldMapper.NAME, indexedId), is(true));
                             }
-                            assertThat(
-                                bloomFilterFieldReader.mayContainTerm(IdFieldMapper.NAME, getBytesRefFromString("random")),
-                                is(false)
-                            );
-
-                            assertThat(
-                                bloomFilterFieldReader.mayContainTerm(IdFieldMapper.NAME, getBytesRefFromString("12345")),
-                                is(false)
-                            );
+                            assertThat(bloomFilter.mayContainTerm(IdFieldMapper.NAME, getBytesRefFromString("random")), is(false));
+
+                            assertThat(bloomFilter.mayContainTerm(IdFieldMapper.NAME, getBytesRefFromString("12345")), is(false));
                         }
                     }
 
@@ -144,15 +138,16 @@ private static BytesRef getBytesRefFromString(String random) {
         return new BytesRef(random.getBytes(StandardCharsets.UTF_8));
     }
 
-    private ES93BloomFilterStoredFieldsFormat.Reader getBloomFilterReaderFrom(LeafReaderContext leafReaderContext) throws IOException {
+    private ES93BloomFilterStoredFieldsFormat.BloomFilterProvider getBloomFilterProvider(LeafReaderContext leafReaderContext)
+        throws IOException {
         LeafReader reader = leafReaderContext.reader();
         var fieldInfos = reader.getFieldInfos();
         assertThat(reader, is(instanceOf(SegmentReader.class)));
         SegmentReader segmentReader = (SegmentReader) reader;
         SegmentInfo si = segmentReader.getSegmentInfo().info;
 
         var storedFieldsReader = si.getCodec().storedFieldsFormat().fieldsReader(si.dir, si, fieldInfos, IOContext.DEFAULT);
-        assertThat(storedFieldsReader, is(instanceOf(ES93BloomFilterStoredFieldsFormat.Reader.class)));
-        return (ES93BloomFilterStoredFieldsFormat.Reader) storedFieldsReader;
+        assertThat(storedFieldsReader, is(instanceOf(ES93BloomFilterStoredFieldsFormat.BloomFilterProvider.class)));
+        return ((ES93BloomFilterStoredFieldsFormat.BloomFilterProvider) storedFieldsReader);
     }
 }