Remove 6.0 version constant uses

client/rest-high-level/src/test/java/org/elasticsearch/client/core/MainResponseTests.java

@@ -38,7 +38,7 @@ protected org.elasticsearch.action.main.MainResponse createServerTestInstance()
         ClusterName clusterName = new ClusterName(randomAlphaOfLength(10));
         String nodeName = randomAlphaOfLength(10);
         final String date = new Date(randomNonNegativeLong()).toString();
-        Version version = VersionUtils.randomVersionBetween(random(), Version.V_6_0_1, Version.CURRENT);
+        Version version = VersionUtils.randomIndexCompatibleVersion(random());
         Build build = new Build(
             Build.Flavor.UNKNOWN, Build.Type.UNKNOWN, randomAlphaOfLength(8), date, randomBoolean(),
             version.toString()

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

@@ -261,7 +261,7 @@ Query percolateQuery(String name, PercolateQuery.QueryStore queryStore, List<Byt
             }
             Query filter = null;
             if (excludeNestedDocuments) {
-                filter = Queries.newNonNestedFilter(indexVersion);
+                filter = Queries.newNonNestedFilter();
             }
             return new PercolateQuery(name, queryStore, documents, candidateQuery, searcher, filter, verifiedMatchesQuery);
         }

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

@@ -30,7 +30,6 @@
 import org.apache.lucene.search.Weight;
 import org.apache.lucene.util.BitSet;
 import org.apache.lucene.util.BitSetIterator;
-import org.elasticsearch.Version;
 import org.elasticsearch.common.document.DocumentField;
 import org.elasticsearch.common.lucene.search.Queries;
 import org.elasticsearch.search.SearchHit;
