Java 类org.apache.lucene.search.grouping.term.TermSecondPassGroupingCollector 实例源码

@SuppressWarnings({"unchecked", "rawtypes"})
private TopGroups<BytesRef> getTopGroups(AbstractSecondPassGroupingCollector c, int withinGroupOffset) {
  if (c.getClass().isAssignableFrom(TermSecondPassGroupingCollector.class)) {
    return ((TermSecondPassGroupingCollector) c).getTopGroups(withinGroupOffset);
  } else if (c.getClass().isAssignableFrom(FunctionSecondPassGroupingCollector.class)) {
    TopGroups<MutableValue> mvalTopGroups = ((FunctionSecondPassGroupingCollector) c).getTopGroups(withinGroupOffset);
    List<GroupDocs<BytesRef>> groups = new ArrayList<>(mvalTopGroups.groups.length);
    for (GroupDocs<MutableValue> mvalGd : mvalTopGroups.groups) {
      BytesRef groupValue = mvalGd.groupValue.exists() ? ((MutableValueStr) mvalGd.groupValue).value : null;
      groups.add(new GroupDocs<>(Float.NaN, mvalGd.maxScore, mvalGd.totalHits, mvalGd.scoreDocs, groupValue, mvalGd.groupSortValues));
    }
    return new TopGroups<>(mvalTopGroups.groupSort, mvalTopGroups.withinGroupSort, mvalTopGroups.totalHitCount, mvalTopGroups.totalGroupedHitCount, groups.toArray(new GroupDocs[groups.size()]), Float.NaN);
  }
  fail();
  return null;
}

@SuppressWarnings({"unchecked", "rawtypes"})
private TopGroups<BytesRef> getTopGroups(AbstractSecondPassGroupingCollector c, int withinGroupOffset) {
  if (c.getClass().isAssignableFrom(TermSecondPassGroupingCollector.class)) {
    return ((TermSecondPassGroupingCollector) c).getTopGroups(withinGroupOffset);
  } else if (c.getClass().isAssignableFrom(FunctionSecondPassGroupingCollector.class)) {
    TopGroups<MutableValue> mvalTopGroups = ((FunctionSecondPassGroupingCollector) c).getTopGroups(withinGroupOffset);
    List<GroupDocs<BytesRef>> groups = new ArrayList<GroupDocs<BytesRef>>(mvalTopGroups.groups.length);
    for (GroupDocs<MutableValue> mvalGd : mvalTopGroups.groups) {
      BytesRef groupValue = mvalGd.groupValue.exists() ? ((MutableValueStr) mvalGd.groupValue).value : null;
      groups.add(new GroupDocs<BytesRef>(Float.NaN, mvalGd.maxScore, mvalGd.totalHits, mvalGd.scoreDocs, groupValue, mvalGd.groupSortValues));
    }
    return new TopGroups<BytesRef>(mvalTopGroups.groupSort, mvalTopGroups.withinGroupSort, mvalTopGroups.totalHitCount, mvalTopGroups.totalGroupedHitCount, groups.toArray(new GroupDocs[groups.size()]), Float.NaN);
  }
  fail();
  return null;
}

@SuppressWarnings({"unchecked", "rawtypes"})
private TopGroups<BytesRef> getTopGroups(AbstractSecondPassGroupingCollector c, int withinGroupOffset) {
  if (c.getClass().isAssignableFrom(TermSecondPassGroupingCollector.class)) {
    return ((TermSecondPassGroupingCollector) c).getTopGroups(withinGroupOffset);
  } else if (c.getClass().isAssignableFrom(FunctionSecondPassGroupingCollector.class)) {
    TopGroups<MutableValue> mvalTopGroups = ((FunctionSecondPassGroupingCollector) c).getTopGroups(withinGroupOffset);
    List<GroupDocs<BytesRef>> groups = new ArrayList<GroupDocs<BytesRef>>(mvalTopGroups.groups.length);
    for (GroupDocs<MutableValue> mvalGd : mvalTopGroups.groups) {
      BytesRef groupValue = mvalGd.groupValue.exists() ? ((MutableValueStr) mvalGd.groupValue).value : null;
      groups.add(new GroupDocs<BytesRef>(Float.NaN, mvalGd.maxScore, mvalGd.totalHits, mvalGd.scoreDocs, groupValue, mvalGd.groupSortValues));
    }
    return new TopGroups<BytesRef>(mvalTopGroups.groupSort, mvalTopGroups.withinGroupSort, mvalTopGroups.totalHitCount, mvalTopGroups.totalGroupedHitCount, groups.toArray(new GroupDocs[groups.size()]), Float.NaN);
  }
  fail();
  return null;
}

