Simplify class hierarchy for ordinals field data. (#60350)

This PR simplifies the hierarchy for ordinals field data classes:
* Remove `AbstractIndexFieldData`, since only `AbstractIndexOrdinalsFieldData`
inherits directly from it.
* Make `SortedSetOrdinalsIndexFieldData` extend
`AbstractIndexOrdinalsFieldData`. This lets us remove some redundant code.

Author: jtibshirani

server/src/main/java/org/elasticsearch/index/fielddata/RamAccountingTermsEnum.java

@@ -22,7 +22,7 @@
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.common.breaker.CircuitBreaker;
-import org.elasticsearch.index.fielddata.plain.AbstractIndexFieldData;
+import org.elasticsearch.index.fielddata.plain.AbstractIndexOrdinalsFieldData;
 
 import java.io.IOException;
 
@@ -38,13 +38,14 @@ public final class RamAccountingTermsEnum extends FilteredTermsEnum {
 
     private final CircuitBreaker breaker;
     private final TermsEnum termsEnum;
-    private final AbstractIndexFieldData.PerValueEstimator estimator;
+    private final AbstractIndexOrdinalsFieldData.PerValueEstimator estimator;
     private final String fieldName;
     private long totalBytes;
     private long flushBuffer;
 
 
-    public RamAccountingTermsEnum(TermsEnum termsEnum, CircuitBreaker breaker, AbstractIndexFieldData.PerValueEstimator estimator,
+    public RamAccountingTermsEnum(TermsEnum termsEnum, CircuitBreaker breaker,
+                                  AbstractIndexOrdinalsFieldData.PerValueEstimator estimator,
                                   String fieldName) {
         super(termsEnum);
         this.breaker = breaker;

server/src/main/java/org/elasticsearch/index/fielddata/plain/AbstractIndexFieldData.java

@@ -21,53 +21,85 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.lucene.index.DirectoryReader;
-import org.apache.lucene.index.FilteredTermsEnum;
-import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.OrdinalMap;
+import org.apache.lucene.index.SortedSetDocValues;
 import org.apache.lucene.index.Terms;
 import org.apache.lucene.index.TermsEnum;
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.ElasticsearchException;
 import org.elasticsearch.index.fielddata.IndexFieldDataCache;
 import org.elasticsearch.index.fielddata.IndexOrdinalsFieldData;
 import org.elasticsearch.index.fielddata.LeafOrdinalsFieldData;
+import org.elasticsearch.index.fielddata.RamAccountingTermsEnum;
+import org.elasticsearch.index.fielddata.ScriptDocValues;
 import org.elasticsearch.index.fielddata.ordinals.GlobalOrdinalsBuilder;
 import org.elasticsearch.index.fielddata.ordinals.GlobalOrdinalsIndexFieldData;
 import org.elasticsearch.indices.breaker.CircuitBreakerService;
 import org.elasticsearch.search.aggregations.support.ValuesSourceType;
 
 import java.io.IOException;
+import java.util.function.Function;
 
-public abstract class AbstractIndexOrdinalsFieldData extends AbstractIndexFieldData<LeafOrdinalsFieldData>
-        implements IndexOrdinalsFieldData {
+public abstract class AbstractIndexOrdinalsFieldData implements IndexOrdinalsFieldData {
     private static final Logger logger = LogManager.getLogger(AbstractBinaryDVLeafFieldData.class);
 
-    private final double minFrequency, maxFrequency;
-    private final int minSegmentSize;
+    private final String fieldName;
+    private final ValuesSourceType valuesSourceType;
+    private final IndexFieldDataCache cache;
     protected final CircuitBreakerService breakerService;
+    protected final Function<SortedSetDocValues, ScriptDocValues<?>> scriptFunction;
 
     protected AbstractIndexOrdinalsFieldData(
         String fieldName,
         ValuesSourceType valuesSourceType,
         IndexFieldDataCache cache,
         CircuitBreakerService breakerService,
-        double minFrequency,
-        double maxFrequency,
-        int minSegmentSize
+        Function<SortedSetDocValues, ScriptDocValues<?>> scriptFunction
     ) {
-        super(fieldName, valuesSourceType, cache);
+        this.fieldName = fieldName;
+        this.valuesSourceType = valuesSourceType;
+        this.cache = cache;
         this.breakerService = breakerService;
-        this.minFrequency = minFrequency;
-        this.maxFrequency = maxFrequency;
-        this.minSegmentSize = minSegmentSize;
+        this.scriptFunction = scriptFunction;
+    }
+
+    @Override
+    public String getFieldName() {
+        return this.fieldName;
+    }
+
+    @Override
+    public ValuesSourceType getValuesSourceType() {
+        return valuesSourceType;
     }
 
     @Override
     public OrdinalMap getOrdinalMap() {
         return null;
     }
 
+    @Override
+    public LeafOrdinalsFieldData load(LeafReaderContext context) {
+        if (context.reader().getFieldInfos().fieldInfo(fieldName) == null) {
+            // Some leaf readers may be wrapped and report different set of fields and use the same cache key.
+            // If a field can't be found then it doesn't mean it isn't there,
+            // so if a field doesn't exist then we don't cache it and just return an empty field data instance.
+            // The next time the field is found, we do cache.
+            return AbstractLeafOrdinalsFieldData.empty();
+        }
+
+        try {
+            return cache.load(context, this);
+        } catch (Exception e) {
+            if (e instanceof ElasticsearchException) {
+                throw (ElasticsearchException) e;
+            } else {
+                throw new ElasticsearchException(e);
+            }
+        }
+    }
+
     @Override
     public IndexOrdinalsFieldData loadGlobal(DirectoryReader indexReader) {
         IndexOrdinalsFieldData fieldData = loadGlobalInternal(indexReader);
@@ -121,60 +153,49 @@ public IndexOrdinalsFieldData loadGlobalDirect(DirectoryReader indexReader) thro
             this,
             breakerService,
             logger,
-            AbstractLeafOrdinalsFieldData.DEFAULT_SCRIPT_FUNCTION
+            scriptFunction
         );
     }
 
-    @Override
-    protected LeafOrdinalsFieldData empty(int maxDoc) {
-        return AbstractLeafOrdinalsFieldData.empty();
-    }
-
-    protected TermsEnum filter(Terms terms, TermsEnum iterator, LeafReader reader) throws IOException {
-        if (iterator == null) {
-            return null;
-        }
-        int docCount = terms.getDocCount();
-        if (docCount == -1) {
-            docCount = reader.maxDoc();
-        }
-        if (docCount >= minSegmentSize) {
-            final int minFreq = minFrequency > 1.0
-                    ? (int) minFrequency
-                    : (int)(docCount * minFrequency);
-            final int maxFreq = maxFrequency > 1.0
-                    ? (int) maxFrequency
-                    : (int)(docCount * maxFrequency);
-            if (minFreq > 1 || maxFreq < docCount) {
-                iterator = new FrequencyFilter(iterator, minFreq, maxFreq);
-            }
-        }
-        return iterator;
-    }
-
     @Override
     public boolean supportsGlobalOrdinalsMapping() {
         return false;
     }
 
-    private static final class FrequencyFilter extends FilteredTermsEnum {
-
-        private int minFreq;
-        private int maxFreq;
-        FrequencyFilter(TermsEnum delegate, int minFreq, int maxFreq) {
-            super(delegate, false);
-            this.minFreq = minFreq;
-            this.maxFreq = maxFreq;
-        }
-
-        @Override
-        protected AcceptStatus accept(BytesRef arg0) throws IOException {
-            int docFreq = docFreq();
-            if (docFreq >= minFreq && docFreq <= maxFreq) {
-                return AcceptStatus.YES;
-            }
-            return AcceptStatus.NO;
-        }
+    /**
+     * A {@code PerValueEstimator} is a sub-class that can be used to estimate
+     * the memory overhead for loading the data. Each field data
+     * implementation should implement its own {@code PerValueEstimator} if it
+     * intends to take advantage of the CircuitBreaker.
+     * <p>
+     * Note that the .beforeLoad(...) and .afterLoad(...) methods must be
+     * manually called.
+     */
+    public interface PerValueEstimator {
+
+        /**
+         * @return the number of bytes for the given term
+         */
+        long bytesPerValue(BytesRef term);
+
+        /**
+         * Execute any pre-loading estimations for the terms. May also
+         * optionally wrap a {@link TermsEnum} in a
+         * {@link RamAccountingTermsEnum}
+         * which will estimate the memory on a per-term basis.
+         *
+         * @param terms terms to be estimated
+         * @return A TermsEnum for the given terms
+         */
+        TermsEnum beforeLoad(Terms terms) throws IOException;
+
+        /**
+         * Possibly adjust a circuit breaker after field data has been loaded,
+         * now that the actual amount of memory used by the field data is known
+         *
+         * @param termsEnum  terms that were loaded
+         * @param actualUsed actual field data memory usage
+         */
+        void afterLoad(TermsEnum termsEnum, long actualUsed);
     }
-
 }

server/src/main/java/org/elasticsearch/index/fielddata/plain/AbstractIndexOrdinalsFieldData.java

@@ -37,7 +37,6 @@
 import org.elasticsearch.index.fielddata.LeafOrdinalsFieldData;
 import org.elasticsearch.index.fielddata.fieldcomparator.BytesRefFieldComparatorSource;
 import org.elasticsearch.index.mapper.MapperService;
-import org.elasticsearch.index.mapper.TextFieldMapper;
 import org.elasticsearch.indices.breaker.CircuitBreakerService;
 import org.elasticsearch.search.DocValueFormat;
 import org.elasticsearch.search.MultiValueMode;
@@ -139,10 +138,7 @@ public void close() {
     private final ConstantLeafFieldData atomicFieldData;
 
     private ConstantIndexFieldData(String name, String value, ValuesSourceType valuesSourceType) {
-        super(name, valuesSourceType, null, null,
-                TextFieldMapper.Defaults.FIELDDATA_MIN_FREQUENCY,
-                TextFieldMapper.Defaults.FIELDDATA_MAX_FREQUENCY,
-                TextFieldMapper.Defaults.FIELDDATA_MIN_SEGMENT_SIZE);
+        super(name, valuesSourceType, null, null, AbstractLeafOrdinalsFieldData.DEFAULT_SCRIPT_FUNCTION);
         atomicFieldData = new ConstantLeafFieldData(value);
     }