@@ -71,11 +70,7 @@ static void innerHitsExecute(Query mainQuery, IndexSearcher indexSearcher, Searc
         for (PercolateQuery percolateQuery : percolateQueries) {
             String fieldName = singlePercolateQuery ? FIELD_NAME_PREFIX : FIELD_NAME_PREFIX + "_" + percolateQuery.getName();
             IndexSearcher percolatorIndexSearcher = percolateQuery.getPercolatorIndexSearcher();
-            // there is a bug in lucene's MemoryIndex that doesn't allow us to use docValues here...
-            // See https://issues.apache.org/jira/browse/LUCENE-8055
-            // for now we just use version 6.0 version to find nested parent
-            final Version version = Version.V_6_0_0; //context.mapperService().getIndexSettings().getIndexVersionCreated();
-            Weight weight = percolatorIndexSearcher.createWeight(percolatorIndexSearcher.rewrite(Queries.newNonNestedFilter(version)),
+            Weight weight = percolatorIndexSearcher.createWeight(percolatorIndexSearcher.rewrite(Queries.newNonNestedFilter()),
                     ScoreMode.COMPLETE_NO_SCORES, 1f);
             Scorer s = weight.scorer(percolatorIndexSearcher.getIndexReader().leaves().get(0));
             int memoryIndexMaxDoc = percolatorIndexSearcher.getIndexReader().maxDoc();

modules/percolator/src/test/java/org/elasticsearch/percolator/PercolatorFieldMapperTests.java

@@ -412,7 +412,7 @@ public void testCreateCandidateQuery_oldIndex() throws Exception {
         assertThat(t.v1().clauses().get(0).getQuery(), instanceOf(CoveringQuery.class));
         assertThat(t.v1().clauses().get(1).getQuery(), instanceOf(TermQuery.class));
 
-        t = fieldType.createCandidateQuery(indexReader, Version.V_6_0_0);
+        t = fieldType.createCandidateQuery(indexReader, Version.CURRENT.minimumCompatibilityVersion());
         assertTrue(t.v2());
         assertEquals(2, t.v1().clauses().size());
         assertThat(t.v1().clauses().get(0).getQuery(), instanceOf(TermInSetQuery.class));

modules/percolator/src/test/java/org/elasticsearch/percolator/QueryAnalyzerTests.java

@@ -148,22 +148,6 @@ public void testExtractQueryMetadata_multiPhraseQuery() {
         assertThat(terms.get(5).bytes().utf8ToString(), equalTo("_term6"));
     }
 
-    public void testExtractQueryMetadata_multiPhraseQuery_pre6dot1() {
-        MultiPhraseQuery multiPhraseQuery = new MultiPhraseQuery.Builder()
-            .add(new Term("_field", "_long_term"))
-            .add(new Term[] {new Term("_field", "_long_term"), new Term("_field", "_term")})
-            .add(new Term[] {new Term("_field", "_long_term"), new Term("_field", "_very_long_term")})
-            .add(new Term[] {new Term("_field", "_very_long_term")})
-            .build();
-        Result result = analyze(multiPhraseQuery, Version.V_6_0_0);
-        assertThat(result.verified, is(false));
-        assertThat(result.minimumShouldMatch, equalTo(1));
-        List<QueryExtraction> terms = new ArrayList<>(result.extractions);
-        assertThat(terms.size(), equalTo(1));
-        assertThat(terms.get(0).field(), equalTo("_field"));
-        assertThat(terms.get(0).bytes().utf8ToString(), equalTo("_very_long_term"));
-    }
-
     public void testExtractQueryMetadata_multiPhraseQuery_dups() {
         MultiPhraseQuery multiPhraseQuery = new MultiPhraseQuery.Builder()
             .add(new Term("_field", "_term1"))
@@ -211,35 +195,6 @@ public void testExtractQueryMetadata_booleanQuery() {
         assertThat(terms.get(4).bytes(), equalTo(termQuery3.getTerm().bytes()));
     }
 
-    public void testExtractQueryMetadata_booleanQuery_pre6dot1() {
-        BooleanQuery.Builder builder = new BooleanQuery.Builder();
-        TermQuery termQuery1 = new TermQuery(new Term("_field", "_term"));
-        builder.add(termQuery1, BooleanClause.Occur.SHOULD);
-        PhraseQuery phraseQuery = new PhraseQuery("_field", "_term1", "term2");
-        builder.add(phraseQuery, BooleanClause.Occur.SHOULD);
-
-        BooleanQuery.Builder subBuilder = new BooleanQuery.Builder();
-        TermQuery termQuery2 = new TermQuery(new Term("_field1", "_term"));
-        subBuilder.add(termQuery2, BooleanClause.Occur.MUST);
-        TermQuery termQuery3 = new TermQuery(new Term("_field3", "_long_term"));
-        subBuilder.add(termQuery3, BooleanClause.Occur.MUST);
-        builder.add(subBuilder.build(), BooleanClause.Occur.SHOULD);
-
-        BooleanQuery booleanQuery = builder.build();
-        Result result = analyze(booleanQuery, Version.V_6_0_0);
-        assertThat("Should clause with phrase query isn't verified, so entire query can't be verified", result.verified, is(false));
-        assertThat(result.minimumShouldMatch, equalTo(1));
-        List<QueryExtraction> terms = new ArrayList<>(result.extractions);
-        terms.sort(Comparator.comparing(qt -> qt.term));
-        assertThat(terms.size(), equalTo(3));
-        assertThat(terms.get(0).field(), equalTo(termQuery1.getTerm().field()));
-        assertThat(terms.get(0).bytes(), equalTo(termQuery1.getTerm().bytes()));
-        assertThat(terms.get(1).field(), equalTo(phraseQuery.getTerms()[0].field()));
-        assertThat(terms.get(1).bytes(), equalTo(phraseQuery.getTerms()[0].bytes()));
-        assertThat(terms.get(2).field(), equalTo(termQuery3.getTerm().field()));
-        assertThat(terms.get(2).bytes(), equalTo(termQuery3.getTerm().bytes()));
-    }
-
     public void testExtractQueryMetadata_booleanQuery_msm() {
         BooleanQuery.Builder builder = new BooleanQuery.Builder();
         builder.setMinimumNumberShouldMatch(2);
@@ -326,28 +281,6 @@ public void testExtractQueryMetadata_booleanQuery_msm() {
         assertFalse(result.verified);
     }
 
-    public void testExtractQueryMetadata_booleanQuery_msm_pre6dot1() {
-        BooleanQuery.Builder builder = new BooleanQuery.Builder();
-        builder.setMinimumNumberShouldMatch(2);
-        TermQuery termQuery1 = new TermQuery(new Term("_field", "_term1"));
-        builder.add(termQuery1, BooleanClause.Occur.SHOULD);
-        TermQuery termQuery2 = new TermQuery(new Term("_field", "_term2"));
-        builder.add(termQuery2, BooleanClause.Occur.SHOULD);
-        TermQuery termQuery3 = new TermQuery(new Term("_field", "_term3"));
-        builder.add(termQuery3, BooleanClause.Occur.SHOULD);
-
-        BooleanQuery booleanQuery = builder.build();
-        Result result = analyze(booleanQuery, Version.V_6_0_0);
-        assertThat(result.verified, is(false));
-        assertThat(result.minimumShouldMatch, equalTo(1));
-        List<QueryExtraction> extractions = new ArrayList<>(result.extractions);
-        extractions.sort(Comparator.comparing(extraction -> extraction.term));
-        assertThat(extractions.size(), equalTo(3));
-        assertThat(extractions.get(0).term, equalTo(new Term("_field", "_term1")));
-        assertThat(extractions.get(1).term, equalTo(new Term("_field", "_term2")));
-        assertThat(extractions.get(2).term, equalTo(new Term("_field", "_term3")));
-    }
-
     public void testExtractQueryMetadata_booleanQuery_onlyShould() {
         BooleanQuery.Builder builder = new BooleanQuery.Builder();
         TermQuery termQuery1 = new TermQuery(new Term("_field", "_term1"));
@@ -401,12 +334,6 @@ public void testExtractQueryMetadata_booleanQueryWithMustNot() {
         assertThat(result.verified, is(false));
         assertThat(result.minimumShouldMatch, equalTo(0));
         assertTermsEqual(result.extractions);
-
-        result = analyze(booleanQuery, Version.V_6_0_0);
-        assertThat(result.matchAllDocs, is(true));
-        assertThat(result.verified, is(false));
-        assertThat(result.minimumShouldMatch, equalTo(0));
-        assertTermsEqual(result.extractions);
     }
 
     public void testExactMatch_booleanQuery() {
@@ -657,18 +584,6 @@ public void testExtractQueryMetadata_spanNearQuery() {
         assertTermsEqual(result.extractions, spanTermQuery1.getTerm(), spanTermQuery2.getTerm());
     }
 
-    public void testExtractQueryMetadata_spanNearQuery_pre6dot1() {
-        SpanTermQuery spanTermQuery1 = new SpanTermQuery(new Term("_field", "_short_term"));
-        SpanTermQuery spanTermQuery2 = new SpanTermQuery(new Term("_field", "_very_long_term"));
-        SpanNearQuery spanNearQuery = new SpanNearQuery.Builder("_field", true)
-            .addClause(spanTermQuery1).addClause(spanTermQuery2).build();
-
-        Result result = analyze(spanNearQuery, Version.V_6_0_0);
-        assertThat(result.verified, is(false));
-        assertThat(result.minimumShouldMatch, equalTo(1));
-        assertTermsEqual(result.extractions, spanTermQuery2.getTerm());
-    }
-
     public void testExtractQueryMetadata_spanOrQuery() {
         SpanTermQuery spanTermQuery1 = new SpanTermQuery(new Term("_field", "_short_term"));
         SpanTermQuery spanTermQuery2 = new SpanTermQuery(new Term("_field", "_very_long_term"));
@@ -1217,7 +1132,7 @@ public void testPointRangeQuerySelectShortestRange() {
         BooleanQuery.Builder boolQuery = new BooleanQuery.Builder();
         boolQuery.add(LongPoint.newRangeQuery("_field1", 10, 20), BooleanClause.Occur.FILTER);
         boolQuery.add(LongPoint.newRangeQuery("_field2", 10, 15), BooleanClause.Occur.FILTER);
-        Result result = analyze(boolQuery.build(), Version.V_6_0_0);
+        Result result = analyze(boolQuery.build(), Version.CURRENT);
         assertFalse(result.verified);
         assertThat(result.minimumShouldMatch, equalTo(1));
         assertEquals(1, result.extractions.size());
@@ -1226,7 +1141,7 @@ public void testPointRangeQuerySelectShortestRange() {
         boolQuery = new BooleanQuery.Builder();
         boolQuery.add(LongPoint.newRangeQuery("_field1", 10, 20), BooleanClause.Occur.FILTER);
         boolQuery.add(IntPoint.newRangeQuery("_field2", 10, 15), BooleanClause.Occur.FILTER);
-        result = analyze(boolQuery.build(), Version.V_6_0_0);
+        result = analyze(boolQuery.build(), Version.CURRENT);
         assertFalse(result.verified);
         assertThat(result.minimumShouldMatch, equalTo(1));
         assertEquals(1, result.extractions.size());
@@ -1235,7 +1150,7 @@ public void testPointRangeQuerySelectShortestRange() {
         boolQuery = new BooleanQuery.Builder();
         boolQuery.add(DoublePoint.newRangeQuery("_field1", 10, 20), BooleanClause.Occur.FILTER);
         boolQuery.add(DoublePoint.newRangeQuery("_field2", 10, 15), BooleanClause.Occur.FILTER);
-        result = analyze(boolQuery.build(), Version.V_6_0_0);
+        result = analyze(boolQuery.build(), Version.CURRENT);
         assertFalse(result.verified);
         assertThat(result.minimumShouldMatch, equalTo(1));
         assertEquals(1, result.extractions.size());
@@ -1244,7 +1159,7 @@ public void testPointRangeQuerySelectShortestRange() {
         boolQuery = new BooleanQuery.Builder();
         boolQuery.add(DoublePoint.newRangeQuery("_field1", 10, 20), BooleanClause.Occur.FILTER);
         boolQuery.add(FloatPoint.newRangeQuery("_field2", 10, 15), BooleanClause.Occur.FILTER);
-        result = analyze(boolQuery.build(), Version.V_6_0_0);
+        result = analyze(boolQuery.build(), Version.CURRENT);
         assertFalse(result.verified);
         assertThat(result.minimumShouldMatch, equalTo(1));
         assertEquals(1, result.extractions.size());
@@ -1253,7 +1168,7 @@ public void testPointRangeQuerySelectShortestRange() {
         boolQuery = new BooleanQuery.Builder();
         boolQuery.add(HalfFloatPoint.newRangeQuery("_field1", 10, 20), BooleanClause.Occur.FILTER);
         boolQuery.add(HalfFloatPoint.newRangeQuery("_field2", 10, 15), BooleanClause.Occur.FILTER);
-        result = analyze(boolQuery.build(), Version.V_6_0_0);
+        result = analyze(boolQuery.build(), Version.CURRENT);
         assertFalse(result.verified);
         assertThat(result.minimumShouldMatch, equalTo(1));
         assertEquals(1, result.extractions.size());

server/src/main/java/org/elasticsearch/Version.java

@@ -64,12 +64,6 @@ public class Version implements Comparable<Version>, ToXContentFragment {
     public static final int V_6_0_0_rc2_ID = 6000052;
     public static final Version V_6_0_0_rc2 =
         new Version(V_6_0_0_rc2_ID, org.apache.lucene.util.Version.LUCENE_7_0_1);
-    public static final int V_6_0_0_ID = 6000099;
-    public static final Version V_6_0_0 =
-        new Version(V_6_0_0_ID, org.apache.lucene.util.Version.LUCENE_7_0_1);
-    public static final int V_6_0_1_ID = 6000199;
-    public static final Version V_6_0_1 =
-        new Version(V_6_0_1_ID, org.apache.lucene.util.Version.LUCENE_7_0_1);
     public static final int V_6_1_0_ID = 6010099;
     public static final Version V_6_1_0 = new Version(V_6_1_0_ID, org.apache.lucene.util.Version.LUCENE_7_1_0);
     public static final int V_6_1_1_ID = 6010199;
@@ -230,10 +224,6 @@ public static Version fromId(int id) {
                 return V_6_1_1;
             case V_6_1_0_ID:
                 return V_6_1_0;
-            case V_6_0_1_ID:
-                return V_6_0_1;
-            case V_6_0_0_ID:
-                return V_6_0_0;
             case V_6_0_0_rc2_ID:
                 return V_6_0_0_rc2;
             case V_6_0_0_beta2_ID:

server/src/main/java/org/elasticsearch/common/lucene/search/Queries.java

@@ -31,7 +31,6 @@
 import org.apache.lucene.search.Query;
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.ElasticsearchException;
-import org.elasticsearch.Version;
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.index.mapper.SeqNoFieldMapper;
 import org.elasticsearch.index.mapper.TypeFieldMapper;
@@ -72,17 +71,9 @@ public static Query newNestedFilter() {
 
     /**
      * Creates a new non-nested docs query
-     * @param indexVersionCreated the index version created since newer indices can identify a parent field more efficiently
      */
-    public static Query newNonNestedFilter(Version indexVersionCreated) {
-        if (indexVersionCreated.onOrAfter(Version.V_6_1_0)) {
-            return new DocValuesFieldExistsQuery(SeqNoFieldMapper.PRIMARY_TERM_NAME);
-        } else {
-            return new BooleanQuery.Builder()
-                .add(new MatchAllDocsQuery(), Occur.FILTER)
-                .add(newNestedFilter(), Occur.MUST_NOT)
-                .build();
-        }
+    public static Query newNonNestedFilter() {
+        return new DocValuesFieldExistsQuery(SeqNoFieldMapper.PRIMARY_TERM_NAME);
     }
 
     public static BooleanQuery filtered(@Nullable Query query, @Nullable Query filter) {

server/src/main/java/org/elasticsearch/index/cache/bitset/BitsetFilterCache.java

@@ -251,7 +251,7 @@ public IndexWarmer.TerminationHandle warmReader(final IndexShard indexShard, fin
             }
 
             if (hasNested) {
-                warmUp.add(Queries.newNonNestedFilter(indexSettings.getIndexVersionCreated()));
+                warmUp.add(Queries.newNonNestedFilter());
             }
 
             final CountDownLatch latch = new CountDownLatch(searcher.reader().leaves().size() * warmUp.size());

server/src/main/java/org/elasticsearch/index/mapper/TypeFieldMapper.java

@@ -140,7 +140,7 @@ public Query termsQuery(List<?> values, QueryShardContext context) {
                     .anyMatch(indexType::equals)) {
                 if (context.getMapperService().hasNested()) {
                     // type filters are expected not to match nested docs
-                    return Queries.newNonNestedFilter(context.indexVersionCreated());
+                    return Queries.newNonNestedFilter();
                 } else {
                     return new MatchAllDocsQuery();
                 }

server/src/main/java/org/elasticsearch/index/query/NestedQueryBuilder.java

@@ -281,7 +281,7 @@ protected Query doToQuery(QueryShardContext context) throws IOException {
         Query innerQuery;
         ObjectMapper objectMapper = context.nestedScope().getObjectMapper();
         if (objectMapper == null) {
-            parentFilter = context.bitsetFilter(Queries.newNonNestedFilter(context.indexVersionCreated()));
+            parentFilter = context.bitsetFilter(Queries.newNonNestedFilter());
         } else {
             parentFilter = context.bitsetFilter(objectMapper.nestedTypeFilter());
         }
@@ -388,7 +388,7 @@ public TopDocsAndMaxScore[] topDocs(SearchHit[] hits) throws IOException {
                 SearchHit hit = hits[i];
                 Query rawParentFilter;
                 if (parentObjectMapper == null) {
-                    rawParentFilter = Queries.newNonNestedFilter(context.indexShard().indexSettings().getIndexVersionCreated());
+                    rawParentFilter = Queries.newNonNestedFilter();
                 } else {
                     rawParentFilter = parentObjectMapper.nestedTypeFilter();
                 }

server/src/main/java/org/elasticsearch/index/shard/ShardSplittingQuery.java

@@ -71,7 +71,7 @@ final class ShardSplittingQuery extends Query {
         }
         this.indexMetaData = indexMetaData;
         this.shardId = shardId;
-        this.nestedParentBitSetProducer =  hasNested ? newParentDocBitSetProducer(indexMetaData.getCreationVersion()) : null;
+        this.nestedParentBitSetProducer =  hasNested ? newParentDocBitSetProducer() : null;
     }
     @Override
     public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) {
@@ -343,9 +343,9 @@ public float matchCost() {
      * than once. There is no point in using BitsetFilterCache#BitSetProducerWarmer since we use this only as a delete by query which is
      * executed on a recovery-private index writer. There is no point in caching it and it won't have a cache hit either.
      */
-    private static BitSetProducer newParentDocBitSetProducer(Version indexVersionCreated) {
+    private static BitSetProducer newParentDocBitSetProducer() {
         return context -> {
-                Query query = Queries.newNonNestedFilter(indexVersionCreated);
+                Query query = Queries.newNonNestedFilter();
                 final IndexReaderContext topLevelContext = ReaderUtil.getTopLevelContext(context);
                 final IndexSearcher searcher = new IndexSearcher(topLevelContext);
                 searcher.setQueryCache(null);

server/src/main/java/org/elasticsearch/search/DefaultSearchContext.java

@@ -278,7 +278,7 @@ public Query buildFilteredQuery(Query query) {
                 && typeFilter == null // when a _type filter is set, it will automatically exclude nested docs
                 && new NestedHelper(mapperService()).mightMatchNestedDocs(query)
                 && (aliasFilter == null || new NestedHelper(mapperService()).mightMatchNestedDocs(aliasFilter))) {
-            filters.add(Queries.newNonNestedFilter(mapperService().getIndexSettings().getIndexVersionCreated()));
+            filters.add(Queries.newNonNestedFilter());
         }
 
         if (aliasFilter != null) {

server/src/main/java/org/elasticsearch/search/aggregations/bucket/nested/NestedAggregator.java

@@ -66,7 +66,7 @@ public class NestedAggregator extends BucketsAggregator implements SingleBucketA
         super(name, factories, context, parentAggregator, pipelineAggregators, metaData);
 
         Query parentFilter = parentObjectMapper != null ? parentObjectMapper.nestedTypeFilter()
-            : Queries.newNonNestedFilter(context.mapperService().getIndexSettings().getIndexVersionCreated());
+            : Queries.newNonNestedFilter();
         this.parentFilter = context.bitsetFilterCache().getBitSetProducer(parentFilter);
         this.childFilter = childObjectMapper.nestedTypeFilter();
         this.collectsFromSingleBucket = collectsFromSingleBucket;