Remove old version constants from QueryAnalyzer (#41996)

Author: martijnvg

modules/percolator/src/main/java/org/elasticsearch/percolator/QueryAnalyzer.java

@@ -206,20 +206,8 @@ private static BiFunction<Query, Version, Result> phraseQuery() {
                 return new Result(true, Collections.emptySet(), 0);
             }
 
-            if (version.onOrAfter(Version.V_6_1_0)) {
-                Set<QueryExtraction> extractions = Arrays.stream(terms).map(QueryExtraction::new).collect(toSet());
-                return new Result(false, extractions, extractions.size());
-            } else {
-                // the longest term is likely to be the rarest,
-                // so from a performance perspective it makes sense to extract that
-                Term longestTerm = terms[0];
-                for (Term term : terms) {
-                    if (longestTerm.bytes().length < term.bytes().length) {
-                        longestTerm = term;
-                    }
-                }
-                return new Result(false, Collections.singleton(new QueryExtraction(longestTerm)), 1);
-            }
+            Set<QueryExtraction> extractions = Arrays.stream(terms).map(QueryExtraction::new).collect(toSet());
+            return new Result(false, extractions, extractions.size());
         };
     }
 
@@ -255,23 +243,14 @@ private static BiFunction<Query, Version, Result> spanTermQuery() {
     private static BiFunction<Query, Version, Result> spanNearQuery() {
         return (query, version) -> {
             SpanNearQuery spanNearQuery = (SpanNearQuery) query;
-            if (version.onOrAfter(Version.V_6_1_0)) {
-                // This has the same problem as boolean queries when it comes to duplicated clauses
-                // so we rewrite to a boolean query to keep things simple.
-                BooleanQuery.Builder builder = new BooleanQuery.Builder();
-                for (SpanQuery clause : spanNearQuery.getClauses()) {
-                    builder.add(clause, Occur.FILTER);
-                }
-                // make sure to unverify the result
-                return booleanQuery().apply(builder.build(), version).unverify();
-            } else {
-                Result bestClause = null;
-                for (SpanQuery clause : spanNearQuery.getClauses()) {
-                    Result temp = analyze(clause, version);
-                    bestClause = selectBestResult(temp, bestClause);
-                }
-                return bestClause;
+            // This has the same problem as boolean queries when it comes to duplicated clauses
+            // so we rewrite to a boolean query to keep things simple.
+            BooleanQuery.Builder builder = new BooleanQuery.Builder();
+            for (SpanQuery clause : spanNearQuery.getClauses()) {
+                builder.add(clause, Occur.FILTER);
             }
+            // make sure to unverify the result
+            return booleanQuery().apply(builder.build(), version).unverify();
         };
     }
 
@@ -478,77 +457,69 @@ private static Result handleConjunction(List<Result> conjunctions, Version versi
         if (conjunctions.isEmpty()) {
             throw new IllegalArgumentException("Must have at least on conjunction sub result");
         }
-        if (version.onOrAfter(Version.V_6_1_0)) {
-            for (Result subResult : conjunctions) {
-                if (subResult.isMatchNoDocs()) {
-                    return subResult;
-                }
+        for (Result subResult : conjunctions) {
+            if (subResult.isMatchNoDocs()) {
+                return subResult;
             }
-            int msm = 0;
-            boolean verified = true;
-            boolean matchAllDocs = true;
-            boolean hasDuplicateTerms = false;
-            Set<QueryExtraction> extractions = new HashSet<>();
-            Set<String> seenRangeFields = new HashSet<>();
-            for (Result result : conjunctions) {
-                // In case that there are duplicate query extractions we need to be careful with
-                // incrementing msm,
-                // because that could lead to valid matches not becoming candidate matches:
-                // query: (field:val1 AND field:val2) AND (field:val2 AND field:val3)
-                // doc: field: val1 val2 val3
-                // So lets be protective and decrease the msm:
-                int resultMsm = result.minimumShouldMatch;
-                for (QueryExtraction queryExtraction : result.extractions) {
-                    if (queryExtraction.range != null) {
-                        // In case of range queries each extraction does not simply increment the
-                        // minimum_should_match
-                        // for that percolator query like for a term based extraction, so that can lead
-                        // to more false
-                        // positives for percolator queries with range queries than term based queries.
-                        // The is because the way number fields are extracted from the document to be
-                        // percolated.
-                        // Per field a single range is extracted and if a percolator query has two or
-                        // more range queries
-                        // on the same field, then the minimum should match can be higher than clauses
-                        // in the CoveringQuery.
-                        // Therefore right now the minimum should match is incremented once per number
-                        // field when processing
-                        // the percolator query at index time.
-                        if (seenRangeFields.add(queryExtraction.range.fieldName)) {
-                            resultMsm = 1;
-                        } else {
-                            resultMsm = 0;
-                        }
-                    }
-
-                    if (extractions.contains(queryExtraction)) {
-
+        }
+        int msm = 0;
+        boolean verified = true;
+        boolean matchAllDocs = true;
+        boolean hasDuplicateTerms = false;
+        Set<QueryExtraction> extractions = new HashSet<>();
+        Set<String> seenRangeFields = new HashSet<>();
+        for (Result result : conjunctions) {
+            // In case that there are duplicate query extractions we need to be careful with
+            // incrementing msm,
+            // because that could lead to valid matches not becoming candidate matches:
+            // query: (field:val1 AND field:val2) AND (field:val2 AND field:val3)
+            // doc: field: val1 val2 val3
+            // So lets be protective and decrease the msm:
+            int resultMsm = result.minimumShouldMatch;
+            for (QueryExtraction queryExtraction : result.extractions) {
+                if (queryExtraction.range != null) {
+                    // In case of range queries each extraction does not simply increment the
+                    // minimum_should_match
+                    // for that percolator query like for a term based extraction, so that can lead
+                    // to more false
+                    // positives for percolator queries with range queries than term based queries.
+                    // The is because the way number fields are extracted from the document to be
+                    // percolated.
+                    // Per field a single range is extracted and if a percolator query has two or
+                    // more range queries
+                    // on the same field, then the minimum should match can be higher than clauses
+                    // in the CoveringQuery.
+                    // Therefore right now the minimum should match is incremented once per number
+                    // field when processing
+                    // the percolator query at index time.
+                    if (seenRangeFields.add(queryExtraction.range.fieldName)) {
+                        resultMsm = 1;
+                    } else {
                         resultMsm = 0;
-                        verified = false;
-                        break;
                     }
                 }
-                msm += resultMsm;
 
-                if (result.verified == false
-                        // If some inner extractions are optional, the result can't be verified
-                        || result.minimumShouldMatch < result.extractions.size()) {
+                if (extractions.contains(queryExtraction)) {
+
+                    resultMsm = 0;
                     verified = false;
+                    break;
                 }
-                matchAllDocs &= result.matchAllDocs;
-                extractions.addAll(result.extractions);
             }
-            if (matchAllDocs) {
-                return new Result(matchAllDocs, verified);
-            } else {
-                return new Result(verified, extractions, hasDuplicateTerms ? 1 : msm);
+            msm += resultMsm;
+
+            if (result.verified == false
+                // If some inner extractions are optional, the result can't be verified
+                || result.minimumShouldMatch < result.extractions.size()) {
+                verified = false;
             }
+            matchAllDocs &= result.matchAllDocs;
+            extractions.addAll(result.extractions);
+        }
+        if (matchAllDocs) {
+            return new Result(matchAllDocs, verified);
         } else {
-            Result bestClause = null;
-            for (Result result : conjunctions) {
-                bestClause = selectBestResult(result, bestClause);
-            }
-            return bestClause;
+            return new Result(verified, extractions, hasDuplicateTerms ? 1 : msm);
         }
     }
 
@@ -565,12 +536,7 @@ private static Result handleDisjunctionQuery(List<Query> disjunctions, int requi
     private static Result handleDisjunction(List<Result> disjunctions, int requiredShouldClauses, Version version) {
         // Keep track of the msm for each clause:
         List<Integer> clauses = new ArrayList<>(disjunctions.size());
-        boolean verified;
-        if (version.before(Version.V_6_1_0)) {
-            verified = requiredShouldClauses <= 1;
-        } else {
-            verified = true;
-        }
+        boolean verified = true;
         int numMatchAllClauses = 0;
         boolean hasRangeExtractions = false;
 
@@ -617,10 +583,9 @@ private static Result handleDisjunction(List<Result> disjunctions, int requiredS
         boolean matchAllDocs = numMatchAllClauses > 0 && numMatchAllClauses >= requiredShouldClauses;
 
         int msm = 0;
-        if (version.onOrAfter(Version.V_6_1_0) &&
-            // Having ranges would mean we need to juggle with the msm and that complicates this logic a lot,
-            // so for now lets not do it.
-            hasRangeExtractions == false) {
+        // Having ranges would mean we need to juggle with the msm and that complicates this logic a lot,
+        // so for now lets not do it.
+        if (hasRangeExtractions == false) {
             // Figure out what the combined msm is for this disjunction:
             // (sum the lowest required clauses, otherwise we're too strict and queries may not match)
             clauses = clauses.stream()
@@ -648,103 +613,6 @@ private static Result handleDisjunction(List<Result> disjunctions, int requiredS
         }
     }
 
-    /**
-     * Return an extraction for the conjunction of {@code result1} and {@code result2}
-     * by picking up clauses that look most restrictive and making it unverified if
-     * the other clause is not null and doesn't match all documents. This is used by
-     * 6.0.0 indices which didn't use the terms_set query.
-     */
-    static Result selectBestResult(Result result1, Result result2) {
-        assert result1 != null || result2 != null;
-        if (result1 == null) {
-            return result2;
-        } else if (result2 == null) {
-            return result1;
-        } else if (result1.matchAllDocs) { // conjunction with match_all
-            Result result = result2;
-            if (result1.verified == false) {
-                result = result.unverify();
-            }
-            return result;
-        } else if (result2.matchAllDocs) { // conjunction with match_all
-            Result result = result1;
-            if (result2.verified == false) {
-                result = result.unverify();
-            }
-            return result;
-        } else {
-            // Prefer term based extractions over range based extractions:
-            boolean onlyRangeBasedExtractions = true;
-            for (QueryExtraction clause : result1.extractions) {
-                if (clause.term != null) {
-                    onlyRangeBasedExtractions = false;
-                    break;
-                }
-            }
-            for (QueryExtraction clause : result2.extractions) {
-                if (clause.term != null) {
-                    onlyRangeBasedExtractions = false;
-                    break;
-                }
-            }
-
-            if (onlyRangeBasedExtractions) {
-                BytesRef extraction1SmallestRange = smallestRange(result1.extractions);
-                BytesRef extraction2SmallestRange = smallestRange(result2.extractions);
-                if (extraction1SmallestRange == null) {
-                    return result2.unverify();
-                } else if (extraction2SmallestRange == null) {
-                    return result1.unverify();
-                }
-
-                // Keep the clause with smallest range, this is likely to be the rarest.
-                if (extraction1SmallestRange.compareTo(extraction2SmallestRange) <= 0) {
-                    return result1.unverify();
-                } else {
-                    return result2.unverify();
-                }
-            } else {
-                int extraction1ShortestTerm = minTermLength(result1.extractions);
-                int extraction2ShortestTerm = minTermLength(result2.extractions);
-                // keep the clause with longest terms, this likely to be rarest.
-                if (extraction1ShortestTerm >= extraction2ShortestTerm) {
-                    return result1.unverify();
-                } else {
-                    return result2.unverify();
-                }
-            }
-        }
-    }
-
-    private static int minTermLength(Set<QueryExtraction> extractions) {
-        // In case there are only range extractions, then we return Integer.MIN_VALUE,
-        // so that selectBestExtraction(...) we are likely to prefer the extractions that contains at least a single extraction
-        if (extractions.stream().filter(queryExtraction -> queryExtraction.term != null).count() == 0 &&
-                extractions.stream().filter(queryExtraction -> queryExtraction.range != null).count() > 0) {
-            return Integer.MIN_VALUE;
-        }
-
-        int min = Integer.MAX_VALUE;
-        for (QueryExtraction qt : extractions) {
-            if (qt.term != null) {
-                min = Math.min(min, qt.bytes().length);
-            }
-        }
-        return min;
-    }
-
-    private static BytesRef smallestRange(Set<QueryExtraction> terms) {
-        BytesRef min = null;
-        for (QueryExtraction qt : terms) {
-            if (qt.range != null) {
-                if (min == null || qt.range.interval.compareTo(min) < 0) {
-                    min = qt.range.interval;
-                }
-            }
-        }
-        return min;
-    }
-
     /**
      * Query extraction result. A result is a candidate for a given document either if:
      *  - `matchAllDocs` is true