Property changes on: . ___________________________________________________________________ Modified: svn:mergeinfo Merged /lucene/dev/trunk:r1136568,1136605,1136644 Property changes on: lucene ___________________________________________________________________ Modified: svn:mergeinfo Merged /lucene/dev/trunk/lucene:r1136568,1136605,1136644 Property changes on: lucene\backwards ___________________________________________________________________ Modified: svn:mergeinfo Merged /lucene/dev/trunk/lucene/backwards:r1136568,1136605,1136644 Property changes on: lucene\backwards\src\test ___________________________________________________________________ Modified: svn:mergeinfo Merged /lucene/dev/trunk/lucene/backwards/src/test:r1136568,1136605,1136644 Property changes on: lucene\backwards\src\test-framework ___________________________________________________________________ Modified: svn:mergeinfo Merged /lucene/dev/trunk/lucene/backwards/src/test-framework:r1136568,1136605,1136644 Index: lucene/CHANGES.txt =================================================================== --- lucene/CHANGES.txt (revision 1136568) +++ lucene/CHANGES.txt (working copy) @@ -15,6 +15,11 @@ Comparable; FieldDoc.fields also changed from Comparable[] to Object[] (Uwe Schindler, Mike McCandless) +* LUCENE-3208: Made deprecated methods Query.weight(Searcher) and + Searcher.createWeight() final to prevent override. If you have + overridden one of these methods, cut over to the non-deprecated + implementation. (Uwe Schindler, Robert Muir, Yonik Seeley) + Changes in runtime behavior * LUCENE-2834: the hash used to compute the lock file name when the @@ -53,6 +58,15 @@ ArrayIndexOutOfBoundsException (selckin, Robert Muir, Mike McCandless) +API Changes + +* LUCENE-3208: Renamed protected IndexSearcher.createWeight() to expert + public method IndexSearcher.createNormalizedWeight() as this better describes + what this method does. The old method is still there for backwards + compatibility. Query.weight() was deprecated and simply delegates to + IndexSearcher. Both deprecated methods will be removed in Lucene 4.0. + (Uwe Schindler, Robert Muir, Yonik Seeley) + Optimizations * LUCENE-1736: DateTools.java general improvements. Index: lucene/contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/ReadTask.java =================================================================== --- lucene/contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/ReadTask.java (revision 1136568) +++ lucene/contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/ReadTask.java (working copy) @@ -112,7 +112,7 @@ if (numHits > 0) { if (withCollector() == false) { if (sort != null) { - Weight w = q.weight(searcher); + Weight w = searcher.createNormalizedWeight(q); TopFieldCollector collector = TopFieldCollector.create(sort, numHits, true, withScore(), withMaxScore(), Index: lucene/contrib/grouping/src/test/org/apache/lucene/search/grouping/TestGrouping.java =================================================================== --- lucene/contrib/grouping/src/test/org/apache/lucene/search/grouping/TestGrouping.java (revision 1136568) +++ lucene/contrib/grouping/src/test/org/apache/lucene/search/grouping/TestGrouping.java (working copy) @@ -908,7 +908,7 @@ System.out.println("TEST: " + shardState.subSearchers.length + " shards: " + Arrays.toString(shardState.subSearchers)); } // Run 1st pass collector to get top groups per shard - final Weight w = query.weight(topSearcher); + final Weight w = topSearcher.createNormalizedWeight(query); final List>> shardGroups = new ArrayList>>(); for(int shardIDX=0;shardIDX queriesIter, SegmentReader reader) throws IOException { long delCount = 0; - IndexSearcher searcher = new IndexSearcher(reader); - try { - for (QueryAndLimit ent : queriesIter) { - Query query = ent.query; - int limit = ent.limit; - Weight weight = query.weight(searcher); - Scorer scorer = weight.scorer(reader, true, false); - if (scorer != null) { + + for (QueryAndLimit ent : queriesIter) { + Query query = ent.query; + int limit = ent.limit; + final DocIdSet docs = new QueryWrapperFilter(query).getDocIdSet(reader); + if (docs != null) { + final DocIdSetIterator it = docs.iterator(); + if (it != null) { while(true) { - int doc = scorer.nextDoc(); + int doc = it.nextDoc(); if (doc >= limit) break; @@ -400,8 +400,6 @@ } } } - } finally { - searcher.close(); } return delCount; Index: lucene/src/java/org/apache/lucene/search/function/CustomScoreQuery.java =================================================================== --- lucene/src/java/org/apache/lucene/search/function/CustomScoreQuery.java (revision 1136568) +++ lucene/src/java/org/apache/lucene/search/function/CustomScoreQuery.java (working copy) @@ -189,7 +189,7 @@ public CustomWeight(Searcher searcher) throws IOException { this.similarity = getSimilarity(searcher); - this.subQueryWeight = subQuery.weight(searcher); + this.subQueryWeight = subQuery.createWeight(searcher); this.valSrcWeights = new Weight[valSrcQueries.length]; for(int i = 0; i < valSrcQueries.length; i++) { this.valSrcWeights[i] = valSrcQueries[i].createWeight(searcher); Index: lucene/src/java/org/apache/lucene/search/IndexSearcher.java =================================================================== --- lucene/src/java/org/apache/lucene/search/IndexSearcher.java (revision 1136568) +++ lucene/src/java/org/apache/lucene/search/IndexSearcher.java (working copy) @@ -79,9 +79,6 @@ private final ExecutorService executor; protected final IndexSearcher[] subSearchers; - /** The Similarity implementation used by this searcher. */ - private Similarity similarity = Similarity.getDefault(); - /** Creates a searcher searching the index in the named * directory, with readOnly=true * @param path directory where IndexReader will be opened @@ -257,12 +254,12 @@ */ @Override public void setSimilarity(Similarity similarity) { - this.similarity = similarity; + super.setSimilarity(similarity); } @Override public Similarity getSimilarity() { - return similarity; + return super.getSimilarity(); } /** @@ -298,7 +295,7 @@ @Override public TopDocs search(Query query, Filter filter, int n) throws IOException { - return search(createWeight(query), filter, n); + return search(createNormalizedWeight(query), filter, n); } /** Lower-level search API. @@ -320,7 +317,7 @@ @Override public void search(Query query, Filter filter, Collector results) throws IOException { - search(createWeight(query), filter, results); + search(createNormalizedWeight(query), filter, results); } /** Lower-level search API. @@ -339,7 +336,7 @@ @Override public void search(Query query, Collector results) throws IOException { - search(createWeight(query), null, results); + search(createNormalizedWeight(query), null, results); } /** Search implementation with arbitrary sorting. Finds @@ -356,7 +353,7 @@ @Override public TopFieldDocs search(Query query, Filter filter, int n, Sort sort) throws IOException { - return search(createWeight(query), filter, n, sort); + return search(createNormalizedWeight(query), filter, n, sort); } /** @@ -370,7 +367,7 @@ @Override public TopFieldDocs search(Query query, int n, Sort sort) throws IOException { - return search(createWeight(query), null, n, sort); + return search(createNormalizedWeight(query), null, n, sort); } /** Expert: Low-level search implementation. Finds the top n @@ -606,7 +603,7 @@ */ @Override public Explanation explain(Query query, int doc) throws IOException { - return explain(createWeight(query), doc); + return explain(createNormalizedWeight(query), doc); } /** Expert: low-level implementation method @@ -654,15 +651,16 @@ } /** - * creates a weight for query - * @return new weight + * Creates a normalized weight for a top-level {@link Query}. + * The query is rewritten by this method and {@link Query#createWeight} called, + * afterwards the {@link Weight} is normalized. The returned {@code Weight} + * can then directly be used to get a {@link Scorer}. + * @lucene.internal */ - @Override - protected Weight createWeight(Query query) throws IOException { - return query.weight(this); + public Weight createNormalizedWeight(Query query) throws IOException { + return super.createNormalizedWeight(query); } - /** * A thread subclass for searching a single searchable */ Index: lucene/src/java/org/apache/lucene/search/MultiSearcher.java =================================================================== --- lucene/src/java/org/apache/lucene/search/MultiSearcher.java (revision 1136568) +++ lucene/src/java/org/apache/lucene/search/MultiSearcher.java (working copy) @@ -310,7 +310,7 @@ * @return rewritten queries */ @Override - protected Weight createWeight(Query original) throws IOException { + public Weight createNormalizedWeight(Query original) throws IOException { // step 1 final Query rewrittenQuery = rewrite(original); @@ -325,7 +325,7 @@ final int numDocs = maxDoc(); final CachedDfSource cacheSim = new CachedDfSource(dfMap, numDocs, getSimilarity()); - return rewrittenQuery.weight(cacheSim); + return cacheSim.createNormalizedWeight(rewrittenQuery); } /** * Collects the document frequency for the given terms form all searchables Index: lucene/src/java/org/apache/lucene/search/Query.java =================================================================== --- lucene/src/java/org/apache/lucene/search/Query.java (revision 1136568) +++ lucene/src/java/org/apache/lucene/search/Query.java (working copy) @@ -94,17 +94,13 @@ } /** - * Expert: Constructs and initializes a Weight for a top-level query. + * Expert: Constructs and initializes a Weight for a top-level query. + * @deprecated never ever use this method in {@link Weight} implementations. + * Subclasses of {@code Query} should use {@link #createWeight}, instead. */ - public Weight weight(Searcher searcher) throws IOException { - Query query = searcher.rewrite(this); - Weight weight = query.createWeight(searcher); - float sum = weight.sumOfSquaredWeights(); - float norm = getSimilarity(searcher).queryNorm(sum); - if (Float.isInfinite(norm) || Float.isNaN(norm)) - norm = 1.0f; - weight.normalize(norm); - return weight; + @Deprecated + public final Weight weight(Searcher searcher) throws IOException { + return searcher.createNormalizedWeight(this); } Index: lucene/src/java/org/apache/lucene/search/QueryWrapperFilter.java =================================================================== --- lucene/src/java/org/apache/lucene/search/QueryWrapperFilter.java (revision 1136568) +++ lucene/src/java/org/apache/lucene/search/QueryWrapperFilter.java (working copy) @@ -44,7 +44,7 @@ @Override public DocIdSet getDocIdSet(final IndexReader reader) throws IOException { - final Weight weight = query.weight(new IndexSearcher(reader)); + final Weight weight = new IndexSearcher(reader).createNormalizedWeight(query); return new DocIdSet() { @Override public DocIdSetIterator iterator() throws IOException { Index: lucene/src/java/org/apache/lucene/search/Searcher.java =================================================================== --- lucene/src/java/org/apache/lucene/search/Searcher.java (revision 1136568) +++ lucene/src/java/org/apache/lucene/search/Searcher.java (working copy) @@ -50,7 +50,7 @@ */ public TopFieldDocs search(Query query, Filter filter, int n, Sort sort) throws IOException { - return search(createWeight(query), filter, n, sort); + return search(createNormalizedWeight(query), filter, n, sort); } /** @@ -63,7 +63,7 @@ */ public TopFieldDocs search(Query query, int n, Sort sort) throws IOException { - return search(createWeight(query), null, n, sort); + return search(createNormalizedWeight(query), null, n, sort); } /** Lower-level search API. @@ -81,7 +81,7 @@ */ public void search(Query query, Collector results) throws IOException { - search(createWeight(query), null, results); + search(createNormalizedWeight(query), null, results); } /** Lower-level search API. @@ -102,7 +102,7 @@ */ public void search(Query query, Filter filter, Collector results) throws IOException { - search(createWeight(query), filter, results); + search(createNormalizedWeight(query), filter, results); } /** Finds the top n @@ -112,7 +112,7 @@ */ public TopDocs search(Query query, Filter filter, int n) throws IOException { - return search(createWeight(query), filter, n); + return search(createNormalizedWeight(query), filter, n); } /** Finds the top n @@ -134,7 +134,7 @@ * entire index. */ public Explanation explain(Query query, int doc) throws IOException { - return explain(createWeight(query), doc); + return explain(createNormalizedWeight(query), doc); } /** The Similarity implementation used by this searcher. */ @@ -157,12 +157,36 @@ } /** - * creates a weight for query - * @return new weight + * Creates a normalized weight for a top-level {@link Query}. + * The query is rewritten by this method and {@link Query#createWeight} called, + * afterwards the {@link Weight} is normalized. The returned {@code Weight} + * can then directly be used to get a {@link Scorer}. + * @lucene.internal */ - protected Weight createWeight(Query query) throws IOException { - return query.weight(this); + public Weight createNormalizedWeight(Query query) throws IOException { + query = rewrite(query); + Weight weight = query.createWeight(this); + float sum = weight.sumOfSquaredWeights(); + // this is a hack for backwards compatibility: + float norm = query.getSimilarity(this).queryNorm(sum); + if (Float.isInfinite(norm) || Float.isNaN(norm)) + norm = 1.0f; + weight.normalize(norm); + return weight; } + + /** + * Expert: Creates a normalized weight for a top-level {@link Query}. + * The query is rewritten by this method and {@link Query#createWeight} called, + * afterwards the {@link Weight} is normalized. The returned {@code Weight} + * can then directly be used to get a {@link Scorer}. + * @deprecated never ever use this method in {@link Weight} implementations. + * Subclasses of Searcher should use {@link #createNormalizedWeight}, instead. + */ + @Deprecated + protected final Weight createWeight(Query query) throws IOException { + return createNormalizedWeight(query); + } // inherit javadoc public int[] docFreqs(Term[] terms) throws IOException { Index: lucene/src/java/org/apache/lucene/search/spans/FieldMaskingSpanQuery.java =================================================================== --- lucene/src/java/org/apache/lucene/search/spans/FieldMaskingSpanQuery.java (revision 1136568) +++ lucene/src/java/org/apache/lucene/search/spans/FieldMaskingSpanQuery.java (working copy) @@ -107,11 +107,6 @@ } @Override - public Similarity getSimilarity(Searcher searcher) { - return maskedQuery.getSimilarity(searcher); - } - - @Override public Query rewrite(IndexReader reader) throws IOException { FieldMaskingSpanQuery clone = null; Index: lucene/src/test-framework/org/apache/lucene/search/AssertingIndexSearcher.java =================================================================== --- lucene/src/test-framework/org/apache/lucene/search/AssertingIndexSearcher.java (revision 1136568) +++ lucene/src/test-framework/org/apache/lucene/search/AssertingIndexSearcher.java (working copy) @@ -21,8 +21,6 @@ import java.io.IOException; import org.apache.lucene.index.IndexReader; -import org.apache.lucene.index.IndexReader.AtomicReaderContext; -import org.apache.lucene.index.IndexReader.ReaderContext; /** * Helper class that adds some extra checks to ensure correct @@ -34,57 +32,58 @@ super(r); } - public AssertingIndexSearcher(ReaderContext context) { - super(context); - } - public AssertingIndexSearcher(IndexReader r, ExecutorService ex) { super(r, ex); } - public AssertingIndexSearcher(ReaderContext context, ExecutorService ex) { - super(context, ex); - } + // not anonymous because else not serializable (compare trunk) + private static final class UnmodifiableWeight extends Weight { + private final Weight w; + + UnmodifiableWeight(Weight w) { + this.w = w; + } - /** Ensures, that the returned {@code Weight} is not normalized again, which may produce wrong scores. */ - @Override - public Weight createNormalizedWeight(Query query) throws IOException { - final Weight w = super.createNormalizedWeight(query); - return new Weight() { - @Override - public Explanation explain(AtomicReaderContext context, int doc) throws IOException { - return w.explain(context, doc); - } + @Override + public Explanation explain(IndexReader reader, int doc) throws IOException { + return w.explain(reader, doc); + } - @Override - public Query getQuery() { - return w.getQuery(); - } + @Override + public Query getQuery() { + return w.getQuery(); + } - @Override - public float getValue() { - return w.getValue(); - } + @Override + public float getValue() { + return w.getValue(); + } - @Override - public void normalize(float norm) { - throw new IllegalStateException("Weight already normalized."); - } + @Override + public void normalize(float norm) { + throw new IllegalStateException("Weight already normalized."); + } - @Override - public Scorer scorer(AtomicReaderContext context, ScorerContext scorerContext) throws IOException { - return w.scorer(context, scorerContext); - } + @Override + public Scorer scorer(IndexReader reader, boolean scoreDocsInOrder, boolean topScorer) throws IOException { + return w.scorer(reader, scoreDocsInOrder, topScorer); + } - @Override - public float sumOfSquaredWeights() throws IOException { - throw new IllegalStateException("Weight already normalized."); - } + @Override + public float sumOfSquaredWeights() throws IOException { + throw new IllegalStateException("Weight already normalized."); + } - @Override - public boolean scoresDocsOutOfOrder() { - return w.scoresDocsOutOfOrder(); - } - }; + @Override + public boolean scoresDocsOutOfOrder() { + return w.scoresDocsOutOfOrder(); + } } + + /** Ensures, that the returned {@code Weight} is not normalized again, which may produce wrong scores. */ + @Override + public Weight createNormalizedWeight(Query query) throws IOException { + final Weight w = super.createNormalizedWeight(query); + return new UnmodifiableWeight(w); + } } Index: lucene/src/test-framework/org/apache/lucene/search/QueryUtils.java =================================================================== --- lucene/src/test-framework/org/apache/lucene/search/QueryUtils.java (revision 1136568) +++ lucene/src/test-framework/org/apache/lucene/search/QueryUtils.java (working copy) @@ -241,7 +241,7 @@ * @throws IOException if serialization check fail. */ private static void checkSerialization(Query q, Searcher s) throws IOException { - Weight w = q.weight(s); + Weight w = s.createNormalizedWeight(q); try { ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos); @@ -268,7 +268,7 @@ public static void checkSkipTo(final Query q, final IndexSearcher s) throws IOException { //System.out.println("Checking "+q); - if (q.weight(s).scoresDocsOutOfOrder()) return; // in this case order of skipTo() might differ from that of next(). + if (s.createNormalizedWeight(q).scoresDocsOutOfOrder()) return; // in this case order of skipTo() might differ from that of next(). final int skip_op = 0; final int next_op = 1; @@ -311,7 +311,7 @@ lastDoc[0] = doc; try { if (scorer == null) { - Weight w = q.weight(s); + Weight w = s.createNormalizedWeight(q); scorer = w.scorer(reader, true, false); } @@ -355,7 +355,7 @@ // previous reader, hits NO_MORE_DOCS if (lastReader[0] != null) { final IndexReader previousReader = lastReader[0]; - Weight w = q.weight(new IndexSearcher(previousReader)); + Weight w = new IndexSearcher(previousReader).createNormalizedWeight(q); Scorer scorer = w.scorer(previousReader, true, false); if (scorer != null) { boolean more = scorer.advance(lastDoc[0] + 1) != DocIdSetIterator.NO_MORE_DOCS; @@ -377,7 +377,7 @@ // confirm that skipping beyond the last doc, on the // previous reader, hits NO_MORE_DOCS final IndexReader previousReader = lastReader[0]; - Weight w = q.weight(new IndexSearcher(previousReader)); + Weight w = new IndexSearcher(previousReader).createNormalizedWeight(q); Scorer scorer = w.scorer(previousReader, true, false); if (scorer != null) { boolean more = scorer.advance(lastDoc[0] + 1) != DocIdSetIterator.NO_MORE_DOCS; @@ -408,7 +408,7 @@ try { for (int i=lastDoc[0]+1; i<=doc; i++) { - Weight w = q.weight(s); + Weight w = s.createNormalizedWeight(q); Scorer scorer = w.scorer(reader, true, false); Assert.assertTrue("query collected "+doc+" but skipTo("+i+") says no more docs!",scorer.advance(i) != DocIdSetIterator.NO_MORE_DOCS); Assert.assertEquals("query collected "+doc+" but skipTo("+i+") got to "+scorer.docID(),doc,scorer.docID()); @@ -428,8 +428,9 @@ // previous reader, hits NO_MORE_DOCS if (lastReader[0] != null) { final IndexReader previousReader = lastReader[0]; - Weight w = q.weight(new IndexSearcher(previousReader)); + Weight w = new IndexSearcher(previousReader).createNormalizedWeight(q); Scorer scorer = w.scorer(previousReader, true, false); + if (scorer != null) { boolean more = scorer.advance(lastDoc[0] + 1) != DocIdSetIterator.NO_MORE_DOCS; Assert.assertFalse("query's last doc was "+ lastDoc[0] +" but skipTo("+(lastDoc[0]+1)+") got to "+scorer.docID(),more); @@ -449,7 +450,7 @@ // confirm that skipping beyond the last doc, on the // previous reader, hits NO_MORE_DOCS final IndexReader previousReader = lastReader[0]; - Weight w = q.weight(new IndexSearcher(previousReader)); + Weight w = new IndexSearcher(previousReader).createNormalizedWeight(q); Scorer scorer = w.scorer(previousReader, true, false); if (scorer != null) { boolean more = scorer.advance(lastDoc[0] + 1) != DocIdSetIterator.NO_MORE_DOCS; Index: lucene/src/test-framework/org/apache/lucene/util/LuceneTestCase.java =================================================================== --- lucene/src/test-framework/org/apache/lucene/util/LuceneTestCase.java (revision 1136568) +++ lucene/src/test-framework/org/apache/lucene/util/LuceneTestCase.java (working copy) @@ -49,6 +49,7 @@ import org.apache.lucene.index.TieredMergePolicy; import org.apache.lucene.search.BooleanQuery; import org.apache.lucene.search.FieldCache.CacheEntry; +import org.apache.lucene.search.AssertingIndexSearcher; import org.apache.lucene.search.FieldCache; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.store.Directory; @@ -1097,13 +1098,11 @@ * with one that returns null for getSequentialSubReaders. */ public static IndexSearcher newSearcher(IndexReader r, boolean maybeWrap) throws IOException { - if (random.nextBoolean()) { if (maybeWrap && rarely()) { - return new IndexSearcher(new SlowMultiReaderWrapper(r)); - } else { - return new IndexSearcher(r); + r = new SlowMultiReaderWrapper(r); } + return new AssertingIndexSearcher(r); } else { int threads = 0; final ExecutorService ex = (random.nextBoolean()) ? null @@ -1112,22 +1111,26 @@ if (ex != null && VERBOSE) { System.out.println("NOTE: newSearcher using ExecutorService with " + threads + " threads"); } - return new IndexSearcher(r, ex) { + return new AssertingIndexSearcher(r, ex) { @Override public void close() throws IOException { super.close(); - if (ex != null) { - ex.shutdown(); - try { - ex.awaitTermination(1000, TimeUnit.MILLISECONDS); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } + shutdownExecutorService(ex); } }; } } + + static void shutdownExecutorService(ExecutorService ex) { + if (ex != null) { + ex.shutdown(); + try { + ex.awaitTermination(1000, TimeUnit.MILLISECONDS); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } public String getName() { return this.name; Index: lucene/src/test/org/apache/lucene/search/JustCompileSearch.java =================================================================== --- lucene/src/test/org/apache/lucene/search/JustCompileSearch.java (revision 1136568) +++ lucene/src/test/org/apache/lucene/search/JustCompileSearch.java (working copy) @@ -41,7 +41,7 @@ static final class JustCompileSearcher extends Searcher { @Override - protected Weight createWeight(Query query) throws IOException { + public Weight createNormalizedWeight(Query query) throws IOException { throw new UnsupportedOperationException(UNSUPPORTED_MSG); } Index: lucene/src/test/org/apache/lucene/search/spans/TestNearSpansOrdered.java =================================================================== --- lucene/src/test/org/apache/lucene/search/spans/TestNearSpansOrdered.java (revision 1136568) +++ lucene/src/test/org/apache/lucene/search/spans/TestNearSpansOrdered.java (working copy) @@ -167,17 +167,18 @@ */ public void testSpanNearScorerSkipTo1() throws Exception { SpanNearQuery q = makeQuery(); - Weight w = q.weight(searcher); + Weight w = searcher.createNormalizedWeight(q); Scorer s = w.scorer(searcher.getIndexReader(), true, false); assertEquals(1, s.advance(1)); } + /** * not a direct test of NearSpans, but a demonstration of how/when * this causes problems */ public void testSpanNearScorerExplain() throws Exception { SpanNearQuery q = makeQuery(); - Explanation e = q.weight(searcher).explain(searcher.getIndexReader(), 1); + Explanation e = searcher.explain(q, 1); assertTrue("Scorer explanation value for doc#1 isn't positive: " + e.toString(), 0.0f < e.getValue()); Index: lucene/src/test/org/apache/lucene/search/spans/TestSpans.java =================================================================== --- lucene/src/test/org/apache/lucene/search/spans/TestSpans.java (revision 1136568) +++ lucene/src/test/org/apache/lucene/search/spans/TestSpans.java (working copy) @@ -420,7 +420,7 @@ } }; - Scorer spanScorer = snq.weight(searcher).scorer(searcher.getIndexReader(), true, false); + Scorer spanScorer = searcher.createNormalizedWeight(snq).scorer(searcher.getIndexReader(), true, false); assertTrue("first doc", spanScorer.nextDoc() != DocIdSetIterator.NO_MORE_DOCS); assertEquals("first doc number", spanScorer.docID(), 11); Index: lucene/src/test/org/apache/lucene/search/TestDisjunctionMaxQuery.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestDisjunctionMaxQuery.java (revision 1136568) +++ lucene/src/test/org/apache/lucene/search/TestDisjunctionMaxQuery.java (working copy) @@ -167,7 +167,7 @@ QueryUtils.check(random, dq, s); - final Weight dw = dq.weight(s); + final Weight dw = s.createNormalizedWeight(dq); IndexReader sub = s.getIndexReader().getSequentialSubReaders() == null ? s.getIndexReader() : s.getIndexReader().getSequentialSubReaders()[0]; final Scorer ds = dw.scorer(sub, true, false); @@ -184,8 +184,8 @@ dq.add(tq("dek", "DOES_NOT_EXIST")); QueryUtils.check(random, dq, s); - - final Weight dw = dq.weight(s); + + final Weight dw = s.createNormalizedWeight(dq); IndexReader sub = s.getIndexReader().getSequentialSubReaders() == null ? s.getIndexReader() : s.getIndexReader().getSequentialSubReaders()[0]; final Scorer ds = dw.scorer(sub, true, false); Index: lucene/src/test/org/apache/lucene/search/TestTermScorer.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestTermScorer.java (revision 1136568) +++ lucene/src/test/org/apache/lucene/search/TestTermScorer.java (working copy) @@ -71,7 +71,7 @@ Term allTerm = new Term(FIELD, "all"); TermQuery termQuery = new TermQuery(allTerm); - Weight weight = termQuery.weight(indexSearcher); + Weight weight = indexSearcher.createNormalizedWeight(termQuery); IndexReader sub = indexSearcher.getIndexReader().getSequentialSubReaders() == null ? indexSearcher.getIndexReader() : indexSearcher.getIndexReader().getSequentialSubReaders()[0]; Scorer ts = weight.scorer(sub, true, true); @@ -133,7 +133,7 @@ Term allTerm = new Term(FIELD, "all"); TermQuery termQuery = new TermQuery(allTerm); - Weight weight = termQuery.weight(indexSearcher); + Weight weight = indexSearcher.createNormalizedWeight(termQuery); IndexReader sub = indexSearcher.getIndexReader().getSequentialSubReaders() == null ? indexSearcher.getIndexReader() : indexSearcher.getIndexReader().getSequentialSubReaders()[0]; @@ -153,7 +153,7 @@ Term allTerm = new Term(FIELD, "all"); TermQuery termQuery = new TermQuery(allTerm); - Weight weight = termQuery.weight(indexSearcher); + Weight weight = indexSearcher.createNormalizedWeight(termQuery); IndexReader sub = indexSearcher.getIndexReader().getSequentialSubReaders() == null ? indexSearcher.getIndexReader() : indexSearcher.getIndexReader().getSequentialSubReaders()[0]; Index: lucene/src/test/org/apache/lucene/search/TestTopDocsMerge.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestTopDocsMerge.java (revision 1136568) +++ lucene/src/test/org/apache/lucene/search/TestTopDocsMerge.java (working copy) @@ -191,7 +191,7 @@ } // ... then all shards: - final Weight w = query.weight(searcher); + final Weight w = searcher.createNormalizedWeight(query); final TopDocs[] shardHits = new TopDocs[subSearchers.length]; for(int shardIDX=0;shardIDX