gaobinlong commented on code in PR #15936:
URL: https://github.com/apache/lucene/pull/15936#discussion_r3295944942
##########
lucene/grouping/src/java/org/apache/lucene/search/grouping/TopGroups.java:
##########
@@ -280,4 +287,123 @@ public static <T> TopGroups<T> merge(
totalMaxScore);
}
}
+
+ private record MergedBlockGroup(Object[] topValues, int shardIndex, int
groupIndex) {}
+
+ private static class GroupComparator implements Comparator<MergedBlockGroup>
{
+ @SuppressWarnings("rawtypes")
+ public final FieldComparator[] comparators;
+
+ public final int[] reversed;
+
+ @SuppressWarnings({"rawtypes"})
+ public GroupComparator(Sort groupSort) {
+ final SortField[] sortFields = groupSort.getSort();
+ comparators = new FieldComparator[sortFields.length];
+ reversed = new int[sortFields.length];
+ for (int compIDX = 0; compIDX < sortFields.length; compIDX++) {
+ final SortField sortField = sortFields[compIDX];
+ comparators[compIDX] = sortField.getComparator(1, Pruning.NONE);
+ reversed[compIDX] = sortField.getReverse() ? -1 : 1;
+ }
+ }
+
+ @Override
+ @SuppressWarnings({"unchecked"})
+ public int compare(MergedBlockGroup group, MergedBlockGroup other) {
+ if (group == other) {
+ return 0;
+ }
+ final Object[] groupValues = group.topValues;
+ final Object[] otherValues = other.topValues;
+ for (int compIDX = 0; compIDX < comparators.length; compIDX++) {
+ final int c =
+ reversed[compIDX]
+ * comparators[compIDX].compareValues(groupValues[compIDX],
otherValues[compIDX]);
+ if (c != 0) {
+ return c;
+ }
+ }
+
+ assert group.shardIndex != other.shardIndex;
+ return group.shardIndex - other.shardIndex;
+ }
+ }
+
+ /**
+ * Merge TopGroups that are partitioned into blocks per shard. This method
assumes that within
+ * each shard, the groups are sorted according to the groupSort.
+ *
+ * @param shardGroups list of TopGroups, one per shard.
+ * @param groupSort The {@link Sort} used to sort the groups. The top sorted
document within each
+ * * group according to groupSort, determines how that group sorts
against other groups. This
+ * * must be non-null, ie, if you want to groupSort by relevance use
Sort.RELEVANCE.
+ * @param groupOffset Which group to start from.
+ * @param topNGroups How many top groups to keep.
+ * @return TopGroups instance or null if there are no groups.
+ */
+ public static TopGroups<?> mergeBlockGroups(
+ List<TopGroups<?>> shardGroups, Sort groupSort, int groupOffset, int
topNGroups) {
+ if (shardGroups.isEmpty()) {
+ return null;
+ }
+
+ int totalGroupCount = 0;
+ int totalHitCount = 0;
+ int totalGroupedHitCount = 0;
+ for (TopGroups<?> sg : shardGroups) {
+ totalGroupCount += sg.totalGroupCount;
+ totalHitCount += sg.totalHitCount;
+ }
+
+ // k-way merge
+ GroupComparator groupComp = new GroupComparator(groupSort);
+ NavigableSet<MergedBlockGroup> queue = new TreeSet<>(groupComp);
+
+ // init queue
+ for (int idx = 0; idx < shardGroups.size(); idx++) {
+ GroupDocs<?> firstGroupDocs = shardGroups.get(idx).groups[0];
+ queue.add(new MergedBlockGroup(firstGroupDocs.groupSortValues(), idx,
0));
+ }
+
+ float maxScore =
shardGroups.get(queue.first().shardIndex).groups[0].maxScore();
Review Comment:
This is really a bug, we need to compute maxScore by iterating on all
TopGroups, only for the case of sort by relevance, we can get the maxScore
directly from the head of the queue after initialized.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
