fix properly handling acceptDocs in filters

our idea is to apply it on the "filtered/constant" level, and not on compound filters, so we won't apply it multiple times. The solution is conservative a bit now, we can further optimize it in the future, for example, not to wrap it when no caching is done within the filter chain

src/main/java/org/apache/lucene/queryparser/classic/ExistsFieldQueryExtension.java

@@ -22,7 +22,7 @@ package org.apache.lucene.queryparser.classic;
 import org.apache.lucene.search.Filter;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.TermRangeFilter;
-import org.elasticsearch.common.lucene.search.DeletionAwareConstantScoreQuery;
+import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
 import org.elasticsearch.index.mapper.MapperService;
 import org.elasticsearch.index.query.QueryParseContext;
 
@@ -54,6 +54,6 @@ public class ExistsFieldQueryExtension implements FieldQueryExtension {
 
         filter = wrapSmartNameFilter(filter, smartNameFieldMappers, parseContext);
 
-        return new DeletionAwareConstantScoreQuery(filter);
+        return new XConstantScoreQuery(filter);
     }
 }

src/main/java/org/apache/lucene/queryparser/classic/MissingFieldQueryExtension.java

@@ -22,8 +22,8 @@ package org.apache.lucene.queryparser.classic;
 import org.apache.lucene.search.Filter;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.TermRangeFilter;
-import org.elasticsearch.common.lucene.search.DeletionAwareConstantScoreQuery;
 import org.elasticsearch.common.lucene.search.NotFilter;
+import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
 import org.elasticsearch.index.mapper.MapperService;
 import org.elasticsearch.index.query.QueryParseContext;
 
@@ -59,6 +59,6 @@ public class MissingFieldQueryExtension implements FieldQueryExtension {
 
         filter = wrapSmartNameFilter(filter, smartNameFieldMappers, parseContext);
 
-        return new DeletionAwareConstantScoreQuery(filter);
+        return new XConstantScoreQuery(filter);
     }
 }

src/main/java/org/apache/lucene/search/vectorhighlight/CustomFieldQuery.java

@@ -24,10 +24,7 @@ import org.apache.lucene.index.Term;
 import org.apache.lucene.queries.FilterClause;
 import org.apache.lucene.search.*;
 import org.apache.lucene.search.spans.SpanTermQuery;
-import org.elasticsearch.common.lucene.search.MultiPhrasePrefixQuery;
+import org.elasticsearch.common.lucene.search.*;
-import org.elasticsearch.common.lucene.search.TermFilter;
-import org.elasticsearch.common.lucene.search.XBooleanFilter;
-import org.elasticsearch.common.lucene.search.XTermsFilter;
 import org.elasticsearch.common.lucene.search.function.FiltersFunctionScoreQuery;
 import org.elasticsearch.common.lucene.search.function.FunctionScoreQuery;
 
@@ -87,6 +84,9 @@ public class CustomFieldQuery extends FieldQuery {
         } else if (sourceQuery instanceof FilteredQuery) {
             flatten(((FilteredQuery) sourceQuery).getQuery(), reader, flatQueries);
             flatten(((FilteredQuery) sourceQuery).getFilter(), reader, flatQueries);
+        } else if (sourceQuery instanceof XFilteredQuery) {
+            flatten(((XFilteredQuery) sourceQuery).getQuery(), reader, flatQueries);
+            flatten(((XFilteredQuery) sourceQuery).getFilter(), reader, flatQueries);
         } else if (sourceQuery instanceof MultiPhrasePrefixQuery) {
             try {
                 flatten(sourceQuery.rewrite(reader), reader, flatQueries);

src/main/java/org/elasticsearch/common/lucene/search/ApplyAcceptedDocsFilter.java

@@ -20,10 +20,7 @@
 package org.elasticsearch.common.lucene.search;
 
 import org.apache.lucene.index.AtomicReaderContext;
-import org.apache.lucene.search.DocIdSet;
+import org.apache.lucene.search.*;
-import org.apache.lucene.search.DocIdSetIterator;
-import org.apache.lucene.search.Filter;
-import org.apache.lucene.search.FilteredDocIdSetIterator;
 import org.apache.lucene.util.Bits;
 import org.apache.lucene.util.FixedBitSet;
 import org.elasticsearch.common.lucene.docset.DocIdSets;
@@ -31,13 +28,15 @@ import org.elasticsearch.common.lucene.docset.DocIdSets;
 import java.io.IOException;
 
 /**
- * A filter that filters out deleted documents.
+ * The assumption is that the underlying filter might not apply the accepted docs, so this filter helps to wrap
+ * the actual filter and apply the actual accepted docs.
  */
-public class NotDeletedFilter extends Filter {
+// TODO: we can try and be smart, and only apply if if a filter is cached (down the "chain") since that's the only place that acceptDocs are not applied in ES
+public class ApplyAcceptedDocsFilter extends Filter {
 
     private final Filter filter;
 
-    public NotDeletedFilter(Filter filter) {
+    public ApplyAcceptedDocsFilter(Filter filter) {
         this.filter = filter;
     }
 
@@ -47,10 +46,14 @@ public class NotDeletedFilter extends Filter {
         if (DocIdSets.isEmpty(docIdSet)) {
             return null;
         }
-        if (!context.reader().hasDeletions()) {
+        if (acceptDocs == null) {
             return docIdSet;
         }
-        return new NotDeletedDocIdSet(docIdSet, context.reader().getLiveDocs());
+        if (acceptDocs == context.reader().getLiveDocs()) {
+            // optimized wrapper for not deleted cases
+            return new NotDeletedDocIdSet(docIdSet, acceptDocs);
+        }
+        return BitsFilteredDocIdSet.wrap(docIdSet, acceptDocs);
     }
 
     public Filter filter() {
@@ -59,7 +62,7 @@ public class NotDeletedFilter extends Filter {
 
     @Override
     public String toString() {
-        return "NotDeleted(" + filter + ")";
+        return filter.toString();
     }
 
     static class NotDeletedDocIdSet extends DocIdSet {

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

@@ -32,7 +32,7 @@ import java.util.regex.Pattern;
 public class Queries {
 
     // We don't use MatchAllDocsQuery, its slower than the one below ... (much slower)
-    public final static Query MATCH_ALL_QUERY = new DeletionAwareConstantScoreQuery(new MatchAllDocsFilter());
+    public final static Query MATCH_ALL_QUERY = new XConstantScoreQuery(new MatchAllDocsFilter());
     public final static Query NO_MATCH_QUERY = MatchNoDocsQuery.INSTANCE;
 
     /**
@@ -113,8 +113,8 @@ public class Queries {
         if (query == Queries.MATCH_ALL_QUERY) {
             return true;
         }
-        if (query instanceof DeletionAwareConstantScoreQuery) {
+        if (query instanceof XConstantScoreQuery) {
-            DeletionAwareConstantScoreQuery scoreQuery = (DeletionAwareConstantScoreQuery) query;
+            XConstantScoreQuery scoreQuery = (XConstantScoreQuery) query;
             if (scoreQuery.getFilter() instanceof MatchAllDocsFilter) {
                 return true;
             }

src/main/java/org/elasticsearch/common/lucene/search/XConstantScoreQuery.java

@@ -25,12 +25,12 @@ import org.apache.lucene.search.Filter;
 /**
  * We still need sometimes to exclude deletes, because we don't remove them always with acceptDocs on filters
  */
-public class DeletionAwareConstantScoreQuery extends ConstantScoreQuery {
+public class XConstantScoreQuery extends ConstantScoreQuery {
 
     private final Filter actualFilter;
 
-    public DeletionAwareConstantScoreQuery(Filter filter) {
+    public XConstantScoreQuery(Filter filter) {
-        super(new NotDeletedFilter(filter));
+        super(new ApplyAcceptedDocsFilter(filter));
         this.actualFilter = filter;
     }
 

src/main/java/org/elasticsearch/common/lucene/search/XFilteredQuery.java

@@ -0,0 +1,729 @@
+package org.elasticsearch.common.lucene.search;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import org.apache.lucene.index.AtomicReaderContext;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.*;
+import org.apache.lucene.util.Bits;
+import org.apache.lucene.util.ToStringUtils;
+import org.elasticsearch.common.lucene.docset.DocIdSets;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;
+
+
+/**
+ * A query that applies a filter to the results of another query.
+ * <p/>
+ * <p>Note: the bits are retrieved from the filter each time this
+ * query is used in a search - use a CachingWrapperFilter to avoid
+ * regenerating the bits every time.
+ *
+ * @see CachingWrapperFilter
+ * @since 1.4
+ */
+
+// Copied form Lucene 4.1, Changes are marked with //CHANGE:
+// Note, when Lucene 4.1 comes out, we can simply extend 4.1 and add our tweaks, since they are on top of current one
+// some are tricky though..., need closer look
+public class XFilteredQuery extends Query {
+
+    private final Query query;
+    private final Filter filter;
+    private final FilterStrategy strategy;
+
+    /**
+     * Constructs a new query which applies a filter to the results of the original query.
+     * {@link Filter#getDocIdSet} will be called every time this query is used in a search.
+     *
+     * @param query  Query to be filtered, cannot be <code>null</code>.
+     * @param filter Filter to apply to query results, cannot be <code>null</code>.
+     */
+    public XFilteredQuery(Query query, Filter filter) {
+        this(query, filter, RANDOM_ACCESS_FILTER_STRATEGY);
+    }
+
+    /**
+     * Expert: Constructs a new query which applies a filter to the results of the original query.
+     * {@link Filter#getDocIdSet} will be called every time this query is used in a search.
+     *
+     * @param query    Query to be filtered, cannot be <code>null</code>.
+     * @param filter   Filter to apply to query results, cannot be <code>null</code>.
+     * @param strategy a filter strategy used to create a filtered scorer.
+     * @see FilterStrategy
+     */
+    public XFilteredQuery(Query query, Filter filter, FilterStrategy strategy) {
+        if (query == null || filter == null)
+            throw new IllegalArgumentException("Query and filter cannot be null.");
+        if (strategy == null)
+            throw new IllegalArgumentException("FilterStrategy can not be null");
+        this.strategy = strategy;
+        this.query = query;
+        // CHANGE: we need to wrap it in post application of accepted docs
+        this.filter = new ApplyAcceptedDocsFilter(filter);
+    }
+
+    /**
+     * Returns a Weight that applies the filter to the enclosed query's Weight.
+     * This is accomplished by overriding the Scorer returned by the Weight.
+     */
+    @Override
+    public Weight createWeight(final IndexSearcher searcher) throws IOException {
+        final Weight weight = query.createWeight(searcher);
+        return new Weight() {
+
+            @Override
+            public boolean scoresDocsOutOfOrder() {
+                return true;
+            }
+
+            @Override
+            public float getValueForNormalization() throws IOException {
+                return weight.getValueForNormalization() * getBoost() * getBoost(); // boost sub-weight
+            }
+
+            @Override
+            public void normalize(float norm, float topLevelBoost) {
+                weight.normalize(norm, topLevelBoost * getBoost()); // incorporate boost
+            }
+
+            @Override
+            public Explanation explain(AtomicReaderContext ir, int i) throws IOException {
+                Explanation inner = weight.explain(ir, i);
+                Filter f = XFilteredQuery.this.filter;
+                DocIdSet docIdSet = f.getDocIdSet(ir, ir.reader().getLiveDocs());
+                DocIdSetIterator docIdSetIterator = docIdSet == null ? DocIdSet.EMPTY_DOCIDSET.iterator() : docIdSet.iterator();
+                if (docIdSetIterator == null) {
+                    docIdSetIterator = DocIdSet.EMPTY_DOCIDSET.iterator();
+                }
+                if (docIdSetIterator.advance(i) == i) {
+                    return inner;
+                } else {
+                    Explanation result = new Explanation
+                            (0.0f, "failure to match filter: " + f.toString());
+                    result.addDetail(inner);
+                    return result;
+                }
+            }
+
+            // return this query
+            @Override
+            public Query getQuery() {
+                return XFilteredQuery.this;
+            }
+
+            // return a filtering scorer
+            @Override
+            public Scorer scorer(AtomicReaderContext context, boolean scoreDocsInOrder, boolean topScorer, final Bits acceptDocs) throws IOException {
+                assert filter != null;
+
+                final DocIdSet filterDocIdSet = filter.getDocIdSet(context, acceptDocs);
+                if (filterDocIdSet == null) {
+                    // this means the filter does not accept any documents.
+                    return null;
+                }
+                return strategy.filteredScorer(context, scoreDocsInOrder, topScorer, weight, filterDocIdSet);
+
+            }
+        };
+    }
+
+    /**
+     * A scorer that consults the filter iff a document was matched by the
+     * delegate scorer. This is useful if the filter computation is more expensive
+     * than document scoring or if the filter has a linear running time to compute
+     * the next matching doc like exact geo distances.
+     */
+    // CHANGE: change this to package level, so it won't mess up with JIT
+    // CHANGE: filteredbits can be final
+    static final class QueryFirstScorer extends Scorer {
+        private final Scorer scorer;
+        private int scorerDoc = -1;
+        private final Bits filterbits;
+
+        protected QueryFirstScorer(Weight weight, Bits filterBits, Scorer other) {
+            super(weight);
+            this.scorer = other;
+            this.filterbits = filterBits;
+        }
+
+        // optimization: we are topScorer and collect directly
+        @Override
+        public void score(Collector collector) throws IOException {
+            // the normalization trick already applies the boost of this query,
+            // so we can use the wrapped scorer directly:
+            collector.setScorer(scorer);
+            for (; ; ) {
+                final int scorerDoc = scorer.nextDoc();
+                if (scorerDoc == DocIdSetIterator.NO_MORE_DOCS) {
+                    break;
+                }
+                if (filterbits.get(scorerDoc)) {
+                    collector.collect(scorerDoc);
+                }
+            }
+        }
+
+        @Override
+        public int nextDoc() throws IOException {
+            int doc;
+            for (; ; ) {
+                doc = scorer.nextDoc();
+                if (doc == Scorer.NO_MORE_DOCS || filterbits.get(doc)) {
+                    return scorerDoc = doc;
+                }
+            }
+        }
+
+        @Override
+        public int advance(int target) throws IOException {
+
+            int doc = scorer.advance(target);
+            if (doc != Scorer.NO_MORE_DOCS && !filterbits.get(doc)) {
+                return scorerDoc = nextDoc();
+            } else {
+                return scorerDoc = doc;
+            }
+
+        }
+
+        @Override
+        public int docID() {
+            return scorerDoc;
+        }
+
+        @Override
+        public float score() throws IOException {
+            return scorer.score();
+        }
+
+        @Override
+        public float freq() throws IOException {
+            return scorer.freq();
+        }
+
+        @Override
+        public Collection<ChildScorer> getChildren() {
+            return Collections.singleton(new ChildScorer(scorer, "FILTERED"));
+        }
+    }
+
+    /**
+     * A Scorer that uses a "leap-frog" approach (also called "zig-zag join"). The scorer and the filter
+     * take turns trying to advance to each other's next matching document, often
+     * jumping past the target document. When both land on the same document, it's
+     * collected.
+     */
+    // CHANGE: change this to package level, so it won't mess up with JIT
+    static class LeapFrogScorer extends Scorer {
+        private final DocIdSetIterator secondary;
+        private final DocIdSetIterator primary;
+        private final Scorer scorer;
+        protected int primaryDoc = -1;
+        protected int secondaryDoc = -1;
+
+        protected LeapFrogScorer(Weight weight, DocIdSetIterator primary, DocIdSetIterator secondary, Scorer scorer) {
+            super(weight);
+            this.primary = primary;
+            this.secondary = secondary;
+            this.scorer = scorer;
+        }
+
+        // optimization: we are topScorer and collect directly using short-circuited algo
+        @Override
+        public final void score(Collector collector) throws IOException {
+            int primDoc = primaryNext();
+            int secDoc = secondary.advance(primDoc);
+            // the normalization trick already applies the boost of this query,
+            // so we can use the wrapped scorer directly:
+            collector.setScorer(scorer);
+            for (; ; ) {
+                if (primDoc == secDoc) {
+                    // Check if scorer has exhausted, only before collecting.
+                    if (primDoc == DocIdSetIterator.NO_MORE_DOCS) {
+                        break;
+                    }
+                    collector.collect(primDoc);
+                    primDoc = primary.nextDoc();
+                    secDoc = secondary.advance(primDoc);
+                } else if (secDoc > primDoc) {
+                    primDoc = primary.advance(secDoc);
+                } else {
+                    secDoc = secondary.advance(primDoc);
+                }
+            }
+        }
+
+        private final int advanceToNextCommonDoc() throws IOException {
+            for (; ; ) {
+                if (secondaryDoc < primaryDoc) {
+                    secondaryDoc = secondary.advance(primaryDoc);
+                } else if (secondaryDoc == primaryDoc) {
+                    return primaryDoc;
+                } else {
+                    primaryDoc = primary.advance(secondaryDoc);
+                }
+            }
+        }
+
+        @Override
+        public final int nextDoc() throws IOException {
+            primaryDoc = primaryNext();
+            return advanceToNextCommonDoc();
+        }
+
+        protected int primaryNext() throws IOException {
+            return primary.nextDoc();
+        }
+
+        @Override
+        public final int advance(int target) throws IOException {
+            if (target > primaryDoc) {
+                primaryDoc = primary.advance(target);
+            }
+            return advanceToNextCommonDoc();
+        }
+
+        @Override
+        public final int docID() {
+            return secondaryDoc;
+        }
+
+        @Override
+        public final float score() throws IOException {
+            return scorer.score();
+        }
+
+        @Override
+        public final float freq() throws IOException {
+            return scorer.freq();
+        }
+
+        @Override
+        public final Collection<ChildScorer> getChildren() {
+            return Collections.singleton(new ChildScorer(scorer, "FILTERED"));
+        }
+    }
+
+    // TODO once we have way to figure out if we use RA or LeapFrog we can remove this scorer
+    private static final class PrimaryAdvancedLeapFrogScorer extends LeapFrogScorer {
+        private final int firstFilteredDoc;
+
+        protected PrimaryAdvancedLeapFrogScorer(Weight weight, int firstFilteredDoc, DocIdSetIterator filterIter, Scorer other) {
+            super(weight, filterIter, other, other);
+            this.firstFilteredDoc = firstFilteredDoc;
+            this.primaryDoc = firstFilteredDoc; // initialize to prevent and advance call to move it further
+        }
+
+        @Override
+        protected int primaryNext() throws IOException {
+            if (secondaryDoc != -1) {
+                return super.primaryNext();
+            } else {
+                return firstFilteredDoc;
+            }
+        }
+    }
+
+    /**
+     * Rewrites the query. If the wrapped is an instance of
+     * {@link MatchAllDocsQuery} it returns a {@link ConstantScoreQuery}. Otherwise
+     * it returns a new {@code FilteredQuery} wrapping the rewritten query.
+     */
+    @Override
+    public Query rewrite(IndexReader reader) throws IOException {
+        final Query queryRewritten = query.rewrite(reader);
+
+        // CHANGE: if we push back to Lucene, would love to have an extension for "isMatchAllQuery"
+        if (queryRewritten instanceof MatchAllDocsQuery || Queries.isConstantMatchAllQuery(queryRewritten)) {
+            // Special case: If the query is a MatchAllDocsQuery, we only
+            // return a CSQ(filter).
+            final Query rewritten = new ConstantScoreQuery(filter);
+            // Combine boost of MatchAllDocsQuery and the wrapped rewritten query:
+            rewritten.setBoost(this.getBoost() * queryRewritten.getBoost());
+            return rewritten;
+        }
+
+        if (queryRewritten != query) {
+            // rewrite to a new FilteredQuery wrapping the rewritten query
+            final Query rewritten = new XFilteredQuery(queryRewritten, filter);
+            rewritten.setBoost(this.getBoost());
+            return rewritten;
+        } else {
+            // nothing to rewrite, we are done!
+            return this;
+        }
+    }
+
+    /**
+     * Returns this FilteredQuery's (unfiltered) Query
+     */
+    public final Query getQuery() {
+        return query;
+    }
+
+    /**
+     * Returns this FilteredQuery's filter
+     */
+    public final Filter getFilter() {
+        // CHANGE: unwrap the accepted docs filter
+        if (filter instanceof ApplyAcceptedDocsFilter) {
+            return ((ApplyAcceptedDocsFilter) filter).filter();
+        }
+        return filter;
+    }
+
+    // inherit javadoc
+    @Override
+    public void extractTerms(Set<Term> terms) {
+        getQuery().extractTerms(terms);
+    }
+
+    /**
+     * Prints a user-readable version of this query.
+     */
+    @Override
+    public String toString(String s) {
+        StringBuilder buffer = new StringBuilder();
+        buffer.append("filtered(");
+        buffer.append(query.toString(s));
+        buffer.append(")->");
+        buffer.append(filter);
+        buffer.append(ToStringUtils.boost(getBoost()));
+        return buffer.toString();
+    }
+
+    /**
+     * Returns true iff <code>o</code> is equal to this.
+     */
+    @Override
+    public boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!super.equals(o))
+            return false;
+        assert o instanceof XFilteredQuery;
+        final XFilteredQuery fq = (XFilteredQuery) o;
+        return fq.query.equals(this.query) && fq.filter.equals(this.filter) && fq.strategy.equals(this.strategy);
+    }
+
+    /**
+     * Returns a hash code value for this object.
+     */
+    @Override
+    public int hashCode() {
+        int hash = super.hashCode();
+        hash = hash * 31 + strategy.hashCode();
+        hash = hash * 31 + query.hashCode();
+        hash = hash * 31 + filter.hashCode();
+        return hash;
+    }
+
+    /**
+     * A {@link FilterStrategy} that conditionally uses a random access filter if
+     * the given {@link DocIdSet} supports random access (returns a non-null value
+     * from {@link DocIdSet#bits()}) and
+     * {@link RandomAccessFilterStrategy#useRandomAccess(Bits, int)} returns
+     * <code>true</code>. Otherwise this strategy falls back to a "zig-zag join" (
+     * {@link XFilteredQuery#LEAP_FROG_FILTER_FIRST_STRATEGY}) strategy.
+     * <p/>
+     * <p>
+     * Note: this strategy is the default strategy in {@link FilteredQuery}
+     * </p>
+     */
+    public static final FilterStrategy RANDOM_ACCESS_FILTER_STRATEGY = new RandomAccessFilterStrategy();
+
+    /**
+     * A filter strategy that uses a "leap-frog" approach (also called "zig-zag join").
+     * The scorer and the filter
+     * take turns trying to advance to each other's next matching document, often
+     * jumping past the target document. When both land on the same document, it's
+     * collected.
+     * <p>
+     * Note: This strategy uses the filter to lead the iteration.
+     * </p>
+     */
+    public static final FilterStrategy LEAP_FROG_FILTER_FIRST_STRATEGY = new LeapFrogFilterStrategy(false);
+
+    /**
+     * A filter strategy that uses a "leap-frog" approach (also called "zig-zag join").
+     * The scorer and the filter
+     * take turns trying to advance to each other's next matching document, often
+     * jumping past the target document. When both land on the same document, it's
+     * collected.
+     * <p>
+     * Note: This strategy uses the query to lead the iteration.
+     * </p>
+     */
+    public static final FilterStrategy LEAP_FROG_QUERY_FIRST_STRATEGY = new LeapFrogFilterStrategy(true);
+
+    /**
+     * A filter strategy that advances the Query or rather its {@link Scorer} first and consults the
+     * filter {@link DocIdSet} for each matched document.
+     * <p>
+     * Note: this strategy requires a {@link DocIdSet#bits()} to return a non-null value. Otherwise
+     * this strategy falls back to {@link XFilteredQuery#LEAP_FROG_QUERY_FIRST_STRATEGY}
+     * </p>
+     * <p>
+     * Use this strategy if the filter computation is more expensive than document
+     * scoring or if the filter has a linear running time to compute the next
+     * matching doc like exact geo distances.
+     * </p>
+     */
+    public static final FilterStrategy QUERY_FIRST_FILTER_STRATEGY = new QueryFirstFilterStrategy();
+
+    /**
+     * Abstract class that defines how the filter ({@link DocIdSet}) applied during document collection.
+     */
+    public static abstract class FilterStrategy {
+
+        /**
+         * Returns a filtered {@link Scorer} based on this strategy.
+         *
+         * @param context          the {@link AtomicReaderContext} for which to return the {@link Scorer}.
+         * @param scoreDocsInOrder specifies whether in-order scoring of documents is required. Note
+         *                         that if set to false (i.e., out-of-order scoring is required),
+         *                         this method can return whatever scoring mode it supports, as every
+         *                         in-order scorer is also an out-of-order one. However, an
+         *                         out-of-order scorer may not support {@link Scorer#nextDoc()}
+         *                         and/or {@link Scorer#advance(int)}, therefore it is recommended to
+         *                         request an in-order scorer if use of these methods is required.
+         * @param topScorer        if true, {@link Scorer#score(Collector)} will be called; if false,
+         *                         {@link Scorer#nextDoc()} and/or {@link Scorer#advance(int)} will
+         *                         be called.
+         * @param weight           the {@link FilteredQuery} {@link Weight} to create the filtered scorer.
+         * @param docIdSet         the filter {@link DocIdSet} to apply
+         * @return a filtered scorer
+         * @throws IOException if an {@link IOException} occurs
+         */
+        public abstract Scorer filteredScorer(AtomicReaderContext context,
+                                              boolean scoreDocsInOrder, boolean topScorer, Weight weight,
+                                              DocIdSet docIdSet) throws IOException;
+    }
+
+    /**
+     * A {@link FilterStrategy} that conditionally uses a random access filter if
+     * the given {@link DocIdSet} supports random access (returns a non-null value
+     * from {@link DocIdSet#bits()}) and
+     * {@link RandomAccessFilterStrategy#useRandomAccess(Bits, int)} returns
+     * <code>true</code>. Otherwise this strategy falls back to a "zig-zag join" (
+     * {@link XFilteredQuery#LEAP_FROG_FILTER_FIRST_STRATEGY}) strategy .
+     */
+    public static class RandomAccessFilterStrategy extends FilterStrategy {
+
+        @Override
+        public Scorer filteredScorer(AtomicReaderContext context, boolean scoreDocsInOrder, boolean topScorer, Weight weight, DocIdSet docIdSet) throws IOException {
+            final DocIdSetIterator filterIter = docIdSet.iterator();
+            if (filterIter == null) {
+                // this means the filter does not accept any documents.
+                return null;
+            }
+
+            final int firstFilterDoc = filterIter.nextDoc();
+            if (firstFilterDoc == DocIdSetIterator.NO_MORE_DOCS) {
+                return null;
+            }
+
+            final Bits filterAcceptDocs = docIdSet.bits();
+            // force if RA is requested
+            final boolean useRandomAccess = (filterAcceptDocs != null && (useRandomAccess(filterAcceptDocs, firstFilterDoc)));
+            if (useRandomAccess) {
+                // if we are using random access, we return the inner scorer, just with other acceptDocs
+                return weight.scorer(context, scoreDocsInOrder, topScorer, filterAcceptDocs);
+            } else {
+                assert firstFilterDoc > -1;
+                // we are gonna advance() this scorer, so we set inorder=true/toplevel=false
+                // we pass null as acceptDocs, as our filter has already respected acceptDocs, no need to do twice
+                final Scorer scorer = weight.scorer(context, true, false, null);
+                // TODO once we have way to figure out if we use RA or LeapFrog we can remove this scorer
+                return (scorer == null) ? null : new PrimaryAdvancedLeapFrogScorer(weight, firstFilterDoc, filterIter, scorer);
+            }
+        }
+
+        /**
+         * Expert: decides if a filter should be executed as "random-access" or not.
+         * random-access means the filter "filters" in a similar way as deleted docs are filtered
+         * in Lucene. This is faster when the filter accepts many documents.
+         * However, when the filter is very sparse, it can be faster to execute the query+filter
+         * as a conjunction in some cases.
+         * <p/>
+         * The default implementation returns <code>true</code> if the first document accepted by the
+         * filter is < 100.
+         *
+         * @lucene.internal
+         */
+        protected boolean useRandomAccess(Bits bits, int firstFilterDoc) {
+            //TODO once we have a cost API on filters and scorers we should rethink this heuristic
+            return firstFilterDoc < 100;
+        }
+    }
+
+    private static final class LeapFrogFilterStrategy extends FilterStrategy {
+
+        private final boolean scorerFirst;
+
+        private LeapFrogFilterStrategy(boolean scorerFirst) {
+            this.scorerFirst = scorerFirst;
+        }
+
+        @Override
+        public Scorer filteredScorer(AtomicReaderContext context,
+                                     boolean scoreDocsInOrder, boolean topScorer, Weight weight,
+                                     DocIdSet docIdSet) throws IOException {
+            final DocIdSetIterator filterIter = docIdSet.iterator();
+            if (filterIter == null) {
+                // this means the filter does not accept any documents.
+                return null;
+            }
+            // we are gonna advance() this scorer, so we set inorder=true/toplevel=false
+            // we pass null as acceptDocs, as our filter has already respected acceptDocs, no need to do twice
+            final Scorer scorer = weight.scorer(context, true, false, null);
+            if (scorerFirst) {
+                return (scorer == null) ? null : new LeapFrogScorer(weight, scorer, filterIter, scorer);
+            } else {
+                return (scorer == null) ? null : new LeapFrogScorer(weight, filterIter, scorer, scorer);
+            }
+        }
+
+    }
+
+    /**
+     * A filter strategy that advances the {@link Scorer} first and consults the
+     * {@link DocIdSet} for each matched document.
+     * <p>
+     * Note: this strategy requires a {@link DocIdSet#bits()} to return a non-null value. Otherwise
+     * this strategy falls back to {@link XFilteredQuery#LEAP_FROG_QUERY_FIRST_STRATEGY}
+     * </p>
+     * <p>
+     * Use this strategy if the filter computation is more expensive than document
+     * scoring or if the filter has a linear running time to compute the next
+     * matching doc like exact geo distances.
+     * </p>
+     */
+    private static final class QueryFirstFilterStrategy extends FilterStrategy {
+        @Override
+        public Scorer filteredScorer(final AtomicReaderContext context,
+                                     boolean scoreDocsInOrder, boolean topScorer, Weight weight,
+                                     DocIdSet docIdSet) throws IOException {
+            Bits filterAcceptDocs = docIdSet.bits();
+            if (filterAcceptDocs == null) {
+                return LEAP_FROG_QUERY_FIRST_STRATEGY.filteredScorer(context, scoreDocsInOrder, topScorer, weight, docIdSet);
+            }
+            final Scorer scorer = weight.scorer(context, true, false, null);
+            return scorer == null ? null : new QueryFirstScorer(weight,
+                    filterAcceptDocs, scorer);
+        }
+    }
+
+    // CHANGE: Add custom random access strategy, allowing to set the threshold
+    // CHANGE: Add filter first filter strategy
+    public static final FilterStrategy FILTER_FIRST_FILTER_STRATEGY = new CustomRandomAccessFilterStrategy(0);
+
+    /**
+     * A {@link FilterStrategy} that conditionally uses a random access filter if
+     * the given {@link DocIdSet} supports random access (returns a non-null value
+     * from {@link DocIdSet#bits()}) and
+     * {@link RandomAccessFilterStrategy#useRandomAccess(Bits, int)} returns
+     * <code>true</code>. Otherwise this strategy falls back to a "zig-zag join" (
+     * {@link XFilteredQuery#LEAP_FROG_FILTER_FIRST_STRATEGY}) strategy .
+     */
+    public static class CustomRandomAccessFilterStrategy extends FilterStrategy {
+
+        private final int threshold;
+
+        public CustomRandomAccessFilterStrategy() {
+            this.threshold = -1;
+        }
+
+        public CustomRandomAccessFilterStrategy(int threshold) {
+            this.threshold = threshold;
+        }
+
+        @Override
+        public Scorer filteredScorer(AtomicReaderContext context, boolean scoreDocsInOrder, boolean topScorer, Weight weight, DocIdSet docIdSet) throws IOException {
+            // CHANGE: If threshold is 0, always pass down the accept docs, don't pay the price of calling nextDoc even...
+            if (threshold == 0) {
+                final Bits filterAcceptDocs = docIdSet.bits();
+                if (filterAcceptDocs != null) {
+                    return weight.scorer(context, scoreDocsInOrder, topScorer, filterAcceptDocs);
+                } else {
+                    return LEAP_FROG_QUERY_FIRST_STRATEGY.filteredScorer(context, scoreDocsInOrder, topScorer, weight, docIdSet);
+                }
+            }
+
+            // CHANGE: handle "default" value
+            if (threshold == -1) {
+                // default  value, don't iterate on only apply filter after query if its not a "fast" docIdSet
+                if (!DocIdSets.isFastIterator(docIdSet)) {
+                    return QUERY_FIRST_FILTER_STRATEGY.filteredScorer(context, scoreDocsInOrder, topScorer, weight, docIdSet);
+                }
+            }
+
+            final DocIdSetIterator filterIter = docIdSet.iterator();
+            if (filterIter == null) {
+                // this means the filter does not accept any documents.
+                return null;
+            }
+
+            final int firstFilterDoc = filterIter.nextDoc();
+            if (firstFilterDoc == DocIdSetIterator.NO_MORE_DOCS) {
+                return null;
+            }
+
+            final Bits filterAcceptDocs = docIdSet.bits();
+            // force if RA is requested
+            final boolean useRandomAccess = (filterAcceptDocs != null && (useRandomAccess(filterAcceptDocs, firstFilterDoc)));
+            if (useRandomAccess) {
+                // if we are using random access, we return the inner scorer, just with other acceptDocs
+                return weight.scorer(context, scoreDocsInOrder, topScorer, filterAcceptDocs);
+            } else {
+                assert firstFilterDoc > -1;
+                // we are gonna advance() this scorer, so we set inorder=true/toplevel=false
+                // we pass null as acceptDocs, as our filter has already respected acceptDocs, no need to do twice
+                final Scorer scorer = weight.scorer(context, true, false, null);
+                // TODO once we have way to figure out if we use RA or LeapFrog we can remove this scorer
+                return (scorer == null) ? null : new PrimaryAdvancedLeapFrogScorer(weight, firstFilterDoc, filterIter, scorer);
+            }
+        }
+
+        /**
+         * Expert: decides if a filter should be executed as "random-access" or not.
+         * random-access means the filter "filters" in a similar way as deleted docs are filtered
+         * in Lucene. This is faster when the filter accepts many documents.
+         * However, when the filter is very sparse, it can be faster to execute the query+filter
+         * as a conjunction in some cases.
+         * <p/>
+         * The default implementation returns <code>true</code> if the first document accepted by the
+         * filter is < 100.
+         *
+         * @lucene.internal
+         */
+        protected boolean useRandomAccess(Bits bits, int firstFilterDoc) {
+            // "default"
+            if (threshold == -1) {
+                return firstFilterDoc < 100;
+            }
+            //TODO once we have a cost API on filters and scorers we should rethink this heuristic
+            return firstFilterDoc < threshold;
+        }
+    }
+}

src/main/java/org/elasticsearch/index/engine/robin/RobinEngine.java

@@ -21,7 +21,10 @@ package org.elasticsearch.index.engine.robin;
 
 import com.google.common.collect.Lists;
 import org.apache.lucene.index.*;
-import org.apache.lucene.search.*;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.SearcherFactory;
+import org.apache.lucene.search.SearcherManager;
 import org.apache.lucene.store.AlreadyClosedException;
 import org.elasticsearch.ElasticSearchException;
 import org.elasticsearch.ElasticSearchIllegalStateException;
@@ -32,6 +35,7 @@ import org.elasticsearch.common.Preconditions;
 import org.elasticsearch.common.collect.MapBuilder;
 import org.elasticsearch.common.inject.Inject;
 import org.elasticsearch.common.lucene.Lucene;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.common.lucene.uid.UidField;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.unit.ByteSizeUnit;
@@ -690,11 +694,11 @@ public class RobinEngine extends AbstractIndexShardComponent implements Engine {
 
             Query query;
             if (delete.nested() && delete.aliasFilter() != null) {
-                query = new IncludeNestedDocsQuery(new FilteredQuery(delete.query(), delete.aliasFilter()), delete.parentFilter());
+                query = new IncludeNestedDocsQuery(new XFilteredQuery(delete.query(), delete.aliasFilter()), delete.parentFilter());
             } else if (delete.nested()) {
                 query = new IncludeNestedDocsQuery(delete.query(), delete.parentFilter());
             } else if (delete.aliasFilter() != null) {
-                query = new FilteredQuery(delete.query(), delete.aliasFilter());
+                query = new XFilteredQuery(delete.query(), delete.aliasFilter());
             } else {
                 query = delete.query();
             }

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

@@ -29,8 +29,8 @@ import org.apache.lucene.search.PrefixFilter;
 import org.apache.lucene.search.Query;
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.common.lucene.Lucene;
-import org.elasticsearch.common.lucene.search.DeletionAwareConstantScoreQuery;
 import org.elasticsearch.common.lucene.search.TermFilter;
+import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
 import org.elasticsearch.common.xcontent.XContentBuilder;
 import org.elasticsearch.index.codec.postingsformat.PostingsFormatProvider;
 import org.elasticsearch.index.mapper.*;
@@ -145,7 +145,7 @@ public class TypeFieldMapper extends AbstractFieldMapper<String> implements Inte
 
     @Override
     public Query fieldQuery(String value, @Nullable QueryParseContext context) {
-        return new DeletionAwareConstantScoreQuery(context.cacheFilter(fieldFilter(value, context), null));
+        return new XConstantScoreQuery(context.cacheFilter(fieldFilter(value, context), null));
     }
 
     @Override

src/main/java/org/elasticsearch/index/percolator/PercolatorService.java

@@ -31,8 +31,8 @@ import org.apache.lucene.search.Scorer;
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.common.bytes.BytesArray;
 import org.elasticsearch.common.inject.Inject;
-import org.elasticsearch.common.lucene.search.DeletionAwareConstantScoreQuery;
 import org.elasticsearch.common.lucene.search.TermFilter;
+import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.index.AbstractIndexComponent;
 import org.elasticsearch.index.Index;
@@ -129,7 +129,7 @@ public class PercolatorService extends AbstractIndexComponent {
         try {
             // create a query to fetch all queries that are registered under the index name (which is the type
             // in the percolator).
-            Query query = new DeletionAwareConstantScoreQuery(indexQueriesFilter(indexName));
+            Query query = new XConstantScoreQuery(indexQueriesFilter(indexName));
             QueriesLoaderCollector queries = new QueriesLoaderCollector();
             searcher.searcher().search(query, queries);
             percolator.addQueries(queries.queries());

src/main/java/org/elasticsearch/index/query/ConstantScoreQueryParser.java

@@ -24,7 +24,7 @@ import org.apache.lucene.search.Filter;
 import org.apache.lucene.search.Query;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.inject.Inject;
-import org.elasticsearch.common.lucene.search.DeletionAwareConstantScoreQuery;
+import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.index.cache.filter.support.CacheKeyFilter;
 
@@ -99,7 +99,7 @@ public class ConstantScoreQueryParser implements QueryParser {
                 filter = parseContext.cacheFilter(filter, cacheKey);
             }
 
-            Query query1 = new DeletionAwareConstantScoreQuery(filter);
+            Query query1 = new XConstantScoreQuery(filter);
             query1.setBoost(boost);
             return query1;
         }

src/main/java/org/elasticsearch/index/query/FilteredQueryParser.java

@@ -20,11 +20,11 @@
 package org.elasticsearch.index.query;
 
 import org.apache.lucene.search.Filter;
-import org.apache.lucene.search.FilteredQuery;
 import org.apache.lucene.search.Query;
 import org.elasticsearch.common.inject.Inject;
-import org.elasticsearch.common.lucene.search.DeletionAwareConstantScoreQuery;
 import org.elasticsearch.common.lucene.search.Queries;
+import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.index.cache.filter.support.CacheKeyFilter;
 
@@ -109,23 +109,14 @@ public class FilteredQueryParser implements QueryParser {
 
         // if its a match_all query, use constant_score
         if (Queries.isConstantMatchAllQuery(query)) {
-            Query q = new DeletionAwareConstantScoreQuery(filter);
+            Query q = new XConstantScoreQuery(filter);
             q.setBoost(boost);
             return q;
         }
 
-        // TODO
+        // TODO: Lucene 4 Upgrade: we need to expose filter strategy
-        // With the way filtered queries work today, both query and filter advance (one at a time)
-        // to get hits. Since all filters support random access, it might make sense to use that.
-        // But, it make more sense to apply it down at the postings level then letting the query
-        // construct doc ids and extract it.
-        // This might be possible in lucene 4.0.
-        // More info:
-        //    - https://issues.apache.org/jira/browse/LUCENE-1536
-        //    - http://chbits.blogspot.com/2010/09/fast-search-filters-using-flex.html
 
-
+        XFilteredQuery filteredQuery = new XFilteredQuery(query, filter);
-        FilteredQuery filteredQuery = new FilteredQuery(query, filter);
         filteredQuery.setBoost(boost);
         return filteredQuery;
     }

src/main/java/org/elasticsearch/index/query/HasChildFilterParser.java

@@ -20,10 +20,10 @@
 package org.elasticsearch.index.query;
 
 import org.apache.lucene.search.Filter;
-import org.apache.lucene.search.FilteredQuery;
 import org.apache.lucene.search.Query;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.inject.Inject;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.index.mapper.DocumentMapper;
 import org.elasticsearch.index.search.child.HasChildFilter;
@@ -111,7 +111,7 @@ public class HasChildFilterParser implements FilterParser {
         String parentType = childDocMapper.parentFieldMapper().type();
 
         // wrap the query with type query
-        query = new FilteredQuery(query, parseContext.cacheFilter(childDocMapper.typeFilter(), null));
+        query = new XFilteredQuery(query, parseContext.cacheFilter(childDocMapper.typeFilter(), null));
 
         SearchContext searchContext = SearchContext.current();
 

src/main/java/org/elasticsearch/index/query/HasChildQueryParser.java

@@ -20,10 +20,10 @@
 package org.elasticsearch.index.query;
 
 import org.apache.lucene.search.ConstantScoreQuery;
-import org.apache.lucene.search.FilteredQuery;
 import org.apache.lucene.search.Query;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.inject.Inject;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.index.mapper.DocumentMapper;
 import org.elasticsearch.index.search.child.HasChildFilter;
@@ -112,7 +112,7 @@ public class HasChildQueryParser implements QueryParser {
 
         query.setBoost(boost);
         // wrap the query with type query
-        query = new FilteredQuery(query, parseContext.cacheFilter(childDocMapper.typeFilter(), null));
+        query = new XFilteredQuery(query, parseContext.cacheFilter(childDocMapper.typeFilter(), null));
 
         SearchContext searchContext = SearchContext.current();
         HasChildFilter childFilter = HasChildFilter.create(query, scope, parentType, childType, searchContext, executionType);

src/main/java/org/elasticsearch/index/query/HasParentFilterParser.java

@@ -20,14 +20,12 @@
 package org.elasticsearch.index.query;
 
 import org.apache.lucene.search.Filter;
-import org.apache.lucene.search.FilteredQuery;
 import org.apache.lucene.search.Query;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.inject.Inject;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.index.mapper.DocumentMapper;
-import org.elasticsearch.index.mapper.FieldMapper;
-import org.elasticsearch.index.mapper.internal.ParentFieldMapper;
 import org.elasticsearch.index.search.child.HasParentFilter;
 import org.elasticsearch.search.internal.SearchContext;
 
@@ -109,7 +107,7 @@ public class HasParentFilterParser implements FilterParser {
         }
 
         // wrap the query with type query
-        query = new FilteredQuery(query, parseContext.cacheFilter(parentDocMapper.typeFilter(), null));
+        query = new XFilteredQuery(query, parseContext.cacheFilter(parentDocMapper.typeFilter(), null));
 
         SearchContext searchContext = SearchContext.current();
 

src/main/java/org/elasticsearch/index/query/HasParentQueryParser.java

@@ -20,10 +20,10 @@
 package org.elasticsearch.index.query;
 
 import org.apache.lucene.search.ConstantScoreQuery;
-import org.apache.lucene.search.FilteredQuery;
 import org.apache.lucene.search.Query;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.inject.Inject;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.index.mapper.DocumentMapper;
 import org.elasticsearch.index.search.child.HasParentFilter;
@@ -106,7 +106,7 @@ public class HasParentQueryParser implements QueryParser {
 
         query.setBoost(boost);
         // wrap the query with type query
-        query = new FilteredQuery(query, parseContext.cacheFilter(parentDocMapper.typeFilter(), null));
+        query = new XFilteredQuery(query, parseContext.cacheFilter(parentDocMapper.typeFilter(), null));
         SearchContext searchContext = SearchContext.current();
         HasParentFilter parentFilter = HasParentFilter.create(executionType, query, scope, parentType, searchContext);
 

src/main/java/org/elasticsearch/index/query/NestedFilterParser.java

@@ -20,12 +20,12 @@
 package org.elasticsearch.index.query;
 
 import org.apache.lucene.search.Filter;
-import org.apache.lucene.search.FilteredQuery;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.QueryWrapperFilter;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.inject.Inject;
-import org.elasticsearch.common.lucene.search.DeletionAwareConstantScoreQuery;
+import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.index.cache.filter.support.CacheKeyFilter;
 import org.elasticsearch.index.mapper.MapperService;
@@ -116,7 +116,7 @@ public class NestedFilterParser implements FilterParser {
             }
 
             if (filter != null) {
-                query = new DeletionAwareConstantScoreQuery(filter);
+                query = new XConstantScoreQuery(filter);
             }
 
             query.setBoost(boost);
@@ -136,7 +136,7 @@ public class NestedFilterParser implements FilterParser {
             Filter childFilter = parseContext.cacheFilter(objectMapper.nestedTypeFilter(), null);
             usAsParentFilter.filter = childFilter;
             // wrap the child query to only work on the nested path type
-            query = new FilteredQuery(query, childFilter);
+            query = new XFilteredQuery(query, childFilter);
 
             Filter parentFilter = currentParentFilterContext;
             if (parentFilter == null) {

src/main/java/org/elasticsearch/index/query/NestedQueryParser.java

@@ -22,12 +22,12 @@ package org.elasticsearch.index.query;
 import org.apache.lucene.index.AtomicReaderContext;
 import org.apache.lucene.search.DocIdSet;
 import org.apache.lucene.search.Filter;
-import org.apache.lucene.search.FilteredQuery;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.util.Bits;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.inject.Inject;
-import org.elasticsearch.common.lucene.search.DeletionAwareConstantScoreQuery;
+import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.index.mapper.MapperService;
 import org.elasticsearch.index.mapper.object.ObjectMapper;
@@ -122,7 +122,7 @@ public class NestedQueryParser implements QueryParser {
             }
 
             if (filter != null) {
-                query = new DeletionAwareConstantScoreQuery(filter);
+                query = new XConstantScoreQuery(filter);
             }
 
             MapperService.SmartNameObjectMapper mapper = parseContext.smartObjectMapper(path);
@@ -140,7 +140,7 @@ public class NestedQueryParser implements QueryParser {
             Filter childFilter = parseContext.cacheFilter(objectMapper.nestedTypeFilter(), null);
             usAsParentFilter.filter = childFilter;
             // wrap the child query to only work on the nested path type
-            query = new FilteredQuery(query, childFilter);
+            query = new XFilteredQuery(query, childFilter);
 
             Filter parentFilter = currentParentFilterContext;
             if (parentFilter == null) {

src/main/java/org/elasticsearch/index/query/TopChildrenQueryParser.java

@@ -19,10 +19,10 @@
 
 package org.elasticsearch.index.query;
 
-import org.apache.lucene.search.FilteredQuery;
 import org.apache.lucene.search.Query;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.inject.Inject;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.index.mapper.DocumentMapper;
 import org.elasticsearch.index.search.child.TopChildrenQuery;
@@ -118,7 +118,7 @@ public class TopChildrenQueryParser implements QueryParser {
 
         query.setBoost(boost);
         // wrap the query with type query
-        query = new FilteredQuery(query, parseContext.cacheFilter(childDocMapper.typeFilter(), null));
+        query = new XFilteredQuery(query, parseContext.cacheFilter(childDocMapper.typeFilter(), null));
 
         SearchContext searchContext = SearchContext.current();
         TopChildrenQuery childQuery = new TopChildrenQuery(query, scope, childType, parentType, scoreType, factor, incrementalFactor);

src/main/java/org/elasticsearch/index/query/support/QueryParsers.java

@@ -21,12 +21,12 @@ package org.elasticsearch.index.query.support;
 
 import com.google.common.collect.ImmutableList;
 import org.apache.lucene.search.Filter;
-import org.apache.lucene.search.FilteredQuery;
 import org.apache.lucene.search.MultiTermQuery;
 import org.apache.lucene.search.Query;
 import org.elasticsearch.ElasticSearchIllegalArgumentException;
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.common.lucene.search.AndFilter;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.index.mapper.DocumentMapper;
 import org.elasticsearch.index.mapper.MapperService;
 import org.elasticsearch.index.query.QueryParseContext;
@@ -105,7 +105,7 @@ public final class QueryParsers {
             return query;
         }
         DocumentMapper docMapper = smartFieldMappers.docMapper();
-        return new FilteredQuery(query, parseContext.cacheFilter(docMapper.typeFilter(), null));
+        return new XFilteredQuery(query, parseContext.cacheFilter(docMapper.typeFilter(), null));
     }
 
     public static Filter wrapSmartNameFilter(Filter filter, @Nullable MapperService.SmartNameFieldMappers smartFieldMappers,

src/main/java/org/elasticsearch/index/shard/service/InternalIndexShard.java

@@ -23,7 +23,6 @@ import com.google.common.base.Charsets;
 import org.apache.lucene.index.CheckIndex;
 import org.apache.lucene.index.DirectoryReader;
 import org.apache.lucene.search.Filter;
-import org.apache.lucene.search.FilteredQuery;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.util.ThreadInterruptedException;
 import org.elasticsearch.ElasticSearchException;
@@ -37,6 +36,7 @@ import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.bytes.BytesReference;
 import org.elasticsearch.common.inject.Inject;
 import org.elasticsearch.common.io.FastByteArrayOutputStream;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.common.metrics.MeanMetric;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.unit.TimeValue;
@@ -681,7 +681,7 @@ public class InternalIndexShard extends AbstractIndexShardComponent implements I
     private Query filterQueryIfNeeded(Query query, String[] types) {
         Filter searchFilter = mapperService.searchFilter(types);
         if (searchFilter != null) {
-            query = new FilteredQuery(query, indexCache.filter().cache(searchFilter));
+            query = new XFilteredQuery(query, indexCache.filter().cache(searchFilter));
         }
         return query;
     }

src/main/java/org/elasticsearch/search/facet/FacetPhase.java

@@ -22,11 +22,15 @@ package org.elasticsearch.search.facet;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
-import org.apache.lucene.search.*;
+import org.apache.lucene.search.Collector;
+import org.apache.lucene.search.Filter;
+import org.apache.lucene.search.MultiCollector;
+import org.apache.lucene.search.Query;
 import org.elasticsearch.ElasticSearchException;
 import org.elasticsearch.common.inject.Inject;
-import org.elasticsearch.common.lucene.search.DeletionAwareConstantScoreQuery;
 import org.elasticsearch.common.lucene.search.Queries;
+import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.index.search.nested.BlockJoinQuery;
 import org.elasticsearch.search.SearchParseElement;
 import org.elasticsearch.search.SearchPhase;
@@ -120,10 +124,10 @@ public class FacetPhase implements SearchPhase {
             // now, go and execute the filters->collector ones
             for (Map.Entry<Filter, List<Collector>> entry : filtersByCollector.entrySet()) {
                 Filter filter = entry.getKey();
-                Query query = new DeletionAwareConstantScoreQuery(filter);
+                Query query = new XConstantScoreQuery(filter);
                 Filter searchFilter = context.mapperService().searchFilter(context.types());
                 if (searchFilter != null) {
-                    query = new FilteredQuery(query, context.filterCache().cache(searchFilter));
+                    query = new XFilteredQuery(query, context.filterCache().cache(searchFilter));
                 }
                 try {
                     context.searcher().search(query, MultiCollector.wrap(entry.getValue().toArray(new Collector[entry.getValue().size()])));

src/main/java/org/elasticsearch/search/facet/filter/FilterFacetCollector.java

@@ -21,12 +21,12 @@ package org.elasticsearch.search.facet.filter;
 
 import org.apache.lucene.index.AtomicReaderContext;
 import org.apache.lucene.search.Filter;
-import org.apache.lucene.search.FilteredQuery;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.TotalHitCountCollector;
 import org.apache.lucene.util.Bits;
 import org.elasticsearch.common.lucene.docset.DocIdSets;
-import org.elasticsearch.common.lucene.search.DeletionAwareConstantScoreQuery;
+import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.index.cache.filter.FilterCache;
 import org.elasticsearch.search.facet.AbstractFacetCollector;
 import org.elasticsearch.search.facet.Facet;
@@ -53,13 +53,13 @@ public class FilterFacetCollector extends AbstractFacetCollector implements Opti
 
     @Override
     public void optimizedGlobalExecution(SearchContext searchContext) throws IOException {
-        Query query = new DeletionAwareConstantScoreQuery(filter);
+        Query query = new XConstantScoreQuery(filter);
         if (super.filter != null) {
-            query = new FilteredQuery(query, super.filter);
+            query = new XFilteredQuery(query, super.filter);
         }
         Filter searchFilter = searchContext.mapperService().searchFilter(searchContext.types());
         if (searchFilter != null) {
-            query = new FilteredQuery(query, searchContext.filterCache().cache(searchFilter));
+            query = new XFilteredQuery(query, searchContext.filterCache().cache(searchFilter));
         }
         TotalHitCountCollector collector = new TotalHitCountCollector();
         searchContext.searcher().search(query, collector);

src/main/java/org/elasticsearch/search/facet/query/QueryFacetCollector.java

@@ -23,8 +23,9 @@ import org.apache.lucene.index.AtomicReaderContext;
 import org.apache.lucene.search.*;
 import org.apache.lucene.util.Bits;
 import org.elasticsearch.common.lucene.docset.DocIdSets;
-import org.elasticsearch.common.lucene.search.DeletionAwareConstantScoreQuery;
 import org.elasticsearch.common.lucene.search.Queries;
+import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.index.cache.filter.FilterCache;
 import org.elasticsearch.search.facet.AbstractFacetCollector;
 import org.elasticsearch.search.facet.Facet;
@@ -73,11 +74,11 @@ public class QueryFacetCollector extends AbstractFacetCollector implements Optim
     public void optimizedGlobalExecution(SearchContext searchContext) throws IOException {
         Query query = this.query;
         if (super.filter != null) {
-            query = new FilteredQuery(query, super.filter);
+            query = new XFilteredQuery(query, super.filter);
         }
         Filter searchFilter = searchContext.mapperService().searchFilter(searchContext.types());
         if (searchFilter != null) {
-            query = new FilteredQuery(query, searchContext.filterCache().cache(searchFilter));
+            query = new XFilteredQuery(query, searchContext.filterCache().cache(searchFilter));
         }
         TotalHitCountCollector collector = new TotalHitCountCollector();
         searchContext.searcher().search(query, collector);
@@ -93,13 +94,13 @@ public class QueryFacetCollector extends AbstractFacetCollector implements Optim
      * If its a filtered query with a match all, then we just need the inner filter.
      */
     private Filter extractFilterIfApplicable(Query query) {
-        if (query instanceof FilteredQuery) {
+        if (query instanceof XFilteredQuery) {
-            FilteredQuery fQuery = (FilteredQuery) query;
+            XFilteredQuery fQuery = (XFilteredQuery) query;
             if (Queries.isConstantMatchAllQuery(fQuery.getQuery())) {
                 return fQuery.getFilter();
             }
-        } else if (query instanceof DeletionAwareConstantScoreQuery) {
+        } else if (query instanceof XConstantScoreQuery) {
-            return ((DeletionAwareConstantScoreQuery) query).getFilter();
+            return ((XConstantScoreQuery) query).getFilter();
         } else if (query instanceof ConstantScoreQuery) {
             ConstantScoreQuery constantScoreQuery = (ConstantScoreQuery) query;
             if (constantScoreQuery.getFilter() != null) {

src/main/java/org/elasticsearch/search/highlight/CustomQueryScorer.java

@@ -26,6 +26,7 @@ import org.apache.lucene.search.Query;
 import org.apache.lucene.search.highlight.QueryScorer;
 import org.apache.lucene.search.highlight.WeightedSpanTerm;
 import org.apache.lucene.search.highlight.WeightedSpanTermExtractor;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.common.lucene.search.function.FiltersFunctionScoreQuery;
 import org.elasticsearch.common.lucene.search.function.FunctionScoreQuery;
 
@@ -93,6 +94,9 @@ public final class CustomQueryScorer extends QueryScorer {
             } else if (query instanceof FilteredQuery) {
                 query = ((FilteredQuery) query).getQuery();
                 extract(query, terms);
+            } else if (query instanceof XFilteredQuery) {
+                query = ((XFilteredQuery) query).getQuery();
+                extract(query, terms);
             }
         }
 

src/main/java/org/elasticsearch/search/internal/ContextIndexSearcher.java

@@ -29,6 +29,7 @@ import org.elasticsearch.common.lucene.MinimumScoreCollector;
 import org.elasticsearch.common.lucene.MultiCollector;
 import org.elasticsearch.common.lucene.search.AndFilter;
 import org.elasticsearch.common.lucene.search.FilteredCollector;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.index.engine.Engine;
 import org.elasticsearch.search.dfs.CachedDfSource;
 
@@ -205,7 +206,7 @@ public class ContextIndexSearcher extends IndexSearcher {
             return super.explain(query, doc);
         }
 
-        FilteredQuery filteredQuery = new FilteredQuery(query, searchContext.aliasFilter());
+        XFilteredQuery filteredQuery = new XFilteredQuery(query, searchContext.aliasFilter());
         return super.explain(filteredQuery, doc);
     }
 }

src/main/java/org/elasticsearch/search/internal/SearchContext.java

@@ -22,15 +22,15 @@ package org.elasticsearch.search.internal;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
 import org.apache.lucene.search.Filter;
-import org.apache.lucene.search.FilteredQuery;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.Sort;
 import org.elasticsearch.ElasticSearchException;
 import org.elasticsearch.action.search.SearchType;
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.common.lease.Releasable;
-import org.elasticsearch.common.lucene.search.DeletionAwareConstantScoreQuery;
 import org.elasticsearch.common.lucene.search.Queries;
+import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.common.lucene.search.function.BoostScoreFunction;
 import org.elasticsearch.common.lucene.search.function.FunctionScoreQuery;
 import org.elasticsearch.index.analysis.AnalysisService;
@@ -220,11 +220,11 @@ public class SearchContext implements Releasable {
         Filter searchFilter = mapperService().searchFilter(types());
         if (searchFilter != null) {
             if (Queries.isConstantMatchAllQuery(query())) {
-                Query q = new DeletionAwareConstantScoreQuery(filterCache().cache(searchFilter));
+                Query q = new XConstantScoreQuery(filterCache().cache(searchFilter));
                 q.setBoost(query().getBoost());
                 parsedQuery(new ParsedQuery(q, parsedQuery()));
             } else {
-                parsedQuery(new ParsedQuery(new FilteredQuery(query(), filterCache().cache(searchFilter)), parsedQuery()));
+                parsedQuery(new ParsedQuery(new XFilteredQuery(query(), filterCache().cache(searchFilter)), parsedQuery()));
             }
         }
     }

src/main/java/org/elasticsearch/search/scan/ScanContext.java

@@ -6,6 +6,7 @@ import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.search.*;
 import org.apache.lucene.util.Bits;
 import org.elasticsearch.common.lucene.docset.AllDocIdSet;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.search.internal.SearchContext;
 
 import java.io.IOException;
@@ -27,7 +28,7 @@ public class ScanContext {
 
     public TopDocs execute(SearchContext context) throws IOException {
         ScanCollector collector = new ScanCollector(readerStates, context.from(), context.size(), context.trackScores());
-        Query query = new FilteredQuery(context.query(), new ScanFilter(readerStates, collector));
+        Query query = new XFilteredQuery(context.query(), new ScanFilter(readerStates, collector));
         try {
             context.searcher().search(query, collector);
         } catch (ScanCollector.StopCollectingException e) {

src/test/java/org/elasticsearch/test/integration/validate/SimpleValidateQueryTests.java

@@ -154,24 +154,24 @@ public class SimpleValidateQueryTests extends AbstractNodesTests {
                         .addPoint(40, -70)
                         .addPoint(30, -80)
                         .addPoint(20, -90)
-        ), equalTo("ConstantScore(NotDeleted(GeoPolygonFilter(pin.location, [[40.0, -70.0], [30.0, -80.0], [20.0, -90.0]])))"));
+        ), equalTo("ConstantScore(GeoPolygonFilter(pin.location, [[40.0, -70.0], [30.0, -80.0], [20.0, -90.0]]))"));
 
         assertExplanation(QueryBuilders.constantScoreQuery(FilterBuilders.geoBoundingBoxFilter("pin.location")
                 .topLeft(40, -80)
                 .bottomRight(20, -70)
-        ), equalTo("ConstantScore(NotDeleted(GeoBoundingBoxFilter(pin.location, [40.0, -80.0], [20.0, -70.0])))"));
+        ), equalTo("ConstantScore(GeoBoundingBoxFilter(pin.location, [40.0, -80.0], [20.0, -70.0]))"));
 
         assertExplanation(QueryBuilders.constantScoreQuery(FilterBuilders.geoDistanceFilter("pin.location")
                 .lat(10).lon(20).distance(15, DistanceUnit.MILES).geoDistance(GeoDistance.PLANE)
-        ), equalTo("ConstantScore(NotDeleted(GeoDistanceFilter(pin.location, PLANE, 15.0, 10.0, 20.0)))"));
+        ), equalTo("ConstantScore(GeoDistanceFilter(pin.location, PLANE, 15.0, 10.0, 20.0))"));
 
         assertExplanation(QueryBuilders.constantScoreQuery(FilterBuilders.geoDistanceFilter("pin.location")
                 .lat(10).lon(20).distance(15, DistanceUnit.MILES).geoDistance(GeoDistance.PLANE)
-        ), equalTo("ConstantScore(NotDeleted(GeoDistanceFilter(pin.location, PLANE, 15.0, 10.0, 20.0)))"));
+        ), equalTo("ConstantScore(GeoDistanceFilter(pin.location, PLANE, 15.0, 10.0, 20.0))"));
 
         assertExplanation(QueryBuilders.constantScoreQuery(FilterBuilders.geoDistanceRangeFilter("pin.location")
                 .lat(10).lon(20).from("15miles").to("25miles").geoDistance(GeoDistance.PLANE)
-        ), equalTo("ConstantScore(NotDeleted(GeoDistanceRangeFilter(pin.location, PLANE, [15.0 - 25.0], 10.0, 20.0)))"));
+        ), equalTo("ConstantScore(GeoDistanceRangeFilter(pin.location, PLANE, [15.0 - 25.0], 10.0, 20.0))"));
 
         assertExplanation(QueryBuilders.filteredQuery(
                 QueryBuilders.termQuery("foo", "1"),
@@ -182,10 +182,10 @@ public class SimpleValidateQueryTests extends AbstractNodesTests {
         ), equalTo("filtered(foo:1)->+cache(bar:[2 TO 2]) +cache(baz:3)"));
 
         assertExplanation(QueryBuilders.constantScoreQuery(FilterBuilders.termsFilter("foo", "1", "2", "3")),
-                equalTo("ConstantScore(NotDeleted(cache(foo:1 foo:2 foo:3)))"));
+                equalTo("ConstantScore(cache(foo:1 foo:2 foo:3))"));
 
         assertExplanation(QueryBuilders.constantScoreQuery(FilterBuilders.notFilter(FilterBuilders.termFilter("foo", "bar"))),
-                equalTo("ConstantScore(NotDeleted(NotFilter(cache(foo:bar))))"));
+                equalTo("ConstantScore(NotFilter(cache(foo:bar)))"));
 
         assertExplanation(QueryBuilders.filteredQuery(
                 QueryBuilders.termQuery("foo", "1"),
@@ -223,7 +223,7 @@ public class SimpleValidateQueryTests extends AbstractNodesTests {
 
 
         ValidateQueryResponse response;
-        response =  client("node1").admin().indices().prepareValidateQuery("test")
+        response = client("node1").admin().indices().prepareValidateQuery("test")
                 .setQuery("foo".getBytes())
                 .setExplain(true)
                 .execute().actionGet();
@@ -232,7 +232,7 @@ public class SimpleValidateQueryTests extends AbstractNodesTests {
         assertThat(response.queryExplanations().get(0).error(), containsString("Failed to parse"));
         assertThat(response.queryExplanations().get(0).explanation(), nullValue());
 
-        response =  client("node2").admin().indices().prepareValidateQuery("test")
+        response = client("node2").admin().indices().prepareValidateQuery("test")
                 .setQuery("foo".getBytes())
                 .setExplain(true)
                 .execute().actionGet();
@@ -241,7 +241,7 @@ public class SimpleValidateQueryTests extends AbstractNodesTests {
         assertThat(response.queryExplanations().get(0).error(), containsString("Failed to parse"));
         assertThat(response.queryExplanations().get(0).explanation(), nullValue());
 
-        response =  client("node1").admin().indices().prepareValidateQuery("test")
+        response = client("node1").admin().indices().prepareValidateQuery("test")
                 .setQuery(QueryBuilders.queryString("foo"))
                 .setExplain(true)
                 .execute().actionGet();
@@ -250,7 +250,7 @@ public class SimpleValidateQueryTests extends AbstractNodesTests {
         assertThat(response.queryExplanations().get(0).explanation(), equalTo("_all:foo"));
         assertThat(response.queryExplanations().get(0).error(), nullValue());
 
-        response =  client("node2").admin().indices().prepareValidateQuery("test")
+        response = client("node2").admin().indices().prepareValidateQuery("test")
                 .setQuery(QueryBuilders.queryString("foo"))
                 .setExplain(true)
                 .execute().actionGet();

src/test/java/org/elasticsearch/test/unit/common/lucene/search/MatchAllDocsFilterTests.java

@@ -29,8 +29,8 @@ import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.RAMDirectory;
 import org.elasticsearch.common.lucene.Lucene;
-import org.elasticsearch.common.lucene.search.DeletionAwareConstantScoreQuery;
 import org.elasticsearch.common.lucene.search.Queries;
+import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
 import org.testng.annotations.Test;
 
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -59,7 +59,7 @@ public class MatchAllDocsFilterTests {
         IndexReader reader = IndexReader.open(indexWriter, true);
         IndexSearcher searcher = new IndexSearcher(reader);
 
-        DeletionAwareConstantScoreQuery query = new DeletionAwareConstantScoreQuery(Queries.MATCH_ALL_FILTER);
+        XConstantScoreQuery query = new XConstantScoreQuery(Queries.MATCH_ALL_FILTER);
         long count = Lucene.count(searcher, query);
         assertThat(count, equalTo(2l));
 

src/test/java/org/elasticsearch/test/unit/index/cache/filter/FilterCacheTests.java

@@ -23,12 +23,16 @@ import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field;
 import org.apache.lucene.document.TextField;
 import org.apache.lucene.index.*;
-import org.apache.lucene.search.*;
+import org.apache.lucene.search.ConstantScoreQuery;
+import org.apache.lucene.search.Filter;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.MatchAllDocsQuery;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.RAMDirectory;
 import org.elasticsearch.common.lucene.Lucene;
-import org.elasticsearch.common.lucene.search.DeletionAwareConstantScoreQuery;
 import org.elasticsearch.common.lucene.search.TermFilter;
+import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
+import org.elasticsearch.common.lucene.search.XFilteredQuery;
 import org.elasticsearch.index.Index;
 import org.elasticsearch.index.cache.filter.FilterCache;
 import org.elasticsearch.index.cache.filter.none.NoneFilterCache;
@@ -65,7 +69,7 @@ public class FilterCacheTests {
         reader = refreshReader(reader);
         IndexSearcher searcher = new IndexSearcher(reader);
         assertThat(Lucene.count(searcher, new ConstantScoreQuery(filterCache.cache(new TermFilter(new Term("id", "1"))))), equalTo(1l));
-        assertThat(Lucene.count(searcher, new FilteredQuery(new MatchAllDocsQuery(), filterCache.cache(new TermFilter(new Term("id", "1"))))), equalTo(1l));
+        assertThat(Lucene.count(searcher, new XFilteredQuery(new MatchAllDocsQuery(), filterCache.cache(new TermFilter(new Term("id", "1"))))), equalTo(1l));
 
         indexWriter.deleteDocuments(new Term("id", "1"));
         reader = refreshReader(reader);
@@ -75,8 +79,8 @@ public class FilterCacheTests {
         long constantScoreCount = filter == cachedFilter ? 0 : 1;
         // sadly, when caching based on cacheKey with NRT, this fails, that's why we have DeletionAware one
         assertThat(Lucene.count(searcher, new ConstantScoreQuery(cachedFilter)), equalTo(constantScoreCount));
-        assertThat(Lucene.count(searcher, new DeletionAwareConstantScoreQuery(cachedFilter)), equalTo(0l));
+        assertThat(Lucene.count(searcher, new XConstantScoreQuery(cachedFilter)), equalTo(0l));
-        assertThat(Lucene.count(searcher, new FilteredQuery(new MatchAllDocsQuery(), cachedFilter)), equalTo(0l));
+        assertThat(Lucene.count(searcher, new XFilteredQuery(new MatchAllDocsQuery(), cachedFilter)), equalTo(0l));
 
         indexWriter.close();
     }

src/test/java/org/elasticsearch/test/unit/index/query/SimpleIndexQueryParserTests.java

@@ -569,8 +569,8 @@ public class SimpleIndexQueryParserTests {
     public void testPrefixFilteredQueryBuilder() throws IOException {
         IndexQueryParserService queryParser = queryParser();
         Query parsedQuery = queryParser.parse(filteredQuery(termQuery("name.first", "shay"), prefixFilter("name.first", "sh"))).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         PrefixFilter prefixFilter = (PrefixFilter) filteredQuery.getFilter();
         assertThat(prefixFilter.getPrefix(), equalTo(new Term("name.first", "sh")));
     }
@@ -580,8 +580,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/prefix-filter.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         PrefixFilter prefixFilter = (PrefixFilter) filteredQuery.getFilter();
         assertThat(prefixFilter.getPrefix(), equalTo(new Term("name.first", "sh")));
     }
@@ -592,8 +592,8 @@ public class SimpleIndexQueryParserTests {
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/prefix-filter-named.json");
         ParsedQuery parsedQuery = queryParser.parse(query);
         assertThat(parsedQuery.namedFilters().containsKey("test"), equalTo(true));
-        assertThat(parsedQuery.query(), instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery.query(), instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery.query();
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery.query();
         PrefixFilter prefixFilter = (PrefixFilter) filteredQuery.getFilter();
         assertThat(prefixFilter.getPrefix(), equalTo(new Term("name.first", "sh")));
     }
@@ -708,8 +708,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         Query parsedQuery = queryParser.parse(filteredQuery(termQuery("name.first", "shay"), rangeFilter("age").from(23).to(54).includeLower(true).includeUpper(false))).query();
         // since age is automatically registered in data, we encode it as numeric
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        Filter filter = ((FilteredQuery) parsedQuery).getFilter();
+        Filter filter = ((XFilteredQuery) parsedQuery).getFilter();
         assertThat(filter, instanceOf(NumericRangeFilter.class));
         NumericRangeFilter rangeFilter = (NumericRangeFilter) filter;
         assertThat(rangeFilter.getField(), equalTo("age"));
@@ -725,8 +725,8 @@ public class SimpleIndexQueryParserTests {
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/range-filter.json");
         Query parsedQuery = queryParser.parse(query).query();
         // since age is automatically registered in data, we encode it as numeric
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        Filter filter = ((FilteredQuery) parsedQuery).getFilter();
+        Filter filter = ((XFilteredQuery) parsedQuery).getFilter();
         assertThat(filter, instanceOf(NumericRangeFilter.class));
         NumericRangeFilter rangeFilter = (NumericRangeFilter) filter;
         assertThat(rangeFilter.getField(), equalTo("age"));
@@ -742,8 +742,8 @@ public class SimpleIndexQueryParserTests {
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/range-filter-named.json");
         ParsedQuery parsedQuery = queryParser.parse(query);
         assertThat(parsedQuery.namedFilters().containsKey("test"), equalTo(true));
-        assertThat(parsedQuery.query(), instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery.query(), instanceOf(XFilteredQuery.class));
-        Filter filter = ((FilteredQuery) parsedQuery.query()).getFilter();
+        Filter filter = ((XFilteredQuery) parsedQuery.query()).getFilter();
         assertThat(filter, instanceOf(NumericRangeFilter.class));
         NumericRangeFilter rangeFilter = (NumericRangeFilter) filter;
         assertThat(rangeFilter.getField(), equalTo("age"));
@@ -757,8 +757,8 @@ public class SimpleIndexQueryParserTests {
     public void testNumericRangeFilteredQueryBuilder() throws IOException {
         IndexQueryParserService queryParser = queryParser();
         Query parsedQuery = queryParser.parse(filteredQuery(termQuery("name.first", "shay"), numericRangeFilter("age").from(23).to(54).includeLower(true).includeUpper(false))).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        Filter filter = ((FilteredQuery) parsedQuery).getFilter();
+        Filter filter = ((XFilteredQuery) parsedQuery).getFilter();
         assertThat(filter, instanceOf(NumericRangeFieldDataFilter.class));
         NumericRangeFieldDataFilter<Number> rangeFilter = (NumericRangeFieldDataFilter<Number>) filter;
         assertThat(rangeFilter.getField(), equalTo("age"));
@@ -773,8 +773,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/numeric_range-filter.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        Filter filter = ((FilteredQuery) parsedQuery).getFilter();
+        Filter filter = ((XFilteredQuery) parsedQuery).getFilter();
         assertThat(filter, instanceOf(NumericRangeFieldDataFilter.class));
         NumericRangeFieldDataFilter<Number> rangeFilter = (NumericRangeFieldDataFilter<Number>) filter;
         assertThat(rangeFilter.getField(), equalTo("age"));
@@ -789,8 +789,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/bool-filter.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         XBooleanFilter booleanFilter = (XBooleanFilter) filteredQuery.getFilter();
 
         // TODO get the content and test
@@ -800,8 +800,8 @@ public class SimpleIndexQueryParserTests {
     public void testAndFilteredQueryBuilder() throws IOException {
         IndexQueryParserService queryParser = queryParser();
         Query parsedQuery = queryParser.parse(filteredQuery(matchAllQuery(), andFilter(termFilter("name.first", "shay1"), termFilter("name.first", "shay4")))).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
 
         AndFilter andFilter = (AndFilter) constantScoreQuery.getFilter();
         assertThat(andFilter.filters().size(), equalTo(2));
@@ -814,8 +814,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/and-filter.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
 
         AndFilter andFilter = (AndFilter) filteredQuery.getFilter();
         assertThat(andFilter.filters().size(), equalTo(2));
@@ -829,8 +829,8 @@ public class SimpleIndexQueryParserTests {
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/and-filter-named.json");
         ParsedQuery parsedQuery = queryParser.parse(query);
         assertThat(parsedQuery.namedFilters().containsKey("test"), equalTo(true));
-        assertThat(parsedQuery.query(), instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery.query(), instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery.query();
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery.query();
 
         AndFilter andFilter = (AndFilter) filteredQuery.getFilter();
         assertThat(andFilter.filters().size(), equalTo(2));
@@ -843,8 +843,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/and-filter2.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
 
         AndFilter andFilter = (AndFilter) filteredQuery.getFilter();
         assertThat(andFilter.filters().size(), equalTo(2));
@@ -856,8 +856,8 @@ public class SimpleIndexQueryParserTests {
     public void testOrFilteredQueryBuilder() throws IOException {
         IndexQueryParserService queryParser = queryParser();
         Query parsedQuery = queryParser.parse(filteredQuery(matchAllQuery(), orFilter(termFilter("name.first", "shay1"), termFilter("name.first", "shay4")))).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
 
         OrFilter andFilter = (OrFilter) constantScoreQuery.getFilter();
         assertThat(andFilter.filters().size(), equalTo(2));
@@ -870,8 +870,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/or-filter.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
 
         OrFilter orFilter = (OrFilter) filteredQuery.getFilter();
         assertThat(orFilter.filters().size(), equalTo(2));
@@ -884,8 +884,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/or-filter2.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
 
         OrFilter orFilter = (OrFilter) filteredQuery.getFilter();
         assertThat(orFilter.filters().size(), equalTo(2));
@@ -897,8 +897,8 @@ public class SimpleIndexQueryParserTests {
     public void testNotFilteredQueryBuilder() throws IOException {
         IndexQueryParserService queryParser = queryParser();
         Query parsedQuery = queryParser.parse(filteredQuery(matchAllQuery(), notFilter(termFilter("name.first", "shay1")))).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
 
         NotFilter notFilter = (NotFilter) constantScoreQuery.getFilter();
         assertThat(((TermFilter) notFilter.filter()).getTerm(), equalTo(new Term("name.first", "shay1")));
@@ -909,8 +909,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/not-filter.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         assertThat(((TermQuery) filteredQuery.getQuery()).getTerm(), equalTo(new Term("name.first", "shay")));
 
         NotFilter notFilter = (NotFilter) filteredQuery.getFilter();
@@ -922,8 +922,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/not-filter2.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         assertThat(((TermQuery) filteredQuery.getQuery()).getTerm(), equalTo(new Term("name.first", "shay")));
 
         NotFilter notFilter = (NotFilter) filteredQuery.getFilter();
@@ -935,8 +935,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/not-filter3.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         assertThat(((TermQuery) filteredQuery.getQuery()).getTerm(), equalTo(new Term("name.first", "shay")));
 
         NotFilter notFilter = (NotFilter) filteredQuery.getFilter();
@@ -1039,8 +1039,8 @@ public class SimpleIndexQueryParserTests {
     public void testFilteredQueryBuilder() throws IOException {
         IndexQueryParserService queryParser = queryParser();
         Query parsedQuery = queryParser.parse(filteredQuery(termQuery("name.first", "shay"), termFilter("name.last", "banon"))).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         assertThat(((TermQuery) filteredQuery.getQuery()).getTerm(), equalTo(new Term("name.first", "shay")));
         assertThat(((TermFilter) filteredQuery.getFilter()).getTerm(), equalTo(new Term("name.last", "banon")));
     }
@@ -1050,8 +1050,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/filtered-query.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         assertThat(((TermQuery) filteredQuery.getQuery()).getTerm(), equalTo(new Term("name.first", "shay")));
         assertThat(((TermFilter) filteredQuery.getFilter()).getTerm(), equalTo(new Term("name.last", "banon")));
     }
@@ -1061,8 +1061,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/filtered-query2.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         assertThat(((TermQuery) filteredQuery.getQuery()).getTerm(), equalTo(new Term("name.first", "shay")));
         assertThat(((TermFilter) filteredQuery.getFilter()).getTerm(), equalTo(new Term("name.last", "banon")));
     }
@@ -1072,8 +1072,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/filtered-query3.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         assertThat(((TermQuery) filteredQuery.getQuery()).getTerm(), equalTo(new Term("name.first", "shay")));
 
         Filter filter = filteredQuery.getFilter();
@@ -1089,8 +1089,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/filtered-query4.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         WildcardQuery wildcardQuery = (WildcardQuery) filteredQuery.getQuery();
         assertThat(wildcardQuery.getTerm(), equalTo(new Term("name.first", "sh*")));
         assertThat((double) wildcardQuery.getBoost(), closeTo(1.1, 0.001));
@@ -1103,8 +1103,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/limit-filter.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         assertThat(filteredQuery.getFilter(), instanceOf(LimitFilter.class));
         assertThat(((LimitFilter) filteredQuery.getFilter()).getLimit(), equalTo(2));
 
@@ -1117,8 +1117,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/term-filter.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         assertThat(filteredQuery.getFilter(), instanceOf(TermFilter.class));
         TermFilter termFilter = (TermFilter) filteredQuery.getFilter();
         assertThat(termFilter.getTerm().field(), equalTo("name.last"));
@@ -1131,8 +1131,8 @@ public class SimpleIndexQueryParserTests {
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/term-filter-named.json");
         ParsedQuery parsedQuery = queryParser.parse(query);
         assertThat(parsedQuery.namedFilters().containsKey("test"), equalTo(true));
-        assertThat(parsedQuery.query(), instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery.query(), instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery.query();
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery.query();
         assertThat(filteredQuery.getFilter(), instanceOf(TermFilter.class));
         TermFilter termFilter = (TermFilter) filteredQuery.getFilter();
         assertThat(termFilter.getTerm().field(), equalTo("name.last"));
@@ -1143,8 +1143,8 @@ public class SimpleIndexQueryParserTests {
     public void testTermsFilterQueryBuilder() throws Exception {
         IndexQueryParserService queryParser = queryParser();
         Query parsedQuery = queryParser.parse(filteredQuery(termQuery("name.first", "shay"), termsFilter("name.last", "banon", "kimchy"))).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         assertThat(filteredQuery.getFilter(), instanceOf(XTermsFilter.class));
         XTermsFilter termsFilter = (XTermsFilter) filteredQuery.getFilter();
         assertThat(termsFilter.getTerms().length, equalTo(2));
@@ -1157,8 +1157,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/terms-filter.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         assertThat(filteredQuery.getFilter(), instanceOf(XTermsFilter.class));
         XTermsFilter termsFilter = (XTermsFilter) filteredQuery.getFilter();
         assertThat(termsFilter.getTerms().length, equalTo(2));
@@ -1171,8 +1171,8 @@ public class SimpleIndexQueryParserTests {
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/terms-filter-named.json");
         ParsedQuery parsedQuery = queryParser.parse(query);
         assertThat(parsedQuery.namedFilters().containsKey("test"), equalTo(true));
-        assertThat(parsedQuery.query(), instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery.query(), instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery.query();
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery.query();
         assertThat(filteredQuery.getFilter(), instanceOf(XTermsFilter.class));
         XTermsFilter termsFilter = (XTermsFilter) filteredQuery.getFilter();
         assertThat(termsFilter.getTerms().length, equalTo(2));
@@ -1183,8 +1183,8 @@ public class SimpleIndexQueryParserTests {
     public void testConstantScoreQueryBuilder() throws IOException {
         IndexQueryParserService queryParser = queryParser();
         Query parsedQuery = queryParser.parse(constantScoreQuery(termFilter("name.last", "banon"))).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         assertThat(((TermFilter) constantScoreQuery.getFilter()).getTerm(), equalTo(new Term("name.last", "banon")));
     }
 
@@ -1193,8 +1193,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/constantScore-query.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         assertThat(((TermFilter) constantScoreQuery.getFilter()).getTerm(), equalTo(new Term("name.last", "banon")));
     }
 
@@ -1367,8 +1367,8 @@ public class SimpleIndexQueryParserTests {
     public void testQueryFilterBuilder() throws Exception {
         IndexQueryParserService queryParser = queryParser();
         Query parsedQuery = queryParser.parse(filteredQuery(termQuery("name.first", "shay"), queryFilter(termQuery("name.last", "banon")))).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         QueryWrapperFilter queryWrapperFilter = (QueryWrapperFilter) filteredQuery.getFilter();
         Field field = QueryWrapperFilter.class.getDeclaredField("query");
         field.setAccessible(true);
@@ -1382,8 +1382,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/query-filter.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery, instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery;
         QueryWrapperFilter queryWrapperFilter = (QueryWrapperFilter) filteredQuery.getFilter();
         Field field = QueryWrapperFilter.class.getDeclaredField("query");
         field.setAccessible(true);
@@ -1398,8 +1398,8 @@ public class SimpleIndexQueryParserTests {
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/fquery-filter.json");
         ParsedQuery parsedQuery = queryParser.parse(query);
         assertThat(parsedQuery.namedFilters().containsKey("test"), equalTo(true));
-        assertThat(parsedQuery.query(), instanceOf(FilteredQuery.class));
+        assertThat(parsedQuery.query(), instanceOf(XFilteredQuery.class));
-        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery.query();
+        XFilteredQuery filteredQuery = (XFilteredQuery) parsedQuery.query();
         QueryWrapperFilter queryWrapperFilter = (QueryWrapperFilter) filteredQuery.getFilter();
         Field field = QueryWrapperFilter.class.getDeclaredField("query");
         field.setAccessible(true);
@@ -1499,8 +1499,8 @@ public class SimpleIndexQueryParserTests {
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_distance-named.json");
         ParsedQuery parsedQuery = queryParser.parse(query);
         assertThat(parsedQuery.namedFilters().containsKey("test"), equalTo(true));
-        assertThat(parsedQuery.query(), instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery.query(), instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery.query();
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery.query();
         GeoDistanceFilter filter = (GeoDistanceFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.lat(), closeTo(40, 0.00001));
@@ -1513,8 +1513,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_distance1.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoDistanceFilter filter = (GeoDistanceFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.lat(), closeTo(40, 0.00001));
@@ -1527,8 +1527,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_distance2.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoDistanceFilter filter = (GeoDistanceFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.lat(), closeTo(40, 0.00001));
@@ -1541,8 +1541,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_distance3.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoDistanceFilter filter = (GeoDistanceFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.lat(), closeTo(40, 0.00001));
@@ -1555,8 +1555,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_distance4.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoDistanceFilter filter = (GeoDistanceFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.lat(), closeTo(40, 0.00001));
@@ -1569,8 +1569,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_distance5.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoDistanceFilter filter = (GeoDistanceFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.lat(), closeTo(40, 0.00001));
@@ -1583,8 +1583,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_distance6.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoDistanceFilter filter = (GeoDistanceFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.lat(), closeTo(40, 0.00001));
@@ -1597,8 +1597,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_distance7.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoDistanceFilter filter = (GeoDistanceFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.lat(), closeTo(40, 0.00001));
@@ -1611,8 +1611,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_distance8.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoDistanceFilter filter = (GeoDistanceFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.lat(), closeTo(40, 0.00001));
@@ -1625,8 +1625,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_distance9.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoDistanceFilter filter = (GeoDistanceFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.lat(), closeTo(40, 0.00001));
@@ -1639,8 +1639,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_distance10.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoDistanceFilter filter = (GeoDistanceFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.lat(), closeTo(40, 0.00001));
@@ -1653,8 +1653,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_distance11.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoDistanceFilter filter = (GeoDistanceFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.lat(), closeTo(40, 0.00001));
@@ -1667,8 +1667,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_distance12.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoDistanceFilter filter = (GeoDistanceFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.lat(), closeTo(40, 0.00001));
@@ -1681,9 +1681,9 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_boundingbox-named.json");
         ParsedQuery parsedQuery = queryParser.parse(query);
-        assertThat(parsedQuery.query(), instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery.query(), instanceOf(XConstantScoreQuery.class));
         assertThat(parsedQuery.namedFilters().containsKey("test"), equalTo(true));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery.query();
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery.query();
         InMemoryGeoBoundingBoxFilter filter = (InMemoryGeoBoundingBoxFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.topLeft().lat, closeTo(40, 0.00001));
@@ -1698,8 +1698,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_boundingbox1.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         InMemoryGeoBoundingBoxFilter filter = (InMemoryGeoBoundingBoxFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.topLeft().lat, closeTo(40, 0.00001));
@@ -1713,8 +1713,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_boundingbox2.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         InMemoryGeoBoundingBoxFilter filter = (InMemoryGeoBoundingBoxFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.topLeft().lat, closeTo(40, 0.00001));
@@ -1728,8 +1728,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_boundingbox3.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         InMemoryGeoBoundingBoxFilter filter = (InMemoryGeoBoundingBoxFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.topLeft().lat, closeTo(40, 0.00001));
@@ -1743,8 +1743,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_boundingbox4.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         InMemoryGeoBoundingBoxFilter filter = (InMemoryGeoBoundingBoxFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.topLeft().lat, closeTo(40, 0.00001));
@@ -1759,8 +1759,8 @@ public class SimpleIndexQueryParserTests {
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_polygon-named.json");
         ParsedQuery parsedQuery = queryParser.parse(query);
         assertThat(parsedQuery.namedFilters().containsKey("test"), equalTo(true));
-        assertThat(parsedQuery.query(), instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery.query(), instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery.query();
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery.query();
         GeoPolygonFilter filter = (GeoPolygonFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.points().length, equalTo(3));
@@ -1777,8 +1777,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_polygon1.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoPolygonFilter filter = (GeoPolygonFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.points().length, equalTo(3));
@@ -1795,8 +1795,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_polygon2.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoPolygonFilter filter = (GeoPolygonFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.points().length, equalTo(3));
@@ -1813,8 +1813,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_polygon3.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoPolygonFilter filter = (GeoPolygonFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.points().length, equalTo(3));
@@ -1831,8 +1831,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geo_polygon4.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         GeoPolygonFilter filter = (GeoPolygonFilter) constantScoreQuery.getFilter();
         assertThat(filter.fieldName(), equalTo("location"));
         assertThat(filter.points().length, equalTo(3));
@@ -1849,8 +1849,8 @@ public class SimpleIndexQueryParserTests {
         IndexQueryParserService queryParser = queryParser();
         String query = copyToStringFromClasspath("/org/elasticsearch/test/unit/index/query/geoShape-filter.json");
         Query parsedQuery = queryParser.parse(query).query();
-        assertThat(parsedQuery, instanceOf(DeletionAwareConstantScoreQuery.class));
+        assertThat(parsedQuery, instanceOf(XConstantScoreQuery.class));
-        DeletionAwareConstantScoreQuery constantScoreQuery = (DeletionAwareConstantScoreQuery) parsedQuery;
+        XConstantScoreQuery constantScoreQuery = (XConstantScoreQuery) parsedQuery;
         XTermsFilter filter = (XTermsFilter) constantScoreQuery.getFilter();
         Term exampleTerm = filter.getTerms()[0];
         assertThat(exampleTerm.field(), equalTo("country"));