~slub.team/goobi-indexserver/3.x

public TopGroups(SortField[] groupSort, SortField[] withinGroupSort, int totalHitCount, int totalGroupedHitCount, GroupDocs<GROUP_VALUE_TYPE>[] groups) {

this.groupSort = groupSort;

this.withinGroupSort = withinGroupSort;

this.totalHitCount = totalHitCount;

this.totalGroupedHitCount = totalGroupedHitCount;

this.groups = groups;

this.totalGroupCount = null;

}

public TopGroups(TopGroups<GROUP_VALUE_TYPE> oldTopGroups, Integer totalGroupCount) {

this.groupSort = oldTopGroups.groupSort;

this.withinGroupSort = oldTopGroups.withinGroupSort;

this.totalHitCount = oldTopGroups.totalHitCount;

this.totalGroupedHitCount = oldTopGroups.totalGroupedHitCount;

this.groups = oldTopGroups.groups;

this.totalGroupCount = totalGroupCount;

}

/** Merges an array of TopGroups, for example obtained

* from the second-pass collector across multiple

* shards. Each TopGroups must have been sorted by the

* same groupSort and docSort, and the top groups passed

* to all second-pass collectors must be the same.

* <b>NOTE</b>: We can't always compute an exact totalGroupCount.

* Documents belonging to a group may occur on more than

* one shard and thus the merged totalGroupCount can be

* higher than the actual totalGroupCount. In this case the

* totalGroupCount represents a upper bound. If the documents

* of one group do only reside in one shard then the

* totalGroupCount is exact.

* <b>NOTE</b>: the topDocs in each GroupDocs is actually

* an instance of TopDocsAndShards

public static <T> TopGroups<T> merge(TopGroups<T>[] shardGroups, Sort groupSort, Sort docSort, int docOffset, int docTopN)

throws IOException {

//System.out.println("TopGroups.merge");

if (shardGroups.length == 0) {

return null;

}

int totalHitCount = 0;

int totalGroupedHitCount = 0;

// Optionally merge the totalGroupCount.

Integer totalGroupCount = null;

final int numGroups = shardGroups[0].groups.length;

for(TopGroups<T> shard : shardGroups) {

100

if (numGroups != shard.groups.length) {

101

throw new IllegalArgumentException("number of groups differs across shards; you must pass same top groups to all shards' second-pass collector");

102

}

103

totalHitCount += shard.totalHitCount;

104

totalGroupedHitCount += shard.totalGroupedHitCount;

105

if (shard.totalGroupCount != null) {

106

if (totalGroupCount == null) {

107

totalGroupCount = 0;

108

}

109

110

totalGroupCount += shard.totalGroupCount;

111

}

112

}

113

114

@SuppressWarnings("unchecked")

115

final GroupDocs<T>[] mergedGroupDocs = new GroupDocs[numGroups];

116

117

final TopDocs[] shardTopDocs = new TopDocs[shardGroups.length];

118

119

for(int groupIDX=0;groupIDX<numGroups;groupIDX++) {

120

final T groupValue = shardGroups[0].groups[groupIDX].groupValue;

121

//System.out.println(" merge groupValue=" + groupValue + " sortValues=" + Arrays.toString(shardGroups[0].groups[groupIDX].groupSortValues));

122

float maxScore = Float.MIN_VALUE;

123

int totalHits = 0;

124

for(int shardIDX=0;shardIDX<shardGroups.length;shardIDX++) {

125

//System.out.println(" shard=" + shardIDX);

126

final TopGroups<T> shard = shardGroups[shardIDX];

127

final GroupDocs shardGroupDocs = shard.groups[groupIDX];

128

if (groupValue == null) {

129

if (shardGroupDocs.groupValue != null) {

130

throw new IllegalArgumentException("group values differ across shards; you must pass same top groups to all shards' second-pass collector");

131

}

132

} else if (!groupValue.equals(shardGroupDocs.groupValue)) {

133

throw new IllegalArgumentException("group values differ across shards; you must pass same top groups to all shards' second-pass collector");

134

}

135

136

137

for(ScoreDoc sd : shardGroupDocs.scoreDocs) {

138

System.out.println(" doc=" + sd.doc);

139

}

140

141

142

shardTopDocs[shardIDX] = new TopDocs(shardGroupDocs.totalHits,

143

shardGroupDocs.scoreDocs,

144

shardGroupDocs.maxScore);

145

maxScore = Math.max(maxScore, shardGroupDocs.maxScore);

146

totalHits += shardGroupDocs.totalHits;

147

}

148

149

final TopDocs mergedTopDocs = TopDocs.merge(docSort, docOffset + docTopN, shardTopDocs);

150

151

// Slice;

152

final ScoreDoc[] mergedScoreDocs;

153

if (docOffset == 0) {

154

mergedScoreDocs = mergedTopDocs.scoreDocs;

155

} else if (docOffset >= mergedTopDocs.scoreDocs.length) {

156

mergedScoreDocs = new ScoreDoc[0];

157

} else {

158

mergedScoreDocs = new ScoreDoc[mergedTopDocs.scoreDocs.length - docOffset];

159

System.arraycopy(mergedTopDocs.scoreDocs,

160

docOffset,

161

mergedScoreDocs,

162

163

mergedTopDocs.scoreDocs.length - docOffset);

164

}

165

//System.out.println("SHARDS=" + Arrays.toString(mergedTopDocs.shardIndex));

166

mergedGroupDocs[groupIDX] = new GroupDocs<T>(maxScore,

167

totalHits,

168

mergedScoreDocs,

169

groupValue,

170

shardGroups[0].groups[groupIDX].groupSortValues);

171

}

172

173

if (totalGroupCount != null) {

174

TopGroups<T> result = new TopGroups<T>(groupSort.getSort(),

175

docSort == null ? null : docSort.getSort(),

176

totalHitCount,

177

totalGroupedHitCount,

178

mergedGroupDocs);

179

return new TopGroups<T>(result, totalGroupCount);

180

} else {

181

return new TopGroups<T>(groupSort.getSort(),

182

docSort == null ? null : docSort.getSort(),

183

totalHitCount,

184

totalGroupedHitCount,

185

mergedGroupDocs);

186

}

187

}

188

}

Older »