@SuppressWarnings("unchecked")
private AbstractSecondPassGroupingCollector<?> createSecondPassCollector(AbstractFirstPassGroupingCollector<?> firstPassGroupingCollector,
                                                                      String groupField,
                                                                      Collection<SearchGroup<BytesRef>> searchGroups,
                                                                      Sort groupSort,
                                                                      Sort sortWithinGroup,
                                                                      int maxDocsPerGroup,
                                                                      boolean getScores,
                                                                      boolean getMaxScores,
                                                                      boolean fillSortFields) throws IOException {
  if (firstPassGroupingCollector.getClass().isAssignableFrom(TermFirstPassGroupingCollector.class)) {
    return new TermSecondPassGroupingCollector(groupField, searchGroups, groupSort, sortWithinGroup, maxDocsPerGroup , getScores, getMaxScores, fillSortFields);
  } else {
    ValueSource vs = new BytesRefFieldSource(groupField);
    List<SearchGroup<MutableValue>> mvalSearchGroups = new ArrayList<>(searchGroups.size());
    for (SearchGroup<BytesRef> mergedTopGroup : searchGroups) {
      SearchGroup<MutableValue> sg = new SearchGroup<>();
      MutableValueStr groupValue = new MutableValueStr();
      if (mergedTopGroup.groupValue != null) {
        groupValue.value.copyBytes(mergedTopGroup.groupValue);
      } else {
        groupValue.exists = false;
      }
      sg.groupValue = groupValue;
      sg.sortValues = mergedTopGroup.sortValues;
      mvalSearchGroups.add(sg);
    }

    return new FunctionSecondPassGroupingCollector(mvalSearchGroups, groupSort, sortWithinGroup, maxDocsPerGroup, getScores, getMaxScores, fillSortFields, vs, new HashMap<>());
  }
}

@Override
public List<Collector> create() throws IOException {
  if (firstPhaseGroups.isEmpty()) {
    return Collections.emptyList();
  }

  List<Collector> collectors = new ArrayList<>();
  secondPassCollector = new TermSecondPassGroupingCollector(
        field.getName(), firstPhaseGroups, groupSort, sortWithinGroup, maxDocPerGroup, needScores, needMaxScore, true
  );
  collectors.add(secondPassCollector);
  return collectors;
}

@SuppressWarnings("unchecked")
private AbstractSecondPassGroupingCollector<?> createSecondPassCollector(AbstractFirstPassGroupingCollector<?> firstPassGroupingCollector,
                                                                      String groupField,
                                                                      Collection<SearchGroup<BytesRef>> searchGroups,
                                                                      Sort groupSort,
                                                                      Sort sortWithinGroup,
                                                                      int maxDocsPerGroup,
                                                                      boolean getScores,
                                                                      boolean getMaxScores,
                                                                      boolean fillSortFields) throws IOException {
  if (firstPassGroupingCollector.getClass().isAssignableFrom(TermFirstPassGroupingCollector.class)) {
    return new TermSecondPassGroupingCollector(groupField, searchGroups, groupSort, sortWithinGroup, maxDocsPerGroup , getScores, getMaxScores, fillSortFields);
  } else {
    ValueSource vs = new BytesRefFieldSource(groupField);
    List<SearchGroup<MutableValue>> mvalSearchGroups = new ArrayList<SearchGroup<MutableValue>>(searchGroups.size());
    for (SearchGroup<BytesRef> mergedTopGroup : searchGroups) {
      SearchGroup<MutableValue> sg = new SearchGroup<MutableValue>();
      MutableValueStr groupValue = new MutableValueStr();
      if (mergedTopGroup.groupValue != null) {
        groupValue.value =  mergedTopGroup.groupValue;
      } else {
        groupValue.value = new BytesRef();
        groupValue.exists = false;
      }
      sg.groupValue = groupValue;
      sg.sortValues = mergedTopGroup.sortValues;
      mvalSearchGroups.add(sg);
    }

    return new FunctionSecondPassGroupingCollector(mvalSearchGroups, groupSort, sortWithinGroup, maxDocsPerGroup, getScores, getMaxScores, fillSortFields, vs, new HashMap<Object, Object>());
  }
}

