Java Collector类代码示例

import org.apache.lucene.search.Collector; //导入依赖的package包/类
/**
 * Creates a human-friendly representation of the Collector name.
 *
 * InternalBucket Collectors use the aggregation name in their toString() method,
 * which makes the profiled output a bit nicer.
 *
 * @param c The Collector to derive a name from
 * @return  A (hopefully) prettier name
 */
private String deriveCollectorName(Collector c) {
    String s = c.getClass().getSimpleName();

    // MutiCollector which wraps multiple BucketCollectors is generated
    // via an anonymous class, so this corrects the lack of a name by
    // asking the enclosingClass
    if (s.equals("")) {
        s = c.getClass().getEnclosingClass().getSimpleName();
    }

    // Aggregation collector toString()'s include the user-defined agg name
    if (reason.equals(CollectorResult.REASON_AGGREGATION) || reason.equals(CollectorResult.REASON_AGGREGATION_GLOBAL)) {
        s += ": [" + c.toString() + "]";
    }
    return s;
}
 

import org.apache.lucene.search.Collector; //导入依赖的package包/类
private void countTestCase(Query query, IndexReader reader, boolean shouldCollect) throws Exception {
    TestSearchContext context = new TestSearchContext(null);
    context.parsedQuery(new ParsedQuery(query));
    context.setSize(0);
    context.setTask(new SearchTask(123L, "", "", "", null));

    IndexSearcher searcher = new IndexSearcher(reader);
    final AtomicBoolean collected = new AtomicBoolean();
    IndexSearcher contextSearcher = new IndexSearcher(reader) {
        protected void search(List<LeafReaderContext> leaves, Weight weight, Collector collector) throws IOException {
            collected.set(true);
            super.search(leaves, weight, collector);
        }
    };

    final boolean rescore = QueryPhase.execute(context, contextSearcher);
    assertFalse(rescore);
    assertEquals(searcher.count(query), context.queryResult().topDocs().totalHits);
    assertEquals(shouldCollect, collected.get());
}
 

import org.apache.lucene.search.Collector; //导入依赖的package包/类
public void testPostFilterDisablesCountOptimization() throws Exception {
    TestSearchContext context = new TestSearchContext(null);
    context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
    context.setSize(0);
    context.setTask(new SearchTask(123L, "", "", "", null));

    final AtomicBoolean collected = new AtomicBoolean();
    IndexSearcher contextSearcher = new IndexSearcher(new MultiReader()) {
        protected void search(List<LeafReaderContext> leaves, Weight weight, Collector collector) throws IOException {
            collected.set(true);
            super.search(leaves, weight, collector);
        }
    };

    QueryPhase.execute(context, contextSearcher);
    assertEquals(0, context.queryResult().topDocs().totalHits);
    assertFalse(collected.get());

    context.parsedPostFilter(new ParsedQuery(new MatchNoDocsQuery()));
    QueryPhase.execute(context, contextSearcher);
    assertEquals(0, context.queryResult().topDocs().totalHits);
    assertTrue(collected.get());
}
 

import org.apache.lucene.search.Collector; //导入依赖的package包/类
public void testMinScoreDisablesCountOptimization() throws Exception {
    TestSearchContext context = new TestSearchContext(null);
    context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
    context.setSize(0);
    context.setTask(new SearchTask(123L, "", "", "", null));

    final AtomicBoolean collected = new AtomicBoolean();
    IndexSearcher contextSearcher = new IndexSearcher(new MultiReader()) {
        protected void search(List<LeafReaderContext> leaves, Weight weight, Collector collector) throws IOException {
            collected.set(true);
            super.search(leaves, weight, collector);
        }
    };

    QueryPhase.execute(context, contextSearcher);
    assertEquals(0, context.queryResult().topDocs().totalHits);
    assertFalse(collected.get());

    context.minimumScore(1);
    QueryPhase.execute(context, contextSearcher);
    assertEquals(0, context.queryResult().topDocs().totalHits);
    assertTrue(collected.get());
}
 

import org.apache.lucene.search.Collector; //导入依赖的package包/类
/**
 * Creates a human-friendly representation of the Collector name.
 *
 * Bucket Collectors use the aggregation name in their toString() method,
 * which makes the profiled output a bit nicer.
 *
 * @param c The Collector to derive a name from
 * @return  A (hopefully) prettier name
 */
private String deriveCollectorName(Collector c) {
    String s = c.getClass().getSimpleName();

    // MutiCollector which wraps multiple BucketCollectors is generated
    // via an anonymous class, so this corrects the lack of a name by
    // asking the enclosingClass
    if (s.equals("")) {
        s = c.getClass().getEnclosingClass().getSimpleName();
    }

    // Aggregation collector toString()'s include the user-defined agg name
    if (reason.equals(CollectorResult.REASON_AGGREGATION) || reason.equals(CollectorResult.REASON_AGGREGATION_GLOBAL)) {
        s += ": [" + c.toString() + "]";
    }
    return s;
}
 

import org.apache.lucene.search.Collector; //导入依赖的package包/类
private Collector getInsanityWrapper(final String field, Collector collector) {
  SchemaField sf = searcher.getSchema().getFieldOrNull(field);
  if (sf != null && !sf.hasDocValues() && !sf.multiValued() && sf.getType().getNumberType() != null) {
    // it's a single-valued numeric field: we must currently create insanity :(
    // there isn't a GroupedFacetCollector that works on numerics right now...
    return new FilterCollector(collector) {
      @Override
      public LeafCollector getLeafCollector(LeafReaderContext context) throws IOException {
        LeafReader insane = Insanity.wrapInsanity(context.reader(), field);
        return in.getLeafCollector(insane.getContext());
      }
    };
  } else {
    return collector;
  }
}
 

import org.apache.lucene.search.Collector; //导入依赖的package包/类
/**
 * Search all documents matching the passed query and pass the result on to
 * the provided {@link Consumer}.
 *
 * @param aQuery
 *        Query to execute. May not be <code>null</code>-
 * @param aCollector
 *        The Lucene collector to be used. May not be <code>null</code>.
 * @throws IOException
 *         On Lucene error
 * @see #getAllDocuments(Query)
 */
public void searchAtomic (@Nonnull final Query aQuery, @Nonnull final Collector aCollector) throws IOException
{
  ValueEnforcer.notNull (aQuery, "Query");
  ValueEnforcer.notNull (aCollector, "Collector");

  m_aLucene.runAtomic ( () -> {
    final IndexSearcher aSearcher = m_aLucene.getSearcher ();
    if (aSearcher != null)
    {
      if (s_aLogger.isDebugEnabled ())
        s_aLogger.debug ("Searching Lucene: " + aQuery);

      // Search all documents, collect them
      _timedSearch ( () -> aSearcher.search (aQuery, aCollector), aQuery);
    }
    else
      s_aLogger.error ("Failed to obtain IndexSearcher");
  });
}
 

import org.apache.lucene.search.Collector; //导入依赖的package包/类
@Nonnull
@ReturnsMutableCopy
public ICommonsSortedSet <IParticipantIdentifier> getAllContainedParticipantIDs ()
{
  final ICommonsSortedSet <IParticipantIdentifier> aTargetSet = new CommonsTreeSet <> ();
  final Query aQuery = PDQueryManager.andNotDeleted (new MatchAllDocsQuery ());
  try
  {
    final ObjIntConsumer <Document> aConsumer = (aDoc,
                                                 nDocID) -> aTargetSet.add (PDField.PARTICIPANT_ID.getDocValue (aDoc));
    final Collector aCollector = new AllDocumentsCollector (m_aLucene, aConsumer);
    searchAtomic (aQuery, aCollector);
  }
  catch (final IOException ex)
  {
    s_aLogger.error ("Error searching for documents with query " + aQuery, ex);
  }
  return aTargetSet;
}
 

import org.apache.lucene.search.Collector; //导入依赖的package包/类
private void collectHit(Collector collector, Collector[] sidewaysCollectors) throws IOException {
  //if (DEBUG) {
  //  System.out.println("      hit");
  //}

  collector.collect(collectDocID);
  if (drillDownCollector != null) {
    drillDownCollector.collect(collectDocID);
  }

  // TODO: we could "fix" faceting of the sideways counts
  // to do this "union" (of the drill down hits) in the
  // end instead:

  // Tally sideways counts:
  for (int dim=0;dim<sidewaysCollectors.length;dim++) {
    sidewaysCollectors[dim].collect(collectDocID);
  }
}
 

import org.apache.lucene.search.Collector; //导入依赖的package包/类
@Override
public boolean score(Collector collector, int max) throws IOException {
  FakeScorer fakeScorer = new FakeScorer();
  collector.setScorer(fakeScorer);
  if (doc == -1) {
    doc = nextDocOutOfOrder();
  }
  while(doc < max) {
    fakeScorer.doc = doc;
    fakeScorer.score = scores[ords[scoreUpto]];
    collector.collect(doc);
    doc = nextDocOutOfOrder();
  }

  return doc != DocsEnum.NO_MORE_DOCS;
}
 

import org.apache.lucene.search.Collector; //导入依赖的package包/类
@Test
public void testNullCollectors() throws Exception {
  // Tests that the collector rejects all null collectors.
  try {
    MultiCollector.wrap(null, null);
    fail("only null collectors should not be supported");
  } catch (IllegalArgumentException e) {
    // expected
  }

  // Tests that the collector handles some null collectors well. If it
  // doesn't, an NPE would be thrown.
  Collector c = MultiCollector.wrap(new DummyCollector(), null, new DummyCollector());
  assertTrue(c instanceof MultiCollector);
  assertTrue(c.acceptsDocsOutOfOrder());
  c.collect(1);
  c.setNextReader(null);
  c.setScorer(null);
}
 

import org.apache.lucene.search.Collector; //导入依赖的package包/类
@Test
public void testCollector() throws Exception {
  // Tests that the collector delegates calls to input collectors properly.

  // Tests that the collector handles some null collectors well. If it
  // doesn't, an NPE would be thrown.
  DummyCollector[] dcs = new DummyCollector[] { new DummyCollector(), new DummyCollector() };
  Collector c = MultiCollector.wrap(dcs);
  assertTrue(c.acceptsDocsOutOfOrder());
  c.collect(1);
  c.setNextReader(null);
  c.setScorer(null);

  for (DummyCollector dc : dcs) {
    assertTrue(dc.acceptsDocsOutOfOrderCalled);
    assertTrue(dc.collectCalled);
    assertTrue(dc.setNextReaderCalled);
    assertTrue(dc.setScorerCalled);
  }

}
 

import org.apache.lucene.search.Collector; //导入依赖的package包/类
private DocSet getDocSetScore(List<Query> queries) throws IOException {
  Query main = queries.remove(0);
  ProcessedFilter pf = getProcessedFilter(null, queries);
  DocSetCollector setCollector = new DocSetCollector(maxDoc()>>6, maxDoc());
  Collector collector = setCollector;
  if (pf.postFilter != null) {
    pf.postFilter.setLastDelegate(collector);
    collector = pf.postFilter;
  }

  search(main, pf.filter, collector);

  if(collector instanceof DelegatingCollector) {
    ((DelegatingCollector) collector).finish();
  }

  DocSet docSet = setCollector.getDocSet();
  return docSet;
}
 

import org.apache.lucene.search.Collector; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void execute() throws IOException {
  final int nrOfCommands = commands.size();
  List<Collector> collectors = new ArrayList<>(nrOfCommands);
  for (Command command : commands) {
    collectors.addAll(command.create());
  }

  ProcessedFilter filter = searcher.getProcessedFilter
    (queryCommand.getFilter(), queryCommand.getFilterList());
  Query query = QueryUtils.makeQueryable(queryCommand.getQuery());

  if (truncateGroups) {
    docSet = computeGroupedDocSet(query, filter, collectors);
  } else if (needDocset) {
    docSet = computeDocSet(query, filter, collectors);
  } else if (!collectors.isEmpty()) {
    searchWithTimeLimiter(query, filter, MultiCollector.wrap(collectors.toArray(new Collector[nrOfCommands])));
  } else {
    searchWithTimeLimiter(query, filter, null);
  }
}
 

import org.apache.lucene.search.Collector; //导入依赖的package包/类
public GroupExpandCollector(SortedDocValues docValues, FixedBitSet groupBits, IntOpenHashSet collapsedSet, int limit, Sort sort) throws IOException {
  int numGroups = collapsedSet.size();
  groups = new IntObjectOpenHashMap<>(numGroups * 2);
  collectors = new ArrayList<>();
  DocIdSetIterator iterator = groupBits.iterator();
  int group;
  while ((group = iterator.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) {
    Collector collector = (sort == null) ? TopScoreDocCollector.create(limit, true) : TopFieldCollector.create(sort, limit, false, false, false, true);
    groups.put(group, collector);
    collectors.add(collector);
  }

  this.collapsedSet = collapsedSet;
  this.groupBits = groupBits;
  this.docValues = docValues;
}