/** * 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 * * @deprecated Clients should rewrite the query and then call {@link #createWeight(Query, boolean, float)} * with a boost value of 1f */ @Deprecated public Weight createNormalizedWeight(Query query, boolean needsScores) throws IOException { query = rewrite(query); return createWeight(query, needsScores, 1f); }
/** Lower-level search API. * * <p>{@link LeafCollector#collect(int)} is called for every matching document. * * @throws BooleanQuery.TooManyClauses If a query would exceed * {@link BooleanQuery#getMaxClauseCount()} clauses. */ public void search(Query query, Collector results) throws IOException { query = rewrite(query); search(leafContexts, createWeight(query, results.needsScores(), 1), results); }
/** Returns an Explanation that describes how <code>doc</code> scored against * <code>query</code>. * * <p>This is intended to be used in developing Similarity implementations, * and, for good performance, should not be displayed with every hit. * Computing an explanation is as expensive as executing the query over the * entire index. */ public Explanation explain(Query query, int doc) throws IOException { query = rewrite(query); return explain(createWeight(query, true, 1), doc); }
@Override public DoubleValuesSource rewrite(IndexSearcher searcher) throws IOException { return new WeightDoubleValuesSource(searcher.rewrite(query).createWeight(searcher, true, 1f)); }
private static Scorer getScorer(Query query, CodecReader reader) throws IOException { IndexSearcher s = new IndexSearcher(reader); s.setQueryCache(null); Weight weight = s.createWeight(s.rewrite(query), false, 1.0f); return weight.scorer(reader.getContext()); }
query = rewrite(query); final Weight weight = createWeight(query, needsScores, 1); final List<Future<C>> topDocsFutures = new ArrayList<>(leafSlices.length);
@Override public Weight createWeight(IndexSearcher searcher, boolean needsScores, float boost) throws IOException { if (needsScores) { return new SynonymWeight(this, searcher, boost); } else { // if scores are not needed, let BooleanWeight deal with optimizing that case. BooleanQuery.Builder bq = new BooleanQuery.Builder(); for (Term term : terms) { bq.add(new TermQuery(term), BooleanClause.Occur.SHOULD); } return searcher.rewrite(bq.build()).createWeight(searcher, needsScores, boost); } }
query = rewrite(query); while (true) {
query = searcher.rewrite(query); final Weight weight = searcher.createWeight(query, false, 1); final Scorer scorer = weight.scorer(readerContext);
Query rewritten = searcher.rewrite(query); Weight weight = searcher.createWeight(rewritten, true, 1);
final Weight weight = searcher.rewrite(q).createWeight(searcher, needsScores, score()); return new WeightOrDocIdSet(weight); } else {
final Weight weight = searcher.rewrite(q).createWeight(searcher, needsScores, score()); return new WeightOrDocIdSet(weight);
@Override public Query rewrite(Query original) throws IOException { if (profiler != null) { profiler.startRewriteTime(); } try { return in.rewrite(original); } finally { if (profiler != null) { profiler.stopAndAddRewriteTime(); } } }
@Override public Query rewrite(final Query query) throws IOException { return searcher.rewrite(query); }
static CodecReader wrapReader(String recoverySourceField, CodecReader reader, Supplier<Query> retainSourceQuerySupplier) throws IOException { NumericDocValues recoverySource = reader.getNumericDocValues(recoverySourceField); if (recoverySource == null || recoverySource.nextDoc() == DocIdSetIterator.NO_MORE_DOCS) { return reader; // early terminate - nothing to do here since non of the docs has a recovery source anymore. } BooleanQuery.Builder builder = new BooleanQuery.Builder(); builder.add(new DocValuesFieldExistsQuery(recoverySourceField), BooleanClause.Occur.FILTER); builder.add(retainSourceQuerySupplier.get(), BooleanClause.Occur.FILTER); IndexSearcher s = new IndexSearcher(reader); s.setQueryCache(null); Weight weight = s.createWeight(s.rewrite(builder.build()), false, 1.0f); Scorer scorer = weight.scorer(reader.getContext()); if (scorer != null) { return new SourcePruningFilterCodecReader(recoverySourceField, reader, BitSet.of(scorer.iterator(), reader.maxDoc())); } else { return new SourcePruningFilterCodecReader(recoverySourceField, reader, null); } }
@Override public void createWeight(Map context, IndexSearcher searcher) throws IOException { Query rewritten = searcher.rewrite(q); Weight w = searcher.createWeight(rewritten, true, 1); context.put(this, w); } }
/** Lower-level search API. * * <p>{@link LeafCollector#collect(int)} is called for every matching document. * * @throws BooleanQuery.TooManyClauses If a query would exceed * {@link BooleanQuery#getMaxClauseCount()} clauses. */ public void search(Query query, Collector results) throws IOException { query = rewrite(query); search(leafContexts, createWeight(query, results.needsScores(), 1), results); }
queryResult.size(searchContext.size()); Query query = searchContext.query(); assert query == searcher.rewrite(query); // already rewritten
@Override public DoubleValuesSource rewrite(IndexSearcher searcher) throws IOException { return new WeightDoubleValuesSource(searcher.rewrite(query).createWeight(searcher, true, 1f)); }
/** * Tests if the ConstantScore filter rewrite return an exception */ @Test(expected=UnsupportedOperationException.class) public void testFilterRewrite() throws IOException { this.addDocument("<nowildcard> <nowildcardx>"); final MultiNodeTermQuery wq = new NodeWildcardQuery(new Term(DEFAULT_TEST_FIELD, "nowildcard")); this.assertMatches(searcher, wq, 1); wq.setRewriteMethod(MultiNodeTermQuery.CONSTANT_SCORE_FILTER_REWRITE); wq.setBoost(0.2F); searcher.rewrite(wq); }