Examples of org.apache.lucene.search.Scorer

org.apache.lucene.search.Scorer
Expert: Common scoring functionality for different types of queries.
A Scorer iterates over documents matching a query in increasing order of doc Id.

Document scores are computed using a given Similarity implementation.

NOTE: The values Float.Nan, Float.NEGATIVE_INFINITY and Float.POSITIVE_INFINITY are not valid scores. Certain collectors (eg {@link TopScoreDocCollector}) will not properly collect hits with these scores.

    @Override
    public Scorer scorer(AtomicReaderContext readerContext, boolean scoreDocsInOrder,
        boolean topScorer, Bits acceptDocs) throws IOException {


      // Pass scoreDocsInOrder true, topScorer false to our sub and the live docs:
      final Scorer childScorer = childWeight.scorer(readerContext, true, false, readerContext.reader().getLiveDocs());


      if (childScorer == null) {
        // No matches
        return null;
      }


      final int firstChildDoc = childScorer.nextDoc();
      if (firstChildDoc == DocIdSetIterator.NO_MORE_DOCS) {
        // No matches
        return null;
      }

View Full Code Here

    @Override
    public Scorer scorer(AtomicReaderContext readerContext, boolean scoreDocsInOrder,
        boolean topScorer, Bits acceptDocs) throws IOException {


      // Pass scoreDocsInOrder true, topScorer false to our sub:
      final Scorer parentScorer = parentWeight.scorer(readerContext, true, false, null);


      if (parentScorer == null) {
        // No matches
        return null;
      }

View Full Code Here

    }


    @Override
    public Scorer scorer(IndexReader reader, boolean scoreDocsInOrder, boolean topScorer) throws IOException
    {
      Scorer innerScorer = _innerWeight.scorer(reader, scoreDocsInOrder, topScorer);
      return _scorerBuilder.createScorer(innerScorer, reader, scoreDocsInOrder, topScorer);
    }

View Full Code Here

        int docStart = start + _docStarts[i];
      collector.setNextReader(_subReaders[i], docStart);
      validator.setNextReader(_subReaders[i], docStart);
      
      
      Scorer scorer = weight.scorer(_subReaders[i], true, true);
      if (scorer != null) {
        
      collector.setScorer(scorer);
        target = scorer.nextDoc();
        while(target!=DocIdSetIterator.NO_MORE_DOCS)
        {
          if(validator.validate(target))
          {
            collector.collect(target);
            target = scorer.nextDoc();
          }
          else
          {
            target = validator._nextTarget;
            target = scorer.advance(target);
          }
        }
      }
      if (mapReduceWrapper != null) {
        mapReduceWrapper.mapFullIndexReader(_subReaders[i], validator.getCountCollectors());
      }
      }
      return;
    }


    for (int i = 0; i < _subReaders.length; i++) {
      DocIdSet filterDocIdSet = filter.getDocIdSet(_subReaders[i]);
      if (filterDocIdSet == null) return;  //shall we use return or continue here ??
      int docStart = start + _docStarts[i];
      collector.setNextReader(_subReaders[i], docStart);
      validator.setNextReader(_subReaders[i], docStart);
      Scorer scorer = weight.scorer(_subReaders[i], true, false);
      if (scorer!=null){
        collector.setScorer(scorer);
        DocIdSetIterator filterDocIdIterator = filterDocIdSet.iterator(); // CHECKME: use ConjunctionScorer here?


        if(filterDocIdIterator == null)
          continue;
        
        int doc = -1;
        target = filterDocIdIterator.nextDoc();
        if (mapReduceWrapper == null) {
          while (target < DocIdSetIterator.NO_MORE_DOCS) {
            if (doc < target) {
              doc = scorer.advance(target);
            }


            if (doc == target) // permitted by filter
            {
              if (validator.validate(doc)) {
                collector.collect(doc);


                target = filterDocIdIterator.nextDoc();
              } else {
                // skip to the next possible docid
                target = filterDocIdIterator.advance(validator._nextTarget);
              }
            } else // doc > target
            {
              if (doc == DocIdSetIterator.NO_MORE_DOCS)
                break;
              target = filterDocIdIterator.advance(doc);
            }
          }
        } else {
        //MapReduce wrapper is not null
        while (target < DocIdSetIterator.NO_MORE_DOCS) {
          if (doc < target) {
            doc = scorer.advance(target);
          }


          if (doc == target) // permitted by filter
          {
            if (validator.validate(doc)) {

View Full Code Here

            starts[i] = maxDoc;
            maxDoc += readers[i].maxDoc();
         }


         starts[readers.length] = maxDoc;
         Scorer scorers[] = new Scorer[readers.length];
         for (int i = 0; i < readers.length; i++)
            scorers[i] = scorer(readers[i]);


         return new MultiScorer(searcher.getSimilarity(), scorers, starts);
      }

View Full Code Here

                starts[i] = maxDoc;
                maxDoc += readers[i].maxDoc();
            }


            starts[readers.length] = maxDoc;
            Scorer scorers[] = new Scorer[readers.length];
            for (int i = 0; i < readers.length; i++)
                scorers[i] = scorer(readers[i]);


            return new MultiScorer(searcher.getSimilarity(), scorers, starts);
        } else {

View Full Code Here

        int docStart = start + _docStarts[i];
      collector.setNextReader(_subReaders[i], docStart);
      validator.setNextReader(_subReaders[i], docStart);
    
      
      Scorer scorer = weight.scorer(_subReaders[i], true, true);
      if (scorer != null) {
        collector.setScorer(scorer);
        target = scorer.nextDoc();
        while(target!=DocIdSetIterator.NO_MORE_DOCS)
        {
          if(validator.validate(target))
          {
            collector.collect(target);
            target = scorer.nextDoc();
          }
          else
          {
            target = validator._nextTarget;
            target = scorer.advance(target);
          }
        }
      }
      }
      return;
    }


    for (int i = 0; i < _subReaders.length; i++) {
      DocIdSet filterDocIdSet = filter.getDocIdSet(_subReaders[i]);
      if (filterDocIdSet == null) return;  //shall we use return or continue here ??
      int docStart = start + _docStarts[i];
      collector.setNextReader(_subReaders[i], docStart);
      validator.setNextReader(_subReaders[i], docStart);
      Scorer scorer = weight.scorer(_subReaders[i], true, false);
      if (scorer!=null){
        collector.setScorer(scorer);
        DocIdSetIterator filterDocIdIterator = filterDocIdSet.iterator(); // CHECKME: use ConjunctionScorer here?


        if(filterDocIdIterator == null)
          continue;
        
        int doc = -1;
        target = filterDocIdIterator.nextDoc();
        while(target < DocIdSetIterator.NO_MORE_DOCS)
        {
          if(doc < target)
          {
            doc = scorer.advance(target);
          }


          if(doc == target) // permitted by filter
          {
            if(validator.validate(doc))

View Full Code Here

    @Override
    public Scorer scorer(AtomicReaderContext readerContext, boolean scoreDocsInOrder,
        boolean topScorer, Bits acceptDocs) throws IOException {


      // Pass scoreDocsInOrder true, topScorer false to our sub and the live docs:
      final Scorer childScorer = childWeight.scorer(readerContext, true, false, readerContext.reader().getLiveDocs());


      if (childScorer == null) {
        // No matches
        return null;
      }


      final int firstChildDoc = childScorer.nextDoc();
      if (firstChildDoc == DocIdSetIterator.NO_MORE_DOCS) {
        // No matches
        return null;
      }

View Full Code Here

        // Sort drill-downs by most restrictive first:
        Arrays.sort(dims);


        // TODO: it could be better if we take acceptDocs
        // into account instead of baseScorer?
        Scorer baseScorer = baseWeight.scorer(context, scoreDocsInOrder, false, acceptDocs);


        if (baseScorer == null) {
          return null;
        }

View Full Code Here

      }
    }


    /*(non-Javadoc) @see org.apache.lucene.search.Weight#scorer(org.apache.lucene.index.IndexReader) */
    public Scorer scorer(IndexReader reader) throws IOException {
      Scorer subQueryScorer = subQueryWeight.scorer(reader);
      Scorer[] valSrcScorers = new Scorer[valSrcWeights.length];
      for(int i = 0; i < valSrcScorers.length; i++) {
         valSrcScorers[i] = valSrcWeights[i].scorer(reader);
      }
      return new CustomScorer(similarity, reader, this, subQueryScorer, valSrcScorers);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.lucene.search.Scorer

com.browseengine.bobo.query.RecencyBoostScorerBuilder

com.browseengine.bobo.query.ScoreAdjusterQuery$ScoreAdjusterWeight

com.browseengine.bobo.search.BoboSearcher

com.browseengine.bobo.search.BoboSearcher2

com.browseengine.bobo.test.section.TestSectionSearch

com.browseengine.solr.BoboFacetComponent

com.greplin.lucene.query.PredicateQuery

com.senseidb.search.query.AbstractScoreAdjuster$ScoreAdjusterWeight

org.apache.blur.lucene.search.FacetExecutor$Info

org.apache.blur.lucene.search.FacetQuery$FacetScorer

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.