Apache
/
lucene
mirror of https://github.com/apache/lucene.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

LUCENE-2876: Remove Scorer.getSimilarity 

git-svn-id: https://svn.apache.org/repos/asf/lucene/dev/trunk@1061499 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Robert Muir 2011-01-20 20:36:44 +00:00
parent 1a0f78778b
commit 4f2a9e7aa3
32 changed files with 147 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
lucene/CHANGES.txt
View File

@ -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

6
lucene/src/java/org/apache/lucene/search/BooleanScorer.java
View File

@ -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<Scorer> optionalScorers, List<Scorer> 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 {

19
lucene/src/java/org/apache/lucene/search/BooleanScorer2.java
View File

@ -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<Scorer> required, List<Scorer> prohibited, List<Scorer> 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<Scorer> 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<Scorer> 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.

8
lucene/src/java/org/apache/lucene/search/ConjunctionScorer.java
View File

@ -29,12 +29,12 @@ class ConjunctionScorer extends Scorer {
private final float coord;
private int lastDoc = -1;
public ConjunctionScorer(float coord, Collection<Scorer> scorers) throws IOException {
this(coord, scorers.toArray(new Scorer[scorers.size()]));
public ConjunctionScorer(Weight weight, float coord, Collection<Scorer> 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;

11
lucene/src/java/org/apache/lucene/search/ConstantScoreQuery.java
View File

@ -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

21
lucene/src/java/org/apache/lucene/search/DisjunctionMaxQuery.java
View File

@ -95,29 +95,26 @@ public class DisjunctionMaxQuery extends Query implements Iterable<Query> {
* change suddenly in the next release.</p>
*/
protected class DisjunctionMaxWeight extends Weight {
/** The Similarity implementation. */
protected Similarity similarity;
/** The Weights for our subqueries, in 1-1 correspondence with disjuncts */
protected ArrayList<Weight> weights = new ArrayList<Weight>(); // 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<Query> {
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<Query> {
}
}
/* 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<Query> {
}
}
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<Query> {
} // 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);

12
lucene/src/java/org/apache/lucene/search/DisjunctionMaxScorer.java
View File

@ -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

9
lucene/src/java/org/apache/lucene/search/DisjunctionSumScorer.java
View File

@ -58,6 +58,7 @@ class DisjunctionSumScorer extends Scorer {
private float currentScore = Float.NaN;
/** Construct a <code>DisjunctionScorer</code>.
* @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 {
* <br>When minimumNrMatchers equals the number of subScorers,
* it more efficient to use <code>ConjunctionScorer</code>.
*/
public DisjunctionSumScorer( List<Scorer> subScorers, int minimumNrMatchers) throws IOException {
super(null);
public DisjunctionSumScorer(Weight weight, List<Scorer> subScorers, int minimumNrMatchers) throws IOException {
super(weight);
nrScorers = subScorers.size();
@ -88,8 +89,8 @@ class DisjunctionSumScorer extends Scorer {
/** Construct a <code>DisjunctionScorer</code>, using one as the minimum number
* of matching subscorers.
*/
public DisjunctionSumScorer(List<Scorer> subScorers) throws IOException {
this(subScorers, 1);
public DisjunctionSumScorer(Weight weight, List<Scorer> subScorers) throws IOException {
this(weight, subScorers, 1);
}
/** Called the first time nextDoc() or advance() is called to

11
lucene/src/java/org/apache/lucene/search/ExactPhraseScorer.java
View File

@ -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 {

3
lucene/src/java/org/apache/lucene/search/FilteredQuery.java
View File

@ -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;

6
lucene/src/java/org/apache/lucene/search/MatchAllDocsQuery.java
View File

@ -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

9
lucene/src/java/org/apache/lucene/search/PhraseScorer.java
View File

@ -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

2
lucene/src/java/org/apache/lucene/search/ReqExclScorer.java
View File

@ -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;
}

2
lucene/src/java/org/apache/lucene/search/ReqOptSumScorer.java
View File

@ -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;
}

7
lucene/src/java/org/apache/lucene/search/ScoreCachingWrappingScorer.java
View File

@ -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 {

21
lucene/src/java/org/apache/lucene/search/Scorer.java
View File

@ -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 <code>Similarity</code> implementation used by this scorer.
*/
protected Scorer(Similarity similarity) {
this(similarity, null);
}
/**
* Constructs a Scorer
* @param similarity The <code>Similarity</code> implementation used by this scorer.
* @param weight The scorers <code>Weight</code>
* @param weight The scorers <code>Weight</code>.
*/
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 {
* <p>
* Note: this method will throw {@link UnsupportedOperationException} if no
* associated {@link Weight} instance is provided to
* {@link #Scorer(Similarity, Weight)}
* {@link #Scorer(Weight)}
* </p>
*
* @lucene.experimental

2
lucene/src/java/org/apache/lucene/search/SloppyPhraseScorer.java
View File

@ -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;

13
lucene/src/java/org/apache/lucene/search/TermScorer.java
View File

@ -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 <code>TermScorer</code>.
*
@ -53,15 +54,15 @@ final class TermScorer extends Scorer {
* The field norms of the document fields for the <code>Term</code>.
*/
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
}
/**

9
lucene/src/java/org/apache/lucene/search/function/CustomScoreQuery.java
View File

@ -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;

8
lucene/src/java/org/apache/lucene/search/function/ValueSourceQuery.java
View File

@ -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.

3
lucene/src/java/org/apache/lucene/search/payloads/PayloadNearQuery.java
View File

@ -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);

5
lucene/src/java/org/apache/lucene/search/payloads/PayloadTermQuery.java
View File

@ -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

1
lucene/src/java/org/apache/lucene/search/spans/FieldMaskingSpanQuery.java
View File

@ -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;
/**

14
lucene/src/java/org/apache/lucene/search/spans/SpanScorer.java
View File

@ -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;

4
lucene/src/test/org/apache/lucene/search/JustCompileSearch.java
View File

@ -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

7
lucene/src/test/org/apache/lucene/search/TestBooleanScorer.java
View File

@ -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());

20
lucene/src/test/org/apache/lucene/search/TestPositiveScoresOnlyCollector.java
View File

@ -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<ScoreDoc> 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();
}
}

22
lucene/src/test/org/apache/lucene/search/TestScoreCachingWrappingScorer.java
View File

@ -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();
}
}

6
solr/src/java/org/apache/solr/schema/LatLonType.java
View File

@ -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;

8
solr/src/java/org/apache/solr/search/SolrConstantScoreQuery.java
View File

@ -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) {

6
solr/src/java/org/apache/solr/search/function/BoostedQuery.java
View File

@ -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;

6
solr/src/java/org/apache/solr/search/function/FunctionQuery.java
View File

@ -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;