From 4f2a9e7aa3385d2283f2109d5e38adae720c5fc3 Mon Sep 17 00:00:00 2001 From: Robert Muir Date: Thu, 20 Jan 2011 20:36:44 +0000 Subject: [PATCH] LUCENE-2876: Remove Scorer.getSimilarity git-svn-id: https://svn.apache.org/repos/asf/lucene/dev/trunk@1061499 13f79535-47bb-0310-9956-ffa450edef68 --- lucene/CHANGES.txt | 5 +++++ .../apache/lucene/search/BooleanScorer.java | 6 ++--- .../apache/lucene/search/BooleanScorer2.java | 19 +++++++++------- .../lucene/search/ConjunctionScorer.java | 8 +++---- .../lucene/search/ConstantScoreQuery.java | 11 ++++------ .../lucene/search/DisjunctionMaxQuery.java | 21 ++++++++---------- .../lucene/search/DisjunctionMaxScorer.java | 12 +++++----- .../lucene/search/DisjunctionSumScorer.java | 9 ++++---- .../lucene/search/ExactPhraseScorer.java | 11 ++++++---- .../apache/lucene/search/FilteredQuery.java | 3 +-- .../lucene/search/MatchAllDocsQuery.java | 6 +++-- .../apache/lucene/search/PhraseScorer.java | 9 +++++--- .../apache/lucene/search/ReqExclScorer.java | 2 +- .../apache/lucene/search/ReqOptSumScorer.java | 2 +- .../search/ScoreCachingWrappingScorer.java | 7 +----- .../java/org/apache/lucene/search/Scorer.java | 21 +++--------------- .../lucene/search/SloppyPhraseScorer.java | 2 +- .../org/apache/lucene/search/TermScorer.java | 13 ++++++----- .../search/function/CustomScoreQuery.java | 9 +++----- .../search/function/ValueSourceQuery.java | 8 +++---- .../search/payloads/PayloadNearQuery.java | 3 +-- .../search/payloads/PayloadTermQuery.java | 5 ++--- .../search/spans/FieldMaskingSpanQuery.java | 1 - .../lucene/search/spans/SpanScorer.java | 14 +++++++----- .../lucene/search/JustCompileSearch.java | 4 ++-- .../lucene/search/TestBooleanScorer.java | 7 +++--- .../TestPositiveScoresOnlyCollector.java | 20 ++++++++++++++--- .../TestScoreCachingWrappingScorer.java | 22 ++++++++++++++----- .../org/apache/solr/schema/LatLonType.java | 6 ++--- .../solr/search/SolrConstantScoreQuery.java | 8 +++---- .../solr/search/function/BoostedQuery.java | 6 ++--- .../solr/search/function/FunctionQuery.java | 6 ++--- 32 files changed, 147 insertions(+), 139 deletions(-) diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt index d54d2ae0a02..20c5b3beee7 100644 --- a/lucene/CHANGES.txt +++ b/lucene/CHANGES.txt @@ -613,6 +613,11 @@ API Changes for AttributeImpls, but can still be provided (if needed). (Uwe Schindler) +* LUCENE-2876: Deprecated Scorer.getSimilarity(). If your Scorer uses a Similarity, + it should keep it itself. Fixed Scorers to pass their parent Weight, so that + Scorer.visitSubScorers (LUCENE-2590) will work correctly. + (Robert Muir, Doron Cohen) + Bug fixes * LUCENE-2249: ParallelMultiSearcher should shut down thread pool on diff --git a/lucene/src/java/org/apache/lucene/search/BooleanScorer.java b/lucene/src/java/org/apache/lucene/search/BooleanScorer.java index 6faa7cc8e53..18978c36006 100644 --- a/lucene/src/java/org/apache/lucene/search/BooleanScorer.java +++ b/lucene/src/java/org/apache/lucene/search/BooleanScorer.java @@ -119,7 +119,7 @@ final class BooleanScorer extends Scorer { int doc = NO_MORE_DOCS; int freq; - public BucketScorer() { super(null); } + public BucketScorer(Weight weight) { super(weight); } @Override public int advance(int target) throws IOException { return NO_MORE_DOCS; } @@ -200,7 +200,7 @@ final class BooleanScorer extends Scorer { BooleanScorer(BooleanWeight weight, boolean disableCoord, int minNrShouldMatch, List optionalScorers, List prohibitedScorers, int maxCoord) throws IOException { - super(null, weight); // Similarity not used + super(weight); this.minNrShouldMatch = minNrShouldMatch; if (optionalScorers != null && optionalScorers.size() > 0) { @@ -233,7 +233,7 @@ final class BooleanScorer extends Scorer { public boolean score(Collector collector, int max, int firstDocID) throws IOException { boolean more; Bucket tmp; - BucketScorer bs = new BucketScorer(); + BucketScorer bs = new BucketScorer(weight); // The internal loop will set the score and doc before calling collect. collector.setScorer(bs); do { diff --git a/lucene/src/java/org/apache/lucene/search/BooleanScorer2.java b/lucene/src/java/org/apache/lucene/search/BooleanScorer2.java index c459dae1ade..9c8ac60cbf7 100644 --- a/lucene/src/java/org/apache/lucene/search/BooleanScorer2.java +++ b/lucene/src/java/org/apache/lucene/search/BooleanScorer2.java @@ -68,8 +68,11 @@ class BooleanScorer2 extends Scorer { * prohibited and optional scorers. In no required scorers are added, at least * one of the optional scorers will have to match during the search. * - * @param similarity - * The similarity to be used. + * @param weight + * The BooleanWeight to be used. + * @param disableCoord + * If this parameter is true, coordination level matching + * ({@link Similarity#coord(int, int)}) is not used. * @param minNrShouldMatch * The minimum number of optional added scorers that should match * during the search. In case no required scorers are added, at least @@ -83,7 +86,7 @@ class BooleanScorer2 extends Scorer { */ public BooleanScorer2(BooleanWeight weight, boolean disableCoord, int minNrShouldMatch, List required, List prohibited, List optional, int maxCoord) throws IOException { - super(null, weight); // Similarity not used + super(weight); if (minNrShouldMatch < 0) { throw new IllegalArgumentException("Minimum number of optional scorers should not be negative"); } @@ -108,7 +111,7 @@ class BooleanScorer2 extends Scorer { private float lastDocScore = Float.NaN; SingleMatchScorer(Scorer scorer) { - super(null); // No similarity used. + super(scorer.weight); this.scorer = scorer; } @@ -144,7 +147,7 @@ class BooleanScorer2 extends Scorer { private Scorer countingDisjunctionSumScorer(final List scorers, int minNrShouldMatch) throws IOException { // each scorer from the list counted as a single matcher - return new DisjunctionSumScorer(scorers, minNrShouldMatch) { + return new DisjunctionSumScorer(weight, scorers, minNrShouldMatch) { private int lastScoredDoc = -1; // Save the score of lastScoredDoc, so that we don't compute it more than // once in score(). @@ -167,7 +170,7 @@ class BooleanScorer2 extends Scorer { List requiredScorers) throws IOException { // each scorer from the list counted as a single matcher final int requiredNrMatchers = requiredScorers.size(); - return new ConjunctionScorer(disableCoord ? 1.0f : ((BooleanWeight)weight).coord(requiredScorers.size(), requiredScorers.size()), requiredScorers) { + return new ConjunctionScorer(weight, disableCoord ? 1.0f : ((BooleanWeight)weight).coord(requiredScorers.size(), requiredScorers.size()), requiredScorers) { private int lastScoredDoc = -1; // Save the score of lastScoredDoc, so that we don't compute it more than // once in score(). @@ -192,7 +195,7 @@ class BooleanScorer2 extends Scorer { private Scorer dualConjunctionSumScorer(boolean disableCoord, Scorer req1, Scorer req2) throws IOException { // non counting. - return new ConjunctionScorer(disableCoord ? 1.0f : ((BooleanWeight)weight).coord(2, 2), req1, req2); + return new ConjunctionScorer(weight, disableCoord ? 1.0f : ((BooleanWeight)weight).coord(2, 2), req1, req2); // All scorers match, so defaultSimilarity always has 1 as // the coordination factor. // Therefore the sum of the scores of two scorers @@ -262,7 +265,7 @@ class BooleanScorer2 extends Scorer { : new ReqExclScorer(requiredCountingSumScorer, ((prohibitedScorers.size() == 1) ? prohibitedScorers.get(0) - : new DisjunctionSumScorer(prohibitedScorers))); + : new DisjunctionSumScorer(weight, prohibitedScorers))); } /** Scores and collects all matching documents. diff --git a/lucene/src/java/org/apache/lucene/search/ConjunctionScorer.java b/lucene/src/java/org/apache/lucene/search/ConjunctionScorer.java index 3429e3711c5..b8dea2565b9 100644 --- a/lucene/src/java/org/apache/lucene/search/ConjunctionScorer.java +++ b/lucene/src/java/org/apache/lucene/search/ConjunctionScorer.java @@ -29,12 +29,12 @@ class ConjunctionScorer extends Scorer { private final float coord; private int lastDoc = -1; - public ConjunctionScorer(float coord, Collection scorers) throws IOException { - this(coord, scorers.toArray(new Scorer[scorers.size()])); + public ConjunctionScorer(Weight weight, float coord, Collection scorers) throws IOException { + this(weight, coord, scorers.toArray(new Scorer[scorers.size()])); } - public ConjunctionScorer(float coord, Scorer... scorers) throws IOException { - super(null); + public ConjunctionScorer(Weight weight, float coord, Scorer... scorers) throws IOException { + super(weight); this.scorers = scorers; this.coord = coord; diff --git a/lucene/src/java/org/apache/lucene/search/ConstantScoreQuery.java b/lucene/src/java/org/apache/lucene/search/ConstantScoreQuery.java index 5aa78b4f1a4..d5f5f50389b 100644 --- a/lucene/src/java/org/apache/lucene/search/ConstantScoreQuery.java +++ b/lucene/src/java/org/apache/lucene/search/ConstantScoreQuery.java @@ -97,12 +97,10 @@ public class ConstantScoreQuery extends Query { protected class ConstantWeight extends Weight { private final Weight innerWeight; - private final Similarity similarity; private float queryNorm; private float queryWeight; public ConstantWeight(IndexSearcher searcher) throws IOException { - this.similarity = searcher.getSimilarity(); this.innerWeight = (query == null) ? null : query.createWeight(searcher); } @@ -148,7 +146,7 @@ public class ConstantScoreQuery extends Query { } if (disi == null) return null; - return new ConstantScorer(similarity, disi, this); + return new ConstantScorer(disi, this); } @Override @@ -181,8 +179,8 @@ public class ConstantScoreQuery extends Query { final DocIdSetIterator docIdSetIterator; final float theScore; - public ConstantScorer(Similarity similarity, DocIdSetIterator docIdSetIterator, Weight w) throws IOException { - super(similarity,w); + public ConstantScorer(DocIdSetIterator docIdSetIterator, Weight w) throws IOException { + super(w); theScore = w.getValue(); this.docIdSetIterator = docIdSetIterator; } @@ -212,8 +210,7 @@ public class ConstantScoreQuery extends Query { @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)); + collector.setScorer(new ConstantScorer(scorer, ConstantScorer.this.weight)); } @Override diff --git a/lucene/src/java/org/apache/lucene/search/DisjunctionMaxQuery.java b/lucene/src/java/org/apache/lucene/search/DisjunctionMaxQuery.java index 972e38e4ea6..0434232035e 100644 --- a/lucene/src/java/org/apache/lucene/search/DisjunctionMaxQuery.java +++ b/lucene/src/java/org/apache/lucene/search/DisjunctionMaxQuery.java @@ -95,29 +95,26 @@ public class DisjunctionMaxQuery extends Query implements Iterable { * change suddenly in the next release.

*/ protected class DisjunctionMaxWeight extends Weight { - /** The Similarity implementation. */ - protected Similarity similarity; /** The Weights for our subqueries, in 1-1 correspondence with disjuncts */ protected ArrayList weights = new ArrayList(); // The Weight's for our subqueries, in 1-1 correspondence with disjuncts - /* Construct the Weight for this Query searched by searcher. Recursively construct subquery weights. */ + /** Construct the Weight for this Query searched by searcher. Recursively construct subquery weights. */ public DisjunctionMaxWeight(IndexSearcher searcher) throws IOException { - this.similarity = searcher.getSimilarity(); for (Query disjunctQuery : disjuncts) { weights.add(disjunctQuery.createWeight(searcher)); } } - /* Return our associated DisjunctionMaxQuery */ + /** Return our associated DisjunctionMaxQuery */ @Override public Query getQuery() { return DisjunctionMaxQuery.this; } - /* Return our boost */ + /** Return our boost */ @Override public float getValue() { return getBoost(); } - /* Compute the sub of squared weights of us applied to our subqueries. Used for normalization. */ + /** Compute the sub of squared weights of us applied to our subqueries. Used for normalization. */ @Override public float sumOfSquaredWeights() throws IOException { float max = 0.0f, sum = 0.0f; @@ -131,7 +128,7 @@ public class DisjunctionMaxQuery extends Query implements Iterable { return (((sum - max) * tieBreakerMultiplier * tieBreakerMultiplier) + max) * boost * boost; } - /* Apply the computed normalization factor to our subqueries */ + /** Apply the computed normalization factor to our subqueries */ @Override public void normalize(float norm) { norm *= getBoost(); // Incorporate our boost @@ -140,7 +137,7 @@ public class DisjunctionMaxQuery extends Query implements Iterable { } } - /* Create the scorer used to score our associated DisjunctionMaxQuery */ + /** Create the scorer used to score our associated DisjunctionMaxQuery */ @Override public Scorer scorer(AtomicReaderContext context, ScorerContext scorerContext) throws IOException { Scorer[] scorers = new Scorer[weights.size()]; @@ -152,11 +149,11 @@ public class DisjunctionMaxQuery extends Query implements Iterable { } } if (idx == 0) return null; // all scorers did not have documents - DisjunctionMaxScorer result = new DisjunctionMaxScorer(tieBreakerMultiplier, similarity, scorers, idx); + DisjunctionMaxScorer result = new DisjunctionMaxScorer(this, tieBreakerMultiplier, scorers, idx); return result; } - /* Explain the score we computed for doc */ + /** Explain the score we computed for doc */ @Override public Explanation explain(AtomicReaderContext context, int doc) throws IOException { if (disjuncts.size() == 1) return weights.get(0).explain(context,doc); @@ -178,7 +175,7 @@ public class DisjunctionMaxQuery extends Query implements Iterable { } // end of DisjunctionMaxWeight inner class - /* Create the Weight used to score us */ + /** Create the Weight used to score us */ @Override public Weight createWeight(IndexSearcher searcher) throws IOException { return new DisjunctionMaxWeight(searcher); diff --git a/lucene/src/java/org/apache/lucene/search/DisjunctionMaxScorer.java b/lucene/src/java/org/apache/lucene/search/DisjunctionMaxScorer.java index d6f5d2a8a5c..9995062c2fe 100644 --- a/lucene/src/java/org/apache/lucene/search/DisjunctionMaxScorer.java +++ b/lucene/src/java/org/apache/lucene/search/DisjunctionMaxScorer.java @@ -40,22 +40,20 @@ class DisjunctionMaxScorer extends Scorer { /** * Creates a new instance of DisjunctionMaxScorer * + * @param weight + * The Weight to be used. * @param tieBreakerMultiplier * Multiplier applied to non-maximum-scoring subqueries for a * document as they are summed into the result. - * @param similarity - * -- not used since our definition involves neither coord nor terms - * directly * @param subScorers * The sub scorers this Scorer should iterate on * @param numScorers * The actual number of scorers to iterate on. Note that the array's * length may be larger than the actual number of scorers. */ - public DisjunctionMaxScorer(float tieBreakerMultiplier, - Similarity similarity, Scorer[] subScorers, int numScorers) throws IOException { - super(similarity); - + public DisjunctionMaxScorer(Weight weight, float tieBreakerMultiplier, + Scorer[] subScorers, int numScorers) throws IOException { + super(weight); this.tieBreakerMultiplier = tieBreakerMultiplier; // The passed subScorers array includes only scorers which have documents // (DisjunctionMaxQuery takes care of that), and their nextDoc() was already diff --git a/lucene/src/java/org/apache/lucene/search/DisjunctionSumScorer.java b/lucene/src/java/org/apache/lucene/search/DisjunctionSumScorer.java index 5ec3514e95b..2f7fa5daf33 100644 --- a/lucene/src/java/org/apache/lucene/search/DisjunctionSumScorer.java +++ b/lucene/src/java/org/apache/lucene/search/DisjunctionSumScorer.java @@ -58,6 +58,7 @@ class DisjunctionSumScorer extends Scorer { private float currentScore = Float.NaN; /** Construct a DisjunctionScorer. + * @param weight The weight to be used. * @param subScorers A collection of at least two subscorers. * @param minimumNrMatchers The positive minimum number of subscorers that should * match to match this query. @@ -67,8 +68,8 @@ class DisjunctionSumScorer extends Scorer { *
When minimumNrMatchers equals the number of subScorers, * it more efficient to use ConjunctionScorer. */ - public DisjunctionSumScorer( List subScorers, int minimumNrMatchers) throws IOException { - super(null); + public DisjunctionSumScorer(Weight weight, List subScorers, int minimumNrMatchers) throws IOException { + super(weight); nrScorers = subScorers.size(); @@ -88,8 +89,8 @@ class DisjunctionSumScorer extends Scorer { /** Construct a DisjunctionScorer, using one as the minimum number * of matching subscorers. */ - public DisjunctionSumScorer(List subScorers) throws IOException { - this(subScorers, 1); + public DisjunctionSumScorer(Weight weight, List subScorers) throws IOException { + this(weight, subScorers, 1); } /** Called the first time nextDoc() or advance() is called to diff --git a/lucene/src/java/org/apache/lucene/search/ExactPhraseScorer.java b/lucene/src/java/org/apache/lucene/search/ExactPhraseScorer.java index f2c94a7ae6f..153821d92d0 100644 --- a/lucene/src/java/org/apache/lucene/search/ExactPhraseScorer.java +++ b/lucene/src/java/org/apache/lucene/search/ExactPhraseScorer.java @@ -60,9 +60,12 @@ final class ExactPhraseScorer extends Scorer { private int docID = -1; private int freq; + private final Similarity similarity; + ExactPhraseScorer(Weight weight, PhraseQuery.PostingsAndFreq[] postings, Similarity similarity, byte[] norms) throws IOException { - super(similarity, weight); + super(weight); + this.similarity = similarity; this.norms = norms; this.value = weight.getValue(); @@ -87,7 +90,7 @@ final class ExactPhraseScorer extends Scorer { } for (int i = 0; i < SCORE_CACHE_SIZE; i++) { - scoreCache[i] = getSimilarity().tf((float) i) * value; + scoreCache[i] = similarity.tf((float) i) * value; } } @@ -207,9 +210,9 @@ final class ExactPhraseScorer extends Scorer { if (freq < SCORE_CACHE_SIZE) { raw = scoreCache[freq]; } else { - raw = getSimilarity().tf((float) freq) * value; + raw = similarity.tf((float) freq) * value; } - return norms == null ? raw : raw * getSimilarity().decodeNormValue(norms[docID]); // normalize + return norms == null ? raw : raw * similarity.decodeNormValue(norms[docID]); // normalize } private int phraseFreq() throws IOException { diff --git a/lucene/src/java/org/apache/lucene/search/FilteredQuery.java b/lucene/src/java/org/apache/lucene/search/FilteredQuery.java index e273d37e426..1bcd8459d84 100644 --- a/lucene/src/java/org/apache/lucene/search/FilteredQuery.java +++ b/lucene/src/java/org/apache/lucene/search/FilteredQuery.java @@ -62,7 +62,6 @@ extends Query { @Override public Weight createWeight(final IndexSearcher searcher) throws IOException { final Weight weight = query.createWeight (searcher); - final Similarity similarity = searcher.getSimilarity(); return new Weight() { private float value; @@ -127,7 +126,7 @@ extends Query { return null; } - return new Scorer(similarity, this) { + return new Scorer(this) { private int doc = -1; diff --git a/lucene/src/java/org/apache/lucene/search/MatchAllDocsQuery.java b/lucene/src/java/org/apache/lucene/search/MatchAllDocsQuery.java index 5fa771e46d7..6ade92d4a5a 100644 --- a/lucene/src/java/org/apache/lucene/search/MatchAllDocsQuery.java +++ b/lucene/src/java/org/apache/lucene/search/MatchAllDocsQuery.java @@ -51,10 +51,12 @@ public class MatchAllDocsQuery extends Query { private int doc = -1; private final int maxDoc; private final Bits delDocs; + private final Similarity similarity; MatchAllScorer(IndexReader reader, Similarity similarity, Weight w, byte[] norms) throws IOException { - super(similarity,w); + super(w); + this.similarity = similarity; delDocs = reader.getDeletedDocs(); score = w.getValue(); maxDoc = reader.maxDoc(); @@ -80,7 +82,7 @@ public class MatchAllDocsQuery extends Query { @Override public float score() { - return norms == null ? score : score * getSimilarity().decodeNormValue(norms[docID()]); + return norms == null ? score : score * similarity.decodeNormValue(norms[docID()]); } @Override diff --git a/lucene/src/java/org/apache/lucene/search/PhraseScorer.java b/lucene/src/java/org/apache/lucene/search/PhraseScorer.java index 1f9dc6375c6..1fedc2eb3ee 100644 --- a/lucene/src/java/org/apache/lucene/search/PhraseScorer.java +++ b/lucene/src/java/org/apache/lucene/search/PhraseScorer.java @@ -40,9 +40,12 @@ abstract class PhraseScorer extends Scorer { private float freq; //phrase frequency in current doc as computed by phraseFreq(). + protected final Similarity similarity; + PhraseScorer(Weight weight, PhraseQuery.PostingsAndFreq[] postings, Similarity similarity, byte[] norms) { - super(similarity, weight); + super(weight); + this.similarity = similarity; this.norms = norms; this.value = weight.getValue(); @@ -105,8 +108,8 @@ abstract class PhraseScorer extends Scorer { @Override public float score() throws IOException { //System.out.println("scoring " + first.doc); - float raw = getSimilarity().tf(freq) * value; // raw score - return norms == null ? raw : raw * getSimilarity().decodeNormValue(norms[first.doc]); // normalize + float raw = similarity.tf(freq) * value; // raw score + return norms == null ? raw : raw * similarity.decodeNormValue(norms[first.doc]); // normalize } @Override diff --git a/lucene/src/java/org/apache/lucene/search/ReqExclScorer.java b/lucene/src/java/org/apache/lucene/search/ReqExclScorer.java index a32922b1947..a9d2d043d65 100644 --- a/lucene/src/java/org/apache/lucene/search/ReqExclScorer.java +++ b/lucene/src/java/org/apache/lucene/search/ReqExclScorer.java @@ -36,7 +36,7 @@ class ReqExclScorer extends Scorer { * @param exclDisi indicates exclusion. */ public ReqExclScorer(Scorer reqScorer, DocIdSetIterator exclDisi) { - super(null); // No similarity used. + super(reqScorer.weight); this.reqScorer = reqScorer; this.exclDisi = exclDisi; } diff --git a/lucene/src/java/org/apache/lucene/search/ReqOptSumScorer.java b/lucene/src/java/org/apache/lucene/search/ReqOptSumScorer.java index c8e1b81ff54..ad9a9c146e2 100644 --- a/lucene/src/java/org/apache/lucene/search/ReqOptSumScorer.java +++ b/lucene/src/java/org/apache/lucene/search/ReqOptSumScorer.java @@ -38,7 +38,7 @@ class ReqOptSumScorer extends Scorer { Scorer reqScorer, Scorer optScorer) { - super(null); // No similarity used. + super(reqScorer.weight); this.reqScorer = reqScorer; this.optScorer = optScorer; } diff --git a/lucene/src/java/org/apache/lucene/search/ScoreCachingWrappingScorer.java b/lucene/src/java/org/apache/lucene/search/ScoreCachingWrappingScorer.java index b35e452252f..4aac1b185e4 100644 --- a/lucene/src/java/org/apache/lucene/search/ScoreCachingWrappingScorer.java +++ b/lucene/src/java/org/apache/lucene/search/ScoreCachingWrappingScorer.java @@ -38,7 +38,7 @@ public class ScoreCachingWrappingScorer extends Scorer { /** Creates a new instance by wrapping the given scorer. */ public ScoreCachingWrappingScorer(Scorer scorer) { - super(scorer.getSimilarity()); + super(scorer.weight); this.scorer = scorer; } @@ -46,11 +46,6 @@ public class ScoreCachingWrappingScorer extends Scorer { public boolean score(Collector collector, int max, int firstDocID) throws IOException { return scorer.score(collector, max, firstDocID); } - - @Override - public Similarity getSimilarity() { - return scorer.getSimilarity(); - } @Override public float score() throws IOException { diff --git a/lucene/src/java/org/apache/lucene/search/Scorer.java b/lucene/src/java/org/apache/lucene/search/Scorer.java index 907cdf3aa8a..8642f957aa7 100644 --- a/lucene/src/java/org/apache/lucene/search/Scorer.java +++ b/lucene/src/java/org/apache/lucene/search/Scorer.java @@ -40,31 +40,16 @@ import org.apache.lucene.search.BooleanClause.Occur; * with these scores. */ public abstract class Scorer extends DocIdSetIterator { - private final Similarity similarity; protected final Weight weight; - /** Constructs a Scorer. - * @param similarity The Similarity implementation used by this scorer. - */ - protected Scorer(Similarity similarity) { - this(similarity, null); - } - /** * Constructs a Scorer - * @param similarity The Similarity implementation used by this scorer. - * @param weight The scorers Weight + * @param weight The scorers Weight. */ - protected Scorer(Similarity similarity, Weight weight) { - this.similarity = similarity; + protected Scorer(Weight weight) { this.weight = weight; } - /** Returns the Similarity implementation used by this scorer. */ - public Similarity getSimilarity() { - return this.similarity; - } - /** Scores and collects all matching documents. * @param collector The collector to which all matching documents are passed. */ @@ -172,7 +157,7 @@ public abstract class Scorer extends DocIdSetIterator { *

* Note: this method will throw {@link UnsupportedOperationException} if no * associated {@link Weight} instance is provided to - * {@link #Scorer(Similarity, Weight)} + * {@link #Scorer(Weight)} *

* * @lucene.experimental diff --git a/lucene/src/java/org/apache/lucene/search/SloppyPhraseScorer.java b/lucene/src/java/org/apache/lucene/search/SloppyPhraseScorer.java index 42941214d6e..cc9fad302d0 100644 --- a/lucene/src/java/org/apache/lucene/search/SloppyPhraseScorer.java +++ b/lucene/src/java/org/apache/lucene/search/SloppyPhraseScorer.java @@ -78,7 +78,7 @@ final class SloppyPhraseScorer extends PhraseScorer { int matchLength = end - start; if (matchLength <= slop) - freq += getSimilarity().sloppyFreq(matchLength); // score match + freq += similarity.sloppyFreq(matchLength); // score match if (pp.position > end) end = pp.position; diff --git a/lucene/src/java/org/apache/lucene/search/TermScorer.java b/lucene/src/java/org/apache/lucene/search/TermScorer.java index cffea443afc..9a9ef5eeb3c 100644 --- a/lucene/src/java/org/apache/lucene/search/TermScorer.java +++ b/lucene/src/java/org/apache/lucene/search/TermScorer.java @@ -38,7 +38,8 @@ final class TermScorer extends Scorer { private int[] docs; private int[] freqs; private final DocsEnum.BulkReadResult bulkResult; - + private final Similarity similarity; + /** * Construct a TermScorer. * @@ -53,15 +54,15 @@ final class TermScorer extends Scorer { * The field norms of the document fields for the Term. */ TermScorer(Weight weight, DocsEnum td, Similarity similarity, byte[] norms) { - super(similarity, weight); - + super(weight); + this.similarity = similarity; this.docsEnum = td; this.norms = norms; this.weightValue = weight.getValue(); bulkResult = td.getBulkResult(); for (int i = 0; i < SCORE_CACHE_SIZE; i++) - scoreCache[i] = getSimilarity().tf(i) * weightValue; + scoreCache[i] = similarity.tf(i) * weightValue; } @Override @@ -136,9 +137,9 @@ final class TermScorer extends Scorer { float raw = // compute tf(f)*weight freq < SCORE_CACHE_SIZE // check cache ? scoreCache[freq] // cache hit - : getSimilarity().tf(freq)*weightValue; // cache miss + : similarity.tf(freq)*weightValue; // cache miss - return norms == null ? raw : raw * getSimilarity().decodeNormValue(norms[doc]); // normalize for field + return norms == null ? raw : raw * similarity.decodeNormValue(norms[doc]); // normalize for field } /** diff --git a/lucene/src/java/org/apache/lucene/search/function/CustomScoreQuery.java b/lucene/src/java/org/apache/lucene/search/function/CustomScoreQuery.java index 7bd1b715f8b..8f29cbe1955 100755 --- a/lucene/src/java/org/apache/lucene/search/function/CustomScoreQuery.java +++ b/lucene/src/java/org/apache/lucene/search/function/CustomScoreQuery.java @@ -30,7 +30,6 @@ import org.apache.lucene.search.Query; import org.apache.lucene.search.Weight; import org.apache.lucene.search.Scorer; import org.apache.lucene.search.IndexSearcher; -import org.apache.lucene.search.Similarity; import org.apache.lucene.util.ToStringUtils; /** @@ -183,13 +182,11 @@ public class CustomScoreQuery extends Query { //=========================== W E I G H T ============================ private class CustomWeight extends Weight { - Similarity similarity; Weight subQueryWeight; Weight[] valSrcWeights; boolean qStrict; public CustomWeight(IndexSearcher searcher) throws IOException { - this.similarity = searcher.getSimilarity(); this.subQueryWeight = subQuery.weight(searcher); this.valSrcWeights = new Weight[valSrcQueries.length]; for(int i = 0; i < valSrcQueries.length; i++) { @@ -254,7 +251,7 @@ public class CustomScoreQuery extends Query { for(int i = 0; i < valSrcScorers.length; i++) { valSrcScorers[i] = valSrcWeights[i].scorer(context, scorerContext.scoreDocsInOrder(true)); } - return new CustomScorer(similarity, context.reader, this, subQueryScorer, valSrcScorers); + return new CustomScorer(context.reader, this, subQueryScorer, valSrcScorers); } @Override @@ -303,9 +300,9 @@ public class CustomScoreQuery extends Query { private float vScores[]; // reused in score() to avoid allocating this array for each doc // constructor - private CustomScorer(Similarity similarity, IndexReader reader, CustomWeight w, + private CustomScorer(IndexReader reader, CustomWeight w, Scorer subQueryScorer, Scorer[] valSrcScorers) throws IOException { - super(similarity,w); + super(w); this.qWeight = w.getValue(); this.subQueryScorer = subQueryScorer; this.valSrcScorers = valSrcScorers; diff --git a/lucene/src/java/org/apache/lucene/search/function/ValueSourceQuery.java b/lucene/src/java/org/apache/lucene/search/function/ValueSourceQuery.java index 64971a7bc76..4f26ee01dbf 100644 --- a/lucene/src/java/org/apache/lucene/search/function/ValueSourceQuery.java +++ b/lucene/src/java/org/apache/lucene/search/function/ValueSourceQuery.java @@ -64,12 +64,10 @@ public class ValueSourceQuery extends Query { } class ValueSourceWeight extends Weight { - Similarity similarity; float queryNorm; float queryWeight; public ValueSourceWeight(IndexSearcher searcher) { - this.similarity = searcher.getSimilarity(); } /*(non-Javadoc) @see org.apache.lucene.search.Weight#getQuery() */ @@ -100,7 +98,7 @@ public class ValueSourceQuery extends Query { @Override public Scorer scorer(AtomicReaderContext context, ScorerContext scorerContext) throws IOException { - return new ValueSourceScorer(similarity, context, this); + return new ValueSourceScorer(context, this); } /*(non-Javadoc) @see org.apache.lucene.search.Weight#explain(org.apache.lucene.index.IndexReader, int) */ @@ -133,8 +131,8 @@ public class ValueSourceQuery extends Query { private int doc = -1; // constructor - private ValueSourceScorer(Similarity similarity, AtomicReaderContext context, ValueSourceWeight w) throws IOException { - super(similarity,w); + private ValueSourceScorer(AtomicReaderContext context, ValueSourceWeight w) throws IOException { + super(w); final IndexReader reader = context.reader; qWeight = w.getValue(); // this is when/where the values are first created. diff --git a/lucene/src/java/org/apache/lucene/search/payloads/PayloadNearQuery.java b/lucene/src/java/org/apache/lucene/search/payloads/PayloadNearQuery.java index 0e8ff6c49a8..cc363f937cd 100644 --- a/lucene/src/java/org/apache/lucene/search/payloads/PayloadNearQuery.java +++ b/lucene/src/java/org/apache/lucene/search/payloads/PayloadNearQuery.java @@ -153,7 +153,6 @@ public class PayloadNearQuery extends SpanNearQuery { Spans spans; protected float payloadScore; private int payloadsSeen; - Similarity similarity = getSimilarity(); protected PayloadNearSpanScorer(Spans spans, Weight weight, Similarity similarity, byte[] norms) throws IOException { @@ -211,7 +210,7 @@ public class PayloadNearQuery extends SpanNearQuery { payloadsSeen = 0; do { int matchLength = spans.end() - spans.start(); - freq += getSimilarity().sloppyFreq(matchLength); + freq += similarity.sloppyFreq(matchLength); Spans[] spansArr = new Spans[1]; spansArr[0] = spans; getPayloads(spansArr); diff --git a/lucene/src/java/org/apache/lucene/search/payloads/PayloadTermQuery.java b/lucene/src/java/org/apache/lucene/search/payloads/PayloadTermQuery.java index fe90da15dae..36304b9e23e 100644 --- a/lucene/src/java/org/apache/lucene/search/payloads/PayloadTermQuery.java +++ b/lucene/src/java/org/apache/lucene/search/payloads/PayloadTermQuery.java @@ -100,12 +100,11 @@ public class PayloadTermQuery extends SpanTermQuery { freq = 0.0f; payloadScore = 0; payloadsSeen = 0; - Similarity similarity1 = getSimilarity(); while (more && doc == spans.doc()) { int matchLength = spans.end() - spans.start(); - freq += similarity1.sloppyFreq(matchLength); - processPayload(similarity1); + freq += similarity.sloppyFreq(matchLength); + processPayload(similarity); more = spans.next();// this moves positions to the next match in this // document diff --git a/lucene/src/java/org/apache/lucene/search/spans/FieldMaskingSpanQuery.java b/lucene/src/java/org/apache/lucene/search/spans/FieldMaskingSpanQuery.java index be130bc4eb4..5efc0c91079 100644 --- a/lucene/src/java/org/apache/lucene/search/spans/FieldMaskingSpanQuery.java +++ b/lucene/src/java/org/apache/lucene/search/spans/FieldMaskingSpanQuery.java @@ -25,7 +25,6 @@ import org.apache.lucene.index.Term; import org.apache.lucene.search.Query; import org.apache.lucene.search.Weight; import org.apache.lucene.search.IndexSearcher; -import org.apache.lucene.search.Similarity; import org.apache.lucene.util.ToStringUtils; /** diff --git a/lucene/src/java/org/apache/lucene/search/spans/SpanScorer.java b/lucene/src/java/org/apache/lucene/search/spans/SpanScorer.java index 1d2d9f50bca..8b309a3df68 100644 --- a/lucene/src/java/org/apache/lucene/search/spans/SpanScorer.java +++ b/lucene/src/java/org/apache/lucene/search/spans/SpanScorer.java @@ -36,10 +36,12 @@ public class SpanScorer extends Scorer { protected int doc; protected float freq; - + protected final Similarity similarity; + protected SpanScorer(Spans spans, Weight weight, Similarity similarity, byte[] norms) throws IOException { - super(similarity, weight); + super(weight); + this.similarity = similarity; this.spans = spans; this.norms = norms; this.value = weight.getValue(); @@ -81,7 +83,7 @@ public class SpanScorer extends Scorer { freq = 0.0f; do { int matchLength = spans.end() - spans.start(); - freq += getSimilarity().sloppyFreq(matchLength); + freq += similarity.sloppyFreq(matchLength); more = spans.next(); } while (more && (doc == spans.doc())); return true; @@ -92,8 +94,8 @@ public class SpanScorer extends Scorer { @Override public float score() throws IOException { - float raw = getSimilarity().tf(freq) * value; // raw score - return norms == null? raw : raw * getSimilarity().decodeNormValue(norms[doc]); // normalize + float raw = similarity.tf(freq) * value; // raw score + return norms == null? raw : raw * similarity.decodeNormValue(norms[doc]); // normalize } @Override @@ -109,7 +111,7 @@ public class SpanScorer extends Scorer { int expDoc = advance(doc); float phraseFreq = (expDoc == doc) ? freq : 0.0f; - tfExplanation.setValue(getSimilarity().tf(phraseFreq)); + tfExplanation.setValue(similarity.tf(phraseFreq)); tfExplanation.setDescription("tf(phraseFreq=" + phraseFreq + ")"); return tfExplanation; diff --git a/lucene/src/test/org/apache/lucene/search/JustCompileSearch.java b/lucene/src/test/org/apache/lucene/search/JustCompileSearch.java index efdd3466edf..259b425cd8f 100644 --- a/lucene/src/test/org/apache/lucene/search/JustCompileSearch.java +++ b/lucene/src/test/org/apache/lucene/search/JustCompileSearch.java @@ -210,8 +210,8 @@ final class JustCompileSearch { static final class JustCompileScorer extends Scorer { - protected JustCompileScorer(Similarity similarity) { - super(similarity); + protected JustCompileScorer(Weight weight) { + super(weight); } @Override diff --git a/lucene/src/test/org/apache/lucene/search/TestBooleanScorer.java b/lucene/src/test/org/apache/lucene/search/TestBooleanScorer.java index 2e6c52a9b90..9d25a4cda74 100644 --- a/lucene/src/test/org/apache/lucene/search/TestBooleanScorer.java +++ b/lucene/src/test/org/apache/lucene/search/TestBooleanScorer.java @@ -75,9 +75,8 @@ public class TestBooleanScorer extends LuceneTestCase IndexReader ir = writer.getReader(); writer.close(); IndexSearcher searcher = new IndexSearcher(ir); - - Similarity sim = Similarity.getDefault(); - Scorer[] scorers = new Scorer[] {new Scorer(sim) { + BooleanWeight weight = (BooleanWeight) new BooleanQuery().createWeight(searcher); + Scorer[] scorers = new Scorer[] {new Scorer(weight) { private int doc = -1; @Override public float score() throws IOException { return 0; } @Override public int docID() { return doc; } @@ -91,7 +90,7 @@ public class TestBooleanScorer extends LuceneTestCase } }}; - BooleanWeight weight = (BooleanWeight) new BooleanQuery().createWeight(searcher); + BooleanScorer bs = new BooleanScorer(weight, false, 1, Arrays.asList(scorers), null, scorers.length); assertEquals("should have received 3000", 3000, bs.nextDoc()); diff --git a/lucene/src/test/org/apache/lucene/search/TestPositiveScoresOnlyCollector.java b/lucene/src/test/org/apache/lucene/search/TestPositiveScoresOnlyCollector.java index 28045441dce..42c5ffffa04 100644 --- a/lucene/src/test/org/apache/lucene/search/TestPositiveScoresOnlyCollector.java +++ b/lucene/src/test/org/apache/lucene/search/TestPositiveScoresOnlyCollector.java @@ -19,6 +19,10 @@ package org.apache.lucene.search; import java.io.IOException; +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; public class TestPositiveScoresOnlyCollector extends LuceneTestCase { @@ -26,8 +30,8 @@ public class TestPositiveScoresOnlyCollector extends LuceneTestCase { private static final class SimpleScorer extends Scorer { private int idx = -1; - public SimpleScorer() { - super(null); + public SimpleScorer(Weight weight) { + super(weight); } @Override public float score() throws IOException { @@ -65,7 +69,14 @@ public class TestPositiveScoresOnlyCollector extends LuceneTestCase { } } - Scorer s = new SimpleScorer(); + Directory directory = newDirectory(); + RandomIndexWriter writer = new RandomIndexWriter(random, directory); + writer.commit(); + IndexReader ir = writer.getReader(); + writer.close(); + IndexSearcher searcher = new IndexSearcher(ir); + Weight fake = new TermQuery(new Term("fake", "weight")).createWeight(searcher); + Scorer s = new SimpleScorer(fake); TopDocsCollector tdc = TopScoreDocCollector.create(scores.length, true); Collector c = new PositiveScoresOnlyCollector(tdc); c.setScorer(s); @@ -78,6 +89,9 @@ public class TestPositiveScoresOnlyCollector extends LuceneTestCase { for (int i = 0; i < sd.length; i++) { assertTrue("only positive scores should return: " + sd[i].score, sd[i].score > 0); } + searcher.close(); + ir.close(); + directory.close(); } } diff --git a/lucene/src/test/org/apache/lucene/search/TestScoreCachingWrappingScorer.java b/lucene/src/test/org/apache/lucene/search/TestScoreCachingWrappingScorer.java index a6ba9f61079..d6bc217c70d 100644 --- a/lucene/src/test/org/apache/lucene/search/TestScoreCachingWrappingScorer.java +++ b/lucene/src/test/org/apache/lucene/search/TestScoreCachingWrappingScorer.java @@ -19,7 +19,11 @@ package org.apache.lucene.search; import java.io.IOException; +import org.apache.lucene.index.IndexReader; +import org.apache.lucene.index.RandomIndexWriter; import org.apache.lucene.index.IndexReader.AtomicReaderContext; +import org.apache.lucene.index.Term; +import org.apache.lucene.store.Directory; import org.apache.lucene.util.LuceneTestCase; public class TestScoreCachingWrappingScorer extends LuceneTestCase { @@ -28,8 +32,8 @@ public class TestScoreCachingWrappingScorer extends LuceneTestCase { private int idx = 0; private int doc = -1; - public SimpleScorer() { - super(null); + public SimpleScorer(Weight weight) { + super(weight); } @Override public float score() throws IOException { @@ -95,8 +99,14 @@ public class TestScoreCachingWrappingScorer extends LuceneTestCase { 8.108544f, 4.961808f, 2.2423935f, 7.285586f, 4.6699767f }; public void testGetScores() throws Exception { - - Scorer s = new SimpleScorer(); + Directory directory = newDirectory(); + RandomIndexWriter writer = new RandomIndexWriter(random, directory); + writer.commit(); + IndexReader ir = writer.getReader(); + writer.close(); + IndexSearcher searcher = new IndexSearcher(ir); + Weight fake = new TermQuery(new Term("fake", "weight")).createWeight(searcher); + Scorer s = new SimpleScorer(fake); ScoreCachingCollector scc = new ScoreCachingCollector(scores.length); scc.setScorer(s); @@ -109,7 +119,9 @@ public class TestScoreCachingWrappingScorer extends LuceneTestCase { for (int i = 0; i < scores.length; i++) { assertEquals(scores[i], scc.mscores[i], 0f); } - + searcher.close(); + ir.close(); + directory.close(); } } diff --git a/solr/src/java/org/apache/solr/schema/LatLonType.java b/solr/src/java/org/apache/solr/schema/LatLonType.java index 9045d9e0619..b1f95348a53 100644 --- a/solr/src/java/org/apache/solr/schema/LatLonType.java +++ b/solr/src/java/org/apache/solr/schema/LatLonType.java @@ -371,7 +371,7 @@ class SpatialDistanceQuery extends Query { @Override public Scorer scorer(AtomicReaderContext context, ScorerContext scorerContext) throws IOException { - return new SpatialScorer(searcher.getSimilarity(), context, this); + return new SpatialScorer(context, this); } @Override @@ -404,8 +404,8 @@ class SpatialDistanceQuery extends Query { int lastDistDoc; double lastDist; - public SpatialScorer(Similarity similarity, AtomicReaderContext readerContext, SpatialWeight w) throws IOException { - super(similarity); + public SpatialScorer(AtomicReaderContext readerContext, SpatialWeight w) throws IOException { + super(w); this.weight = w; this.qWeight = w.getValue(); this.reader = readerContext.reader; diff --git a/solr/src/java/org/apache/solr/search/SolrConstantScoreQuery.java b/solr/src/java/org/apache/solr/search/SolrConstantScoreQuery.java index 9df9bec0ac7..0c6c67ad43f 100755 --- a/solr/src/java/org/apache/solr/search/SolrConstantScoreQuery.java +++ b/solr/src/java/org/apache/solr/search/SolrConstantScoreQuery.java @@ -91,13 +91,13 @@ public class SolrConstantScoreQuery extends ConstantScoreQuery { @Override public Scorer scorer(AtomicReaderContext context, ScorerContext scorerContext) throws IOException { - return new ConstantScorer(similarity, context, this); + return new ConstantScorer(context, this); } @Override public Explanation explain(AtomicReaderContext context, int doc) throws IOException { - ConstantScorer cs = new ConstantScorer(similarity, context, this); + ConstantScorer cs = new ConstantScorer(context, this); boolean exists = cs.docIdSetIterator.advance(doc) == doc; ComplexExplanation result = new ComplexExplanation(); @@ -124,8 +124,8 @@ public class SolrConstantScoreQuery extends ConstantScoreQuery { final float theScore; int doc = -1; - public ConstantScorer(Similarity similarity, AtomicReaderContext context, ConstantWeight w) throws IOException { - super(similarity); + public ConstantScorer(AtomicReaderContext context, ConstantWeight w) throws IOException { + super(w); theScore = w.getValue(); DocIdSet docIdSet = filter instanceof SolrFilter ? ((SolrFilter)filter).getDocIdSet(w.context, context) : filter.getDocIdSet(context); if (docIdSet == null) { diff --git a/solr/src/java/org/apache/solr/search/function/BoostedQuery.java b/solr/src/java/org/apache/solr/search/function/BoostedQuery.java index 3564d9208c8..1283c600b60 100755 --- a/solr/src/java/org/apache/solr/search/function/BoostedQuery.java +++ b/solr/src/java/org/apache/solr/search/function/BoostedQuery.java @@ -96,7 +96,7 @@ public class BoostedQuery extends Query { if(subQueryScorer == null) { return null; } - return new BoostedQuery.CustomScorer(searcher.getSimilarity(), context, this, subQueryScorer, boostVal); + return new BoostedQuery.CustomScorer(context, this, subQueryScorer, boostVal); } @Override @@ -123,9 +123,9 @@ public class BoostedQuery extends Query { private final DocValues vals; private final AtomicReaderContext readerContext; - private CustomScorer(Similarity similarity, AtomicReaderContext readerContext, BoostedQuery.BoostedWeight w, + private CustomScorer(AtomicReaderContext readerContext, BoostedQuery.BoostedWeight w, Scorer scorer, ValueSource vs) throws IOException { - super(similarity); + super(w); this.weight = w; this.qWeight = w.getValue(); this.scorer = scorer; diff --git a/solr/src/java/org/apache/solr/search/function/FunctionQuery.java b/solr/src/java/org/apache/solr/search/function/FunctionQuery.java index 44eb99ebc54..beb43bc22ac 100644 --- a/solr/src/java/org/apache/solr/search/function/FunctionQuery.java +++ b/solr/src/java/org/apache/solr/search/function/FunctionQuery.java @@ -95,7 +95,7 @@ public class FunctionQuery extends Query { @Override public Scorer scorer(AtomicReaderContext context, ScorerContext scorerContext) throws IOException { - return new AllScorer(searcher.getSimilarity(), context, this); + return new AllScorer(context, this); } @Override @@ -114,8 +114,8 @@ public class FunctionQuery extends Query { final boolean hasDeletions; final Bits delDocs; - public AllScorer(Similarity similarity, AtomicReaderContext context, FunctionWeight w) throws IOException { - super(similarity); + public AllScorer(AtomicReaderContext context, FunctionWeight w) throws IOException { + super(w); this.weight = w; this.qWeight = w.getValue(); this.reader = context.reader;