Examples of org.apache.lucene.search.TopDocsCollector

org.apache.lucene.search.TopDocsCollector
A base class for all collectors that return a {@link TopDocs} output. Thiscollector allows easy extension by providing a single constructor which accepts a {@link PriorityQueue} as well as protected members for thatpriority queue and a counter of the number of total hits.
Extending classes can override {@link #topDocs(int,int)} and{@link #getTotalHits()} in order to provide their own implementation.

    for(int downTo=groupQueue.size()-groupOffset-1;downTo>=0;downTo--) {
      final OneGroup og = groupQueue.pop();


      // At this point we hold all docs w/ in each group,
      // unsorted; we now sort them:
      final TopDocsCollector collector;
      if (withinGroupSort == null) {
        // Sort by score
        if (!needsScores) {
          throw new IllegalArgumentException("cannot sort by relevance within group: needsScores=false");
        }
        collector = TopScoreDocCollector.create(maxDocsPerGroup, true);
      } else {
        // Sort by fields
        collector = StatisticFieldCollector.create(withinGroupSort, maxDocsPerGroup, fillSortFields, needsScores, needsScores, true);
      }


      collector.setScorer(fakeScorer);
      collector.setNextReader(og.reader, og.docBase);
      for(int docIDX=0;docIDX<og.count;docIDX++) {
        final int doc = og.docs[docIDX];
        fakeScorer.doc = doc;
        if (needsScores) {
          fakeScorer.score = og.scores[docIDX];
        }
        collector.collect(doc);
      }
      totalGroupedHitCount += og.count;


      final Object[] groupSortValues;


      if (fillSortFields) {
        groupSortValues = new Comparable[comparators.length];
        for(int sortFieldIDX=0;sortFieldIDX<comparators.length;sortFieldIDX++) {
          groupSortValues[sortFieldIDX] = comparators[sortFieldIDX].value(og.comparatorSlot);
        }
      } else {
        groupSortValues = null;
      }


      final TopDocs topDocs = collector.topDocs(withinGroupOffset, maxDocsPerGroup);


      groups[downTo] = new GroupDocs<Object>(topDocs.getMaxScore(),
                                     og.count,
                                     topDocs.scoreDocs,
                                     null,

View Full Code Here

    for(int downTo=groupQueue.size()-groupOffset-1;downTo>=0;downTo--) {
      final OneGroup og = groupQueue.pop();


      // At this point we hold all docs w/ in each group,
      // unsorted; we now sort them:
      final TopDocsCollector collector;
      if (withinGroupSort == null) {
        // Sort by score
        if (!needsScores) {
          throw new IllegalArgumentException("cannot sort by relevance within group: needsScores=false");
        }
        collector = TopScoreDocCollector.create(maxDocsPerGroup, true);
      } else {
        // Sort by fields
        collector = TopFieldCollector.create(withinGroupSort, maxDocsPerGroup, fillSortFields, needsScores, needsScores, true);
      }


      collector.setScorer(fakeScorer);
      collector.setNextReader(og.reader, og.docBase);
      for(int docIDX=0;docIDX<og.count;docIDX++) {
        final int doc = og.docs[docIDX];
        fakeScorer.doc = doc;
        if (needsScores) {
          fakeScorer.score = og.scores[docIDX];
        }
        collector.collect(doc);
      }
      totalGroupedHitCount += og.count;


      final Object[] groupSortValues;


      if (fillSortFields) {
        groupSortValues = new Comparable[comparators.length];
        for(int sortFieldIDX=0;sortFieldIDX<comparators.length;sortFieldIDX++) {
          groupSortValues[sortFieldIDX] = comparators[sortFieldIDX].value(og.comparatorSlot);
        }
      } else {
        groupSortValues = null;
      }


      final TopDocs topDocs = collector.topDocs(withinGroupOffset, maxDocsPerGroup);


      groups[downTo] = new GroupDocs<Object>(topDocs.getMaxScore(),
                                     og.count,
                                     topDocs.scoreDocs,
                                     null,

View Full Code Here

    @SuppressWarnings({ "rawtypes" })
    public SearchResult call() throws Exception {
      final IndexSearcher indexSearcher = getSearcherByShard(_shardName);
      int nDocs = Math.min(_limit, indexSearcher.maxDoc());


      TopDocsCollector resultCollector;
      if (_sort != null) {
        boolean fillFields = true;// see IndexSearcher#search(...)
        boolean fieldSortDoTrackScores = false;
        boolean fieldSortDoMaxScore = false;
        resultCollector = TopFieldCollector.create(_sort, nDocs, fillFields, fieldSortDoTrackScores,
                fieldSortDoMaxScore, !_weight.scoresDocsOutOfOrder());
      } else {
        resultCollector = TopScoreDocCollector.create(nDocs, !_weight.scoresDocsOutOfOrder());
      }
      try {
        indexSearcher.search(_weight, null, wrapInTimeoutCollector(resultCollector));
      } catch (TimeExceededException e) {
        LOG.warn("encountered exceeded timout for query '" + _weight.getQuery() + " on shard '" + _shardName
                + "' with timeout set to '" + _timeout + "'");
      }
      TopDocs docs = resultCollector.topDocs();
      return new SearchResult(docs.totalHits, docs.scoreDocs, _callIndex);
    }

View Full Code Here

    for(int downTo=groupQueue.size()-groupOffset-1;downTo>=0;downTo--) {
      final OneGroup og = groupQueue.pop();


      // At this point we hold all docs w/ in each group,
      // unsorted; we now sort them:
      final TopDocsCollector collector;
      if (withinGroupSort == null) {
        // Sort by score
        if (!needsScores) {
          throw new IllegalArgumentException("cannot sort by relevance within group: needsScores=false");
        }
        collector = TopScoreDocCollector.create(maxDocsPerGroup, true);
      } else {
        // Sort by fields
        collector = TopFieldCollector.create(withinGroupSort, maxDocsPerGroup, fillSortFields, needsScores, needsScores, true);
      }


      collector.setScorer(fakeScorer);
      collector.setNextReader(og.reader, og.docBase);
      for(int docIDX=0;docIDX<og.count;docIDX++) {
        final int doc = og.docs[docIDX];
        fakeScorer.doc = doc;
        if (needsScores) {
          fakeScorer.score = og.scores[docIDX];
        }
        collector.collect(doc);
      }
      totalGroupedHitCount += og.count;


      final Object[] groupSortValues;


      if (fillSortFields) {
        groupSortValues = new Comparable[comparators.length];
        for(int sortFieldIDX=0;sortFieldIDX<comparators.length;sortFieldIDX++) {
          groupSortValues[sortFieldIDX] = comparators[sortFieldIDX].value(og.comparatorSlot);
        }
      } else {
        groupSortValues = null;
      }


      final TopDocs topDocs = collector.topDocs(withinGroupOffset, maxDocsPerGroup);


      groups[downTo] = new GroupDocs<Object>(topDocs.getMaxScore(),
                                     og.count,
                                     topDocs.scoreDocs,
                                     null,

View Full Code Here

    for(int groupIDX=offset;groupIDX<sortedGroups.length;groupIDX++) {
      final OneGroup og = sortedGroups[groupIDX];


      // At this point we hold all docs w/ in each group,
      // unsorted; we now sort them:
      final TopDocsCollector collector;
      if (withinGroupSort == null) {
        // Sort by score
        if (!trackScores) {
          throw new IllegalArgumentException("cannot sort by relevance within group: trackScores=false");
        }
        collector = TopScoreDocCollector.create(maxDocsPerGroup, true);
      } else {
        // Sort by fields
        collector = TopFieldCollector.create(withinGroupSort, maxDocsPerGroup, fillSortFields, trackScores, trackMaxScore, true);
      }


      collector.setScorer(fakeScorer);
      collector.setNextReader(og.reader, og.docBase);
      final int numChildDocs = og.counts[slot];
      for(int docIDX=0;docIDX<numChildDocs;docIDX++) {
        final int doc = og.docs[slot][docIDX];
        fakeScorer.doc = doc;
        if (trackScores) {
          fakeScorer.score = og.scores[slot][docIDX];
        }
        collector.collect(doc);
      }
      totalGroupedHitCount += numChildDocs;


      final Object[] groupSortValues;


      if (fillSortFields) {
        groupSortValues = new Object[comparators.length];
        for(int sortFieldIDX=0;sortFieldIDX<comparators.length;sortFieldIDX++) {
          groupSortValues[sortFieldIDX] = comparators[sortFieldIDX].value(og.slot);
        }
      } else {
        groupSortValues = null;
      }


      final TopDocs topDocs = collector.topDocs(withinGroupOffset, maxDocsPerGroup);


      groups[groupIDX-offset] = new GroupDocs<Integer>(topDocs.getMaxScore(),
                                                       og.counts[slot],
                                                       topDocs.scoreDocs,
                                                       og.doc,

View Full Code Here


    groupMap = new HashMap<String, SearchGroupDocs>(groups.size());


    for (SearchGroup group : groups) {
      //System.out.println("  prep group=" + (group.groupValue == null ? "null" : group.groupValue.utf8ToString()));
      final TopDocsCollector collector;
      if (withinGroupSort == null) {
        // Sort by score
        collector = TopScoreDocCollector.create(maxDocsPerGroup, true);
      } else {
        // Sort by fields

View Full Code Here

    for(int groupIDX=offset;groupIDX<sortedGroups.length;groupIDX++) {
      final OneGroup og = sortedGroups[groupIDX];


      // At this point we hold all docs w/ in each group,
      // unsorted; we now sort them:
      final TopDocsCollector collector;
      if (withinGroupSort == null) {
        // Sort by score
        if (!trackScores) {
          throw new IllegalArgumentException("cannot sort by relevance within group: trackScores=false");
        }
        collector = TopScoreDocCollector.create(maxDocsPerGroup, true);
      } else {
        // Sort by fields
        collector = TopFieldCollector.create(withinGroupSort, maxDocsPerGroup, fillSortFields, trackScores, trackMaxScore, true);
      }


      collector.setScorer(fakeScorer);
      collector.setNextReader(og.reader, og.docBase);
      final int numChildDocs = og.counts[slot];
      for(int docIDX=0;docIDX<numChildDocs;docIDX++) {
        final int doc = og.docs[slot][docIDX];
        fakeScorer.doc = doc;
        if (trackScores) {
          fakeScorer.score = og.scores[slot][docIDX];
        }
        collector.collect(doc);
      }
      totalGroupedHitCount += numChildDocs;


      final Object[] groupSortValues;


      if (fillSortFields) {
        groupSortValues = new Object[comparators.length];
        for(int sortFieldIDX=0;sortFieldIDX<comparators.length;sortFieldIDX++) {
          groupSortValues[sortFieldIDX] = comparators[sortFieldIDX].value(og.slot);
        }
      } else {
        groupSortValues = null;
      }


      final TopDocs topDocs = collector.topDocs(withinGroupOffset, maxDocsPerGroup);


      groups[groupIDX-offset] = new GroupDocs<Integer>(topDocs.getMaxScore(),
                                                       og.counts[slot],
                                                       topDocs.scoreDocs,
                                                       og.doc,

View Full Code Here

    for(int groupIDX=offset;groupIDX<sortedGroups.length;groupIDX++) {
      final OneGroup og = sortedGroups[groupIDX];


      // At this point we hold all docs w/ in each group,
      // unsorted; we now sort them:
      final TopDocsCollector collector;
      if (withinGroupSort == null) {
        // Sort by score
        if (!trackScores) {
          throw new IllegalArgumentException("cannot sort by relevance within group: trackScores=false");
        }
        collector = TopScoreDocCollector.create(maxDocsPerGroup, true);
      } else {
        // Sort by fields
        collector = TopFieldCollector.create(withinGroupSort, maxDocsPerGroup, fillSortFields, trackScores, trackMaxScore, true);
      }


      collector.setScorer(fakeScorer);
      collector.setNextReader(og.reader, og.docBase);
      final int numChildDocs = og.counts[slot];
      for(int docIDX=0;docIDX<numChildDocs;docIDX++) {
        final int doc = og.docs[slot][docIDX];
        fakeScorer.doc = doc;
        if (trackScores) {
          fakeScorer.score = og.scores[slot][docIDX];
        }
        collector.collect(doc);
      }
      totalGroupedHitCount += numChildDocs;


      final Object[] groupSortValues;


      if (fillSortFields) {
        groupSortValues = new Object[comparators.length];
        for(int sortFieldIDX=0;sortFieldIDX<comparators.length;sortFieldIDX++) {
          groupSortValues[sortFieldIDX] = comparators[sortFieldIDX].value(og.slot);
        }
      } else {
        groupSortValues = null;
      }


      final TopDocs topDocs = collector.topDocs(withinGroupOffset, maxDocsPerGroup);


      groups[groupIDX-offset] = new GroupDocs<Integer>(topDocs.getMaxScore(),
                                                       og.counts[slot],
                                                       topDocs.scoreDocs,
                                                       og.doc,

View Full Code Here

TOP

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

net.sf.katta.lib.lucene.LuceneServer$SearchCall

org.apache.lucene.search.grouping.BlockGroupingCollector

org.apache.lucene.search.grouping.SecondPassGroupingCollector

org.apache.lucene.search.join.BlockJoinCollector

org.apache.lucene.search.join.ToParentBlockJoinCollector

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.