epotyom commented on code in PR #13568:
URL: https://github.com/apache/lucene/pull/13568#discussion_r1678181693
##########
lucene/facet/src/java/org/apache/lucene/facet/DrillSideways.java:
##########
@@ -349,45 +344,149 @@ private DrillDownQuery getDrillDownQuery(
public <R> ConcurrentDrillSidewaysResult<R> search(
final DrillDownQuery query, final CollectorManager<?, R>
hitCollectorManager)
throws IOException {
+ // Main query
+ FacetsCollectorManager drillDownFacetsCollectorManager =
+ createDrillDownFacetsCollectorManager();
+ final CollectorOwner<?, ?> mainCollectorOwner;
+ if (drillDownFacetsCollectorManager != null) {
+ // Make sure we populate a facet collector corresponding to the base
query if desired:
+ mainCollectorOwner =
+ CollectorOwner.hire(
+ new MultiCollectorManager(drillDownFacetsCollectorManager,
hitCollectorManager));
+ } else {
+ mainCollectorOwner = CollectorOwner.hire(hitCollectorManager);
+ }
+ // Drill sideways dimensions
+ final List<CollectorOwner<?, ?>> drillSidewaysCollectorOwners;
+ if (query.getDims().isEmpty() == false) {
+ drillSidewaysCollectorOwners = new ArrayList<>(query.getDims().size());
+ for (int i = 0; i < query.getDims().size(); i++) {
+ drillSidewaysCollectorOwners.add(
+ CollectorOwner.hire(createDrillSidewaysFacetsCollectorManager()));
+ }
+ } else {
+ drillSidewaysCollectorOwners = null;
+ }
+ // Execute query
if (executor != null) {
- return searchConcurrently(query, hitCollectorManager);
+ searchConcurrently(query, mainCollectorOwner,
drillSidewaysCollectorOwners);
+ } else {
+ searchSequentially(query, mainCollectorOwner,
drillSidewaysCollectorOwners);
+ }
+
+ // Collect results
+ final FacetsCollector facetsCollectorResult;
+ final R hitCollectorResult;
+ if (drillDownFacetsCollectorManager != null) {
+ // drill down collected using MultiCollector
+ // Extract the results:
+ Object[] drillDownResult = (Object[]) mainCollectorOwner.reduce();
+ facetsCollectorResult = (FacetsCollector) drillDownResult[0];
+ hitCollectorResult = (R) drillDownResult[1];
+ } else {
+ facetsCollectorResult = null;
+ hitCollectorResult = (R) mainCollectorOwner.reduce();
+ }
+
+ // Getting results for drill sideways dimensions (if any)
+ final String[] drillSidewaysDims;
+ final FacetsCollector[] drillSidewaysCollectors;
+ if (query.getDims().isEmpty() == false) {
+ drillSidewaysDims = query.getDims().keySet().toArray(new String[0]);
+ int numDims = query.getDims().size();
+ assert drillSidewaysCollectorOwners != null;
+ assert drillSidewaysCollectorOwners.size() == numDims;
+ drillSidewaysCollectors = new FacetsCollector[numDims];
+ for (int dim = 0; dim < numDims; dim++) {
+ drillSidewaysCollectors[dim] =
+ (FacetsCollector) drillSidewaysCollectorOwners.get(dim).reduce();
+ }
} else {
- return searchSequentially(query, hitCollectorManager);
+ drillSidewaysDims = null;
+ drillSidewaysCollectors = null;
}
+
+ return new ConcurrentDrillSidewaysResult<>(
+ buildFacetsResult(facetsCollectorResult, drillSidewaysCollectors,
drillSidewaysDims),
+ null,
+ hitCollectorResult,
+ facetsCollectorResult,
+ drillSidewaysCollectors,
+ drillSidewaysDims);
}
- @SuppressWarnings("unchecked")
- private <R> ConcurrentDrillSidewaysResult<R> searchSequentially(
- final DrillDownQuery query, final CollectorManager<?, R>
hitCollectorManager)
+ /**
+ * Search using DrillDownQuery with custom collectors. This method can be
used with any {@link
+ * CollectorOwner}s. It doesn't return anything because it is expected that
you read results from
+ * provided {@link CollectorOwner}s.
+ *
+ * <p>To read the results, run {@link CollectorOwner#reduce()} for drill
down and all drill
+ * sideways dimensions.
+ *
+ * <p>If {@code doReduce} is set to true, this method itself calls {@link
+ * CollectorOwner#reduce()}. Note that results of the call are not returned
by this method, so you
+ * can only do that if there is some other way of accessing results from the
reduce call.
+ *
+ * <p>Note: use {@link Collections#unmodifiableList(List)} to wrap {@code
+ * drillSidewaysCollectorOwners} to convince compiler that it is safe to use
List here.
+ *
+ * <p>TODO: Class CollectorOwner was created so that we can ignore
CollectorManager type C,
+ * because we want each dimensions to be able to use their own types.
Alternatively, we can use
+ * typesafe heterogeneous container and provide CollectorManager type for
each dimension to this
+ * method? I do like CollectorOwner approach as it seems more intuitive?
+ *
+ * <p>TODO: deprecate doReduce - always reduce, {@link
CollectorOwner#getResult()} can be used by
Review Comment:
I'll remove `doReduce` param and change `CollectorOwner` to only have
`getResults` method (no `reduce`) as you suggested above in the next iteration;
unless there are other suggestions.
--
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]