@Override
public List<Collector> create() throws IOException {
  if (firstPhaseGroups.isEmpty()) {
    return Collections.emptyList();
  }

  List<Collector> collectors = new ArrayList<Collector>();
  secondPassCollector = new TermSecondPassGroupingCollector(
        field.getName(), firstPhaseGroups, groupSort, sortWithinGroup, maxDocPerGroup, needScores, needMaxScore, true
  );
  collectors.add(secondPassCollector);
  return collectors;
}

@Override
public List<Collector> create() throws IOException {
  if (firstPhaseGroups.isEmpty()) {
    return Collections.emptyList();
  }

  List<Collector> collectors = new ArrayList<Collector>();
  secondPassCollector = new TermSecondPassGroupingCollector(
        field.getName(), firstPhaseGroups, groupSort, sortWithinGroup, maxDocPerGroup, needScores, needMaxScore, true
  );
  collectors.add(secondPassCollector);
  return collectors;
}

@Override
public List<Collector> create() throws IOException {
  if (firstPhaseGroups.isEmpty()) {
    return Collections.emptyList();
  }

  List<Collector> collectors = new ArrayList<Collector>();
  secondPassCollector = new TermSecondPassGroupingCollector(
        field.getName(), firstPhaseGroups, groupSort, sortWithinGroup, maxDocPerGroup, needScores, needMaxScore, true
  );
  collectors.add(secondPassCollector);
  return collectors;
}

@Override
public List<Collector> create() throws IOException {
  if (firstPhaseGroups.isEmpty()) {
    return Collections.emptyList();
  }

  List<Collector> collectors = new ArrayList<>();
  secondPassCollector = new TermSecondPassGroupingCollector(
        field.getName(), firstPhaseGroups, groupSort, sortWithinGroup, maxDocPerGroup, needScores, needMaxScore, true
  );
  collectors.add(secondPassCollector);
  return collectors;
}

@SuppressWarnings("unchecked")
private AbstractSecondPassGroupingCollector<?> createSecondPassCollector(AbstractFirstPassGroupingCollector<?> firstPassGroupingCollector,
                                                                      String groupField,
                                                                      Collection<SearchGroup<BytesRef>> searchGroups,
                                                                      Sort groupSort,
                                                                      Sort sortWithinGroup,
                                                                      int maxDocsPerGroup,
                                                                      boolean getScores,
                                                                      boolean getMaxScores,
                                                                      boolean fillSortFields) throws IOException {
  if (firstPassGroupingCollector.getClass().isAssignableFrom(TermFirstPassGroupingCollector.class)) {
    return new TermSecondPassGroupingCollector(groupField, searchGroups, groupSort, sortWithinGroup, maxDocsPerGroup , getScores, getMaxScores, fillSortFields);
  } else {
    ValueSource vs = new BytesRefFieldSource(groupField);
    List<SearchGroup<MutableValue>> mvalSearchGroups = new ArrayList<SearchGroup<MutableValue>>(searchGroups.size());
    for (SearchGroup<BytesRef> mergedTopGroup : searchGroups) {
      SearchGroup<MutableValue> sg = new SearchGroup<MutableValue>();
      MutableValueStr groupValue = new MutableValueStr();
      if (mergedTopGroup.groupValue != null) {
        groupValue.value =  mergedTopGroup.groupValue;
      } else {
        groupValue.value = new BytesRef();
        groupValue.exists = false;
      }
      sg.groupValue = groupValue;
      sg.sortValues = mergedTopGroup.sortValues;
      mvalSearchGroups.add(sg);
    }

    return new FunctionSecondPassGroupingCollector(mvalSearchGroups, groupSort, sortWithinGroup, maxDocsPerGroup, getScores, getMaxScores, fillSortFields, vs, new HashMap<Object, Object>());
  }
}