X-Git-Url: https://git.mdrn.pl/pylucene.git/blobdiff_plain/a2e61f0c04805cfcb8706176758d1283c7e3a55c..aaeed5504b982cf3545252ab528713250aa33eed:/lucene-java-3.4.0/lucene/src/java/org/apache/lucene/search/ConstantScoreQuery.java diff --git a/lucene-java-3.4.0/lucene/src/java/org/apache/lucene/search/ConstantScoreQuery.java b/lucene-java-3.4.0/lucene/src/java/org/apache/lucene/search/ConstantScoreQuery.java deleted file mode 100644 index bcb372e..0000000 --- a/lucene-java-3.4.0/lucene/src/java/org/apache/lucene/search/ConstantScoreQuery.java +++ /dev/null @@ -1,292 +0,0 @@ -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.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 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. - * - *

NOTE: if the wrapped filter is an instance of - * {@link CachingWrapperFilter}, you'll likely want to - * enforce deletions in the filter (using either {@link - * CachingWrapperFilter.DeletesMode#RECACHE} or {@link - * CachingWrapperFilter.DeletesMode#DYNAMIC}). - */ -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) { - if (filter == null) - throw new NullPointerException("Filter may not be null"); - this.filter = filter; - this.query = null; - } - - /** 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 terms) { - // 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 final Weight innerWeight; - private final Similarity similarity; - private float queryNorm; - private float queryWeight; - - public ConstantWeight(Searcher searcher) throws IOException { - this.similarity = getSimilarity(searcher); - this.innerWeight = (query == null) ? null : query.createWeight(searcher); - } - - @Override - public Query getQuery() { - return ConstantScoreQuery.this; - } - - @Override - public float getValue() { - return queryWeight; - } - - @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; - } - - @Override - 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 { - 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 { - 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.this.toString() + ", product of:"); - result.setValue(queryWeight); - result.setMatch(Boolean.TRUE); - result.addDetail(new Explanation(getBoost(), "boost")); - result.addDetail(new Explanation(queryNorm, "queryNorm")); - } else { - result.setDescription(ConstantScoreQuery.this.toString() + " doesn't match id " + doc); - result.setValue(0); - result.setMatch(Boolean.FALSE); - } - return result; - } - } - - protected class ConstantScorer extends Scorer { - final DocIdSetIterator docIdSetIterator; - final float theScore; - - public ConstantScorer(Similarity similarity, DocIdSetIterator docIdSetIterator, Weight w) throws IOException { - super(similarity,w); - theScore = w.getValue(); - this.docIdSetIterator = docIdSetIterator; - } - - @Override - public int nextDoc() throws IOException { - return docIdSetIterator.nextDoc(); - } - - @Override - public int docID() { - return docIdSetIterator.docID(); - } - - @Override - public float score() throws IOException { - return theScore; - } - - @Override - 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) throws IOException { - return new ConstantScoreQuery.ConstantWeight(searcher); - } - - @Override - public String toString(String field) { - return new StringBuilder("ConstantScore(") - .append((query == null) ? filter.toString() : query.toString(field)) - .append(')') - .append(ToStringUtils.boost(getBoost())) - .toString(); - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - 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; - } - - @Override - public int hashCode() { - return 31 * super.hashCode() + - ((query == null) ? filter : query).hashCode(); - } - -}