You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by us...@apache.org on 2011/01/02 14:48:00 UTC
svn commit: r1054406 - in /lucene/dev/trunk/lucene: ./
contrib/remote/src/test/org/apache/lucene/search/
src/java/org/apache/lucene/search/ src/test/org/apache/lucene/search/
Author: uschindler
Date: Sun Jan 2 13:47:59 2011
New Revision: 1054406
URL: http://svn.apache.org/viewvc?rev=1054406&view=rev
Log:
LUCENE-2838: ConstantScoreQuery now directly supports wrapping a Query instance for stripping off scores
Added:
lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestConstantScoreQuery.java (with props)
Removed:
lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestBooleanPrefixQuery.java
Modified:
lucene/dev/trunk/lucene/CHANGES.txt
lucene/dev/trunk/lucene/contrib/remote/src/test/org/apache/lucene/search/TestRemoteSearchable.java
lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ConstantScoreAutoRewrite.java
lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ConstantScoreQuery.java
lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/MultiTermQuery.java
lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ScoringRewrite.java
lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
Modified: lucene/dev/trunk/lucene/CHANGES.txt
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/CHANGES.txt?rev=1054406&r1=1054405&r2=1054406&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/CHANGES.txt (original)
+++ lucene/dev/trunk/lucene/CHANGES.txt Sun Jan 2 13:47:59 2011
@@ -678,6 +678,12 @@ New features
Using this wrapper its easy to add fuzzy/wildcard to e.g. a SpanNearQuery.
(Robert Muir, Uwe Schindler)
+* LUCENE-2838: ConstantScoreQuery now directly supports wrapping a Query
+ instance for stripping off scores. The use of a QueryWrapperFilter
+ is no longer needed and discouraged for that use case. Directly wrapping
+ Query improves performance, as out-of-order collection is now supported.
+ (Uwe Schindler)
+
Optimizations
* LUCENE-2075: Terms dict cache is now shared across threads instead
Modified: lucene/dev/trunk/lucene/contrib/remote/src/test/org/apache/lucene/search/TestRemoteSearchable.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/contrib/remote/src/test/org/apache/lucene/search/TestRemoteSearchable.java?rev=1054406&r1=1054405&r2=1054406&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/contrib/remote/src/test/org/apache/lucene/search/TestRemoteSearchable.java (original)
+++ lucene/dev/trunk/lucene/contrib/remote/src/test/org/apache/lucene/search/TestRemoteSearchable.java Sun Jan 2 13:47:59 2011
@@ -122,8 +122,7 @@ public class TestRemoteSearchable extend
Searchable[] searchables = { lookupRemote() };
Searcher searcher = new MultiSearcher(searchables);
ScoreDoc[] hits = searcher.search(
- new ConstantScoreQuery(new QueryWrapperFilter(
- new TermQuery(new Term("test", "test")))), null, 1000).scoreDocs;
+ new ConstantScoreQuery(new TermQuery(new Term("test", "test"))), null, 1000).scoreDocs;
assertEquals(1, hits.length);
}
}
Modified: lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ConstantScoreAutoRewrite.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ConstantScoreAutoRewrite.java?rev=1054406&r1=1054405&r2=1054406&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ConstantScoreAutoRewrite.java (original)
+++ lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ConstantScoreAutoRewrite.java Sun Jan 2 13:47:59 2011
@@ -103,7 +103,7 @@ class ConstantScoreAutoRewrite extends T
addClause(bq, placeholderTerm.createTerm(pendingTerms.get(sort[i], new BytesRef())), 1, 1.0f);
}
// Strip scores
- final Query result = new ConstantScoreQuery(new QueryWrapperFilter(bq));
+ final Query result = new ConstantScoreQuery(bq);
result.setBoost(query.getBoost());
query.incTotalNumberOfTerms(size);
return result;
Modified: lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ConstantScoreQuery.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ConstantScoreQuery.java?rev=1054406&r1=1054405&r2=1054406&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ConstantScoreQuery.java (original)
+++ lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ConstantScoreQuery.java Sun Jan 2 13:47:59 2011
@@ -19,13 +19,15 @@ package org.apache.lucene.search;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
+import org.apache.lucene.util.ToStringUtils;
import java.io.IOException;
import java.util.Set;
/**
- * A query that wraps a filter and simply returns a constant score equal to the
- * query boost for every document in the filter.
+ * A query that wraps another query or a filter and simply returns a constant score equal to the
+ * query boost for every document that matches the filter or query.
+ * For queries it therefore simply strips of all scores and returns a constant one.
*
* <p><b>NOTE</b>: if the wrapped filter is an instance of
* {@link CachingWrapperFilter}, you'll likely want to
@@ -35,34 +37,72 @@ import java.util.Set;
*/
public class ConstantScoreQuery extends Query {
protected final Filter filter;
+ protected final Query query;
+ /** Strips off scores from the passed in Query. The hits will get a constant score
+ * dependent on the boost factor of this query. */
+ public ConstantScoreQuery(Query query) {
+ if (query == null)
+ throw new NullPointerException("Query may not be null");
+ this.filter = null;
+ this.query = query;
+ }
+
+ /** Wraps a Filter as a Query. The hits will get a constant score
+ * dependent on the boost factor of this query.
+ * If you simply want to strip off scores from a Query, no longer use
+ * {@code new ConstantScoreQuery(new QueryWrapperFilter(query))}, instead
+ * use {@link #ConstantScoreQuery(Query)}!
+ */
public ConstantScoreQuery(Filter filter) {
- this.filter=filter;
+ if (filter == null)
+ throw new NullPointerException("Filter may not be null");
+ this.filter = filter;
+ this.query = null;
}
- /** Returns the encapsulated filter */
+ /** Returns the encapsulated filter, returns {@code null} if a query is wrapped. */
public Filter getFilter() {
return filter;
}
+ /** Returns the encapsulated query, returns {@code null} if a filter is wrapped. */
+ public Query getQuery() {
+ return query;
+ }
+
@Override
public Query rewrite(IndexReader reader) throws IOException {
+ if (query != null) {
+ Query rewritten = query.rewrite(reader);
+ if (rewritten != query) {
+ rewritten = new ConstantScoreQuery(rewritten);
+ rewritten.setBoost(this.getBoost());
+ return rewritten;
+ }
+ }
return this;
}
@Override
public void extractTerms(Set<Term> terms) {
- // OK to not add any terms when used for MultiSearcher,
- // but may not be OK for highlighting
+ // TODO: OK to not add any terms when wrapped a filter
+ // and used with MultiSearcher, but may not be OK for
+ // highlighting.
+ // If a query was wrapped, we delegate to query.
+ if (query != null)
+ query.extractTerms(terms);
}
protected class ConstantWeight extends Weight {
- private Similarity similarity;
+ private final Weight innerWeight;
+ private final Similarity similarity;
private float queryNorm;
private float queryWeight;
- public ConstantWeight(Searcher searcher) {
+ public ConstantWeight(Searcher searcher) throws IOException {
this.similarity = getSimilarity(searcher);
+ this.innerWeight = (query == null) ? null : query.createWeight(searcher);
}
@Override
@@ -77,6 +117,8 @@ public class ConstantScoreQuery extends
@Override
public float sumOfSquaredWeights() throws IOException {
+ // we calculate sumOfSquaredWeights of the inner weight, but ignore it (just to initialize everything)
+ if (innerWeight != null) innerWeight.sumOfSquaredWeights();
queryWeight = getBoost();
return queryWeight * queryWeight;
}
@@ -85,31 +127,48 @@ public class ConstantScoreQuery extends
public void normalize(float norm) {
this.queryNorm = norm;
queryWeight *= this.queryNorm;
+ // we normalize the inner weight, but ignore it (just to initialize everything)
+ if (innerWeight != null) innerWeight.normalize(norm);
}
@Override
public Scorer scorer(IndexReader reader, boolean scoreDocsInOrder, boolean topScorer) throws IOException {
- return new ConstantScorer(similarity, reader, this);
+ final DocIdSetIterator disi;
+ if (filter != null) {
+ assert query == null;
+ final DocIdSet dis = filter.getDocIdSet(reader);
+ if (dis == null)
+ return null;
+ disi = dis.iterator();
+ } else {
+ assert query != null && innerWeight != null;
+ disi =
+ innerWeight.scorer(reader, scoreDocsInOrder, topScorer);
+ }
+ if (disi == null)
+ return null;
+ return new ConstantScorer(similarity, disi, this);
+ }
+
+ @Override
+ public boolean scoresDocsOutOfOrder() {
+ return (innerWeight != null) ? innerWeight.scoresDocsOutOfOrder() : false;
}
@Override
public Explanation explain(IndexReader reader, int doc) throws IOException {
-
- ConstantScorer cs = new ConstantScorer(similarity, reader, this);
- boolean exists = cs.docIdSetIterator.advance(doc) == doc;
-
- ComplexExplanation result = new ComplexExplanation();
+ final Scorer cs = scorer(reader, true, false);
+ final boolean exists = (cs != null && cs.advance(doc) == doc);
+ final ComplexExplanation result = new ComplexExplanation();
if (exists) {
- result.setDescription("ConstantScoreQuery(" + filter
- + "), product of:");
+ result.setDescription(ConstantScoreQuery.this.toString() + ", product of:");
result.setValue(queryWeight);
result.setMatch(Boolean.TRUE);
result.addDetail(new Explanation(getBoost(), "boost"));
- result.addDetail(new Explanation(queryNorm,"queryNorm"));
+ result.addDetail(new Explanation(queryNorm, "queryNorm"));
} else {
- result.setDescription("ConstantScoreQuery(" + filter
- + ") doesn't match id " + doc);
+ result.setDescription(ConstantScoreQuery.this.toString() + " doesn't match id " + doc);
result.setValue(0);
result.setMatch(Boolean.FALSE);
}
@@ -120,22 +179,11 @@ public class ConstantScoreQuery extends
protected class ConstantScorer extends Scorer {
final DocIdSetIterator docIdSetIterator;
final float theScore;
- int doc = -1;
- public ConstantScorer(Similarity similarity, IndexReader reader, Weight w) throws IOException {
+ public ConstantScorer(Similarity similarity, DocIdSetIterator docIdSetIterator, Weight w) throws IOException {
super(similarity,w);
theScore = w.getValue();
- DocIdSet docIdSet = filter.getDocIdSet(reader);
- if (docIdSet == null) {
- docIdSetIterator = DocIdSet.EMPTY_DOCIDSET.iterator();
- } else {
- DocIdSetIterator iter = docIdSet.iterator();
- if (iter == null) {
- docIdSetIterator = DocIdSet.EMPTY_DOCIDSET.iterator();
- } else {
- docIdSetIterator = iter;
- }
- }
+ this.docIdSetIterator = docIdSetIterator;
}
@Override
@@ -157,34 +205,88 @@ public class ConstantScoreQuery extends
public int advance(int target) throws IOException {
return docIdSetIterator.advance(target);
}
+
+ private Collector wrapCollector(final Collector collector) {
+ return new Collector() {
+ @Override
+ public void setScorer(Scorer scorer) throws IOException {
+ // we must wrap again here, but using the scorer passed in as parameter:
+ collector.setScorer(new ConstantScorer(ConstantScorer.this.getSimilarity(),
+ scorer, ConstantScorer.this.weight));
+ }
+
+ @Override
+ public void collect(int doc) throws IOException {
+ collector.collect(doc);
+ }
+
+ @Override
+ public void setNextReader(IndexReader reader, int docBase) throws IOException {
+ collector.setNextReader(reader, docBase);
+ }
+
+ @Override
+ public boolean acceptsDocsOutOfOrder() {
+ return collector.acceptsDocsOutOfOrder();
+ }
+ };
+ }
+
+ // this optimization allows out of order scoring as top scorer!
+ @Override
+ public void score(Collector collector) throws IOException {
+ if (docIdSetIterator instanceof Scorer) {
+ ((Scorer) docIdSetIterator).score(wrapCollector(collector));
+ } else {
+ super.score(collector);
+ }
+ }
+
+ // this optimization allows out of order scoring as top scorer,
+ // TODO: theoretically this method should not be called because its protected and
+ // this class does not use it, it should be public in Scorer!
+ @Override
+ protected boolean score(Collector collector, int max, int firstDocID) throws IOException {
+ if (docIdSetIterator instanceof Scorer) {
+ return ((Scorer) docIdSetIterator).score(wrapCollector(collector), max, firstDocID);
+ } else {
+ return super.score(collector, max, firstDocID);
+ }
+ }
}
@Override
- public Weight createWeight(Searcher searcher) {
+ public Weight createWeight(Searcher searcher) throws IOException {
return new ConstantScoreQuery.ConstantWeight(searcher);
}
- /** Prints a user-readable version of this query. */
@Override
public String toString(String field) {
- return "ConstantScore(" + filter.toString() + ")"
- + (getBoost()==1.0 ? "" : "^" + getBoost());
+ return new StringBuilder("ConstantScore(")
+ .append((query == null) ? filter.toString() : query.toString(field))
+ .append(')')
+ .append(ToStringUtils.boost(getBoost()))
+ .toString();
}
- /** Returns true if <code>o</code> is equal to this. */
@Override
public boolean equals(Object o) {
if (this == o) return true;
- if (!(o instanceof ConstantScoreQuery)) return false;
- ConstantScoreQuery other = (ConstantScoreQuery)o;
- return this.getBoost()==other.getBoost() && filter.equals(other.filter);
+ if (!super.equals(o))
+ return false;
+ if (o instanceof ConstantScoreQuery) {
+ final ConstantScoreQuery other = (ConstantScoreQuery) o;
+ return
+ ((this.filter == null) ? other.filter == null : this.filter.equals(other.filter)) &&
+ ((this.query == null) ? other.query == null : this.query.equals(other.query));
+ }
+ return false;
}
- /** Returns a hash code value for this object. */
@Override
public int hashCode() {
- // Simple add is OK since no existing filter hashcode has a float component.
- return filter.hashCode() + Float.floatToIntBits(getBoost());
+ return 31 * super.hashCode() +
+ ((query == null) ? filter : query).hashCode();
}
}
Modified: lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/MultiTermQuery.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/MultiTermQuery.java?rev=1054406&r1=1054405&r2=1054406&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/MultiTermQuery.java (original)
+++ lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/MultiTermQuery.java Sun Jan 2 13:47:59 2011
@@ -201,7 +201,7 @@ public abstract class MultiTermQuery ext
@Override
protected void addClause(BooleanQuery topLevel, Term term, int docFreq, float boost) {
- final Query q = new ConstantScoreQuery(new QueryWrapperFilter(new TermQuery(term, docFreq)));
+ final Query q = new ConstantScoreQuery(new TermQuery(term, docFreq));
q.setBoost(boost);
topLevel.add(q, BooleanClause.Occur.SHOULD);
}
Modified: lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ScoringRewrite.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ScoringRewrite.java?rev=1054406&r1=1054405&r2=1054406&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ScoringRewrite.java (original)
+++ lucene/dev/trunk/lucene/src/java/org/apache/lucene/search/ScoringRewrite.java Sun Jan 2 13:47:59 2011
@@ -89,7 +89,7 @@ public abstract class ScoringRewrite<Q e
if (bq.clauses().isEmpty())
return bq;
// strip the scores off
- final Query result = new ConstantScoreQuery(new QueryWrapperFilter(bq));
+ final Query result = new ConstantScoreQuery(bq);
result.setBoost(query.getBoost());
return result;
}
Added: lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestConstantScoreQuery.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestConstantScoreQuery.java?rev=1054406&view=auto
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestConstantScoreQuery.java (added)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestConstantScoreQuery.java Sun Jan 2 13:47:59 2011
@@ -0,0 +1,132 @@
+package org.apache.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.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.RandomIndexWriter;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.LuceneTestCase;
+
+import java.io.IOException;
+
+/** This class only tests some basic functionality in CSQ, the main parts are mostly
+ * tested by MultiTermQuery tests, explanations seems to be tested in TestExplanations! */
+public class TestConstantScoreQuery extends LuceneTestCase {
+
+ public void testCSQ() throws Exception {
+ final Query q1 = new ConstantScoreQuery(new TermQuery(new Term("a", "b")));
+ final Query q2 = new ConstantScoreQuery(new TermQuery(new Term("a", "c")));
+ final Query q3 = new ConstantScoreQuery(new TermRangeFilter("a", "b", "c", true, true));
+ QueryUtils.check(q1);
+ QueryUtils.check(q2);
+ QueryUtils.checkEqual(q1,q1);
+ QueryUtils.checkEqual(q2,q2);
+ QueryUtils.checkEqual(q3,q3);
+ QueryUtils.checkUnequal(q1,q2);
+ QueryUtils.checkUnequal(q2,q3);
+ QueryUtils.checkUnequal(q1,q3);
+ QueryUtils.checkUnequal(q1, new TermQuery(new Term("a", "b")));
+ }
+
+ private void checkHits(Searcher searcher, Query q, final float expectedScore, final String scorerClassName, final String innerScorerClassName) throws IOException {
+ final int[] count = new int[1];
+ searcher.search(q, new Collector() {
+ private Scorer scorer;
+
+ @Override
+ public void setScorer(Scorer scorer) {
+ this.scorer = scorer;
+ assertEquals("Scorer is implemented by wrong class", scorerClassName, scorer.getClass().getName());
+ if (innerScorerClassName != null && scorer instanceof ConstantScoreQuery.ConstantScorer) {
+ final ConstantScoreQuery.ConstantScorer innerScorer = (ConstantScoreQuery.ConstantScorer) scorer;
+ assertEquals("inner Scorer is implemented by wrong class", innerScorerClassName, innerScorer.docIdSetIterator.getClass().getName());
+ }
+ }
+
+ @Override
+ public void collect(int doc) throws IOException {
+ assertEquals("Score differs from expected", expectedScore, this.scorer.score());
+ count[0]++;
+ }
+
+ @Override
+ public void setNextReader(IndexReader reader, int docBase) {
+ }
+
+ @Override
+ public boolean acceptsDocsOutOfOrder() {
+ return true;
+ }
+ });
+ assertEquals("invalid number of results", 1, count[0]);
+ }
+
+ public void testWrapped2Times() throws Exception {
+ Directory directory = null;
+ IndexReader reader = null;
+ IndexSearcher searcher = null;
+ try {
+ directory = newDirectory();
+ RandomIndexWriter writer = new RandomIndexWriter (random, directory);
+
+ Document doc = new Document();
+ doc.add(newField("field", "term", Field.Store.NO, Field.Index.NOT_ANALYZED));
+ writer.addDocument(doc);
+
+ reader = writer.getReader();
+ writer.close();
+ searcher = new IndexSearcher(reader);
+
+ // set a similarity that does not normalize our boost away
+ searcher.setSimilarity(new DefaultSimilarity() {
+ @Override
+ public float queryNorm(float sumOfSquaredWeights) {
+ return 1.0f;
+ }
+ });
+
+ final Query csq1 = new ConstantScoreQuery(new TermQuery(new Term ("field", "term")));
+ csq1.setBoost(2.0f);
+ final Query csq2 = new ConstantScoreQuery(csq1);
+ csq2.setBoost(5.0f);
+
+ final BooleanQuery bq = new BooleanQuery();
+ bq.add(csq1, BooleanClause.Occur.SHOULD);
+ bq.add(csq2, BooleanClause.Occur.SHOULD);
+
+ final Query csqbq = new ConstantScoreQuery(bq);
+ csqbq.setBoost(17.0f);
+
+ checkHits(searcher, csq1, csq1.getBoost(), ConstantScoreQuery.ConstantScorer.class.getName(), null);
+ checkHits(searcher, csq2, csq2.getBoost(), ConstantScoreQuery.ConstantScorer.class.getName(), ConstantScoreQuery.ConstantScorer.class.getName());
+
+ // for the combined BQ, the scorer should always be BooleanScorer's BucketScorer, because our scorer supports out-of order collection!
+ final String bucketScorerClass = BooleanScorer.class.getName() + "$BucketScorer";
+ checkHits(searcher, bq, csq1.getBoost() + csq2.getBoost(), bucketScorerClass, null);
+ checkHits(searcher, csqbq, csqbq.getBoost(), ConstantScoreQuery.ConstantScorer.class.getName(), bucketScorerClass);
+ } finally {
+ if (searcher != null) searcher.close();
+ if (reader != null) reader.close();
+ if (directory != null) directory.close();
+ }
+ }
+
+}
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java?rev=1054406&r1=1054405&r2=1054406&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java Sun Jan 2 13:47:59 2011
@@ -87,8 +87,8 @@ public class TestMultiTermQueryRewrites
private Query extractInnerQuery(Query q) {
if (q instanceof ConstantScoreQuery) {
- // wrapped as ConstantScoreQuery using QueryWrapperFilter
- q = ((QueryWrapperFilter) ((ConstantScoreQuery) q).getFilter()).getQuery();
+ // wrapped as ConstantScoreQuery
+ q = ((ConstantScoreQuery) q).getQuery();
}
return q;
}