Package org.apache.lucene.search.grouping

Class AbstractAllGroupHeadsCollector<GH extends AbstractAllGroupHeadsCollector.GroupHead>

  • Direct Known Subclasses:
    TermAllGroupHeadsCollector
    public abstract class AbstractAllGroupHeadsCollector<GH extends AbstractAllGroupHeadsCollector.GroupHead>
extends Collector
    This collector specializes in collecting the most relevant document (group head) for each group that match the query.
    WARNING: This API is experimental and might change in incompatible ways in the next release.

    • Constructor Detail

      • AbstractAllGroupHeadsCollector

        protected AbstractAllGroupHeadsCollector​(int numberOfSorts)

    • Method Detail

      • retrieveGroupHeads

        public FixedBitSet retrieveGroupHeads​(int maxDoc)
        Parameters:
        maxDoc - The maxDoc of the top level IndexReader.
        Returns:
        an FixedBitSet containing all group heads.

      • retrieveGroupHeads

        public int[] retrieveGroupHeads()
        Returns:
        an int array containing all group heads. The size of the array is equal to number of collected unique groups.

      • groupHeadsSize

        public int groupHeadsSize()
        Returns:
        the number of group heads found for a query.

      • retrieveGroupHeadAndAddIfNotExist

        protected abstract void retrieveGroupHeadAndAddIfNotExist​(int doc)
                                                   throws IOException
        Returns the group head and puts it into temporalResult. If the group head wasn't encountered before then it will be added to the collected group heads.

        The AbstractAllGroupHeadsCollector.TemporalResult.stop property will be true if the group head wasn't encountered before otherwise false.

        Parameters:
        doc - The document to retrieve the group head for.
        Throws:
        IOException - If I/O related errors occur

      • getCollectedGroupHeads

        protected abstract Collection<GH> getCollectedGroupHeads()
        Returns the collected group heads. Subsequent calls should return the same group heads.
        Returns:
        the collected group heads

      • collect

        public void collect​(int doc)
             throws IOException
        Description copied from class: Collector
        Called once for every document matching a query, with the unbased document number.

        Note: This is called in an inner search loop. For good search performance, implementations of this method should not call Searcher.doc(int) or IndexReader.document(int) on every hit. Doing so can slow searches by an order of magnitude or more.

        Specified by:
        collect in class Collector
        Throws:
        IOException

      • acceptsDocsOutOfOrder

        public boolean acceptsDocsOutOfOrder()
        Description copied from class: Collector
        Return true if this collector does not require the matching docIDs to be delivered in int sort order (smallest to largest) to Collector.collect(int).

        Most Lucene Query implementations will visit matching docIDs in order. However, some queries (currently limited to certain cases of BooleanQuery) can achieve faster searching if the Collector allows them to deliver the docIDs out of order.

        Many collectors don't mind getting docIDs out of order, so it's important to return true here.

        Specified by:
        acceptsDocsOutOfOrder in class Collector