aggr.Merge(&disk)
		}
		m.Aggregated.Disk = &aggr
	}

	if types.Contains(madmin.MetricsScanner) {
		metrics := globalScannerMetrics.report()
		m.Aggregated.Scanner = &metrics
	}
	if types.Contains(madmin.MetricsOS) {
		metrics := globalOSMetrics.report()
		m.Aggregated.OS = &metrics
	}
	if types.Contains(madmin.MetricsBatchJobs) {
		m.Aggregated.BatchJobs = globalBatchJobsMetrics.report(opts.jobID)
	}

    protected final long queryTime;

    /** Flag indicating whether the search results are partial due to timeout or other constraints. */
    protected final boolean partialResults;

    /** The facet response containing aggregated facet information for the search results. */
    protected final FacetResponse facetResponse;

    /**
     * Constructs a new SearchResult with the specified parameters.
     *

 * if some elements are too small, they will be aggregated by smallElementAggregateFunction.
 *
 * @param list the list to split, must be ordered by size desc
 * @param toIntFunction the function used to map the element to its "size"
 * @param largeElementSplitFunction the function used to further split the large element into smaller pieces
 * @param smallElementAggregateFunction the function used to aggregate tiny elements into a large bucket

     * and values are document counts for each query.
     */
    protected Map<String, Long> queryCountMap = new LinkedHashMap<>();

    /**
     * List of field facets containing aggregated field values and their counts.
     */
    protected List<Field> fieldList = new ArrayList<>();

    /**
     * Constructs a FacetResponse from OpenSearch aggregations.

		return []*Record{&input}, nil
	}
	return nil, errDataSource(errors.New("unexpected non JSON input"))
}

// IsAggregated returns if the statement involves SQL aggregation
func (e *SelectStatement) IsAggregated() bool {
	return e.selectQProp.isAggregation
}

// AggregateResult - returns the aggregated result after all input
// records have been processed. Applies only to aggregation queries.

		return e.aggregate.runningSum, err

	case aggFnMin:
		if !e.aggregate.seen {
			// No rows were seen by MIN
			return FromNull(), nil
		}
		return e.aggregate.runningMin, nil

	case aggFnMax:
		if !e.aggregate.seen {
			// No rows were seen by MAX
			return FromNull(), nil
		}
		return e.aggregate.runningMax, nil

	case aggFnSum:
		// TODO: check if returning 0 when no rows were seen

                </tag>
              </tags>
            </configuration>
            <reportSets>
              <reportSet>
                <id>aggregate</id>
                <reports>
                  <report>aggregate</report>
                </reports>
                <inherited>false</inherited>
              </reportSet>
            </reportSets>
          </plugin>
          <plugin>

        msgs.add("* An aggregator Mojo is already executing in parallel build,    *");
        msgs.add("* but aggregator Mojos require exclusive access to reactor to   *");
        msgs.add("* prevent race conditions. This mojo execution will be blocked  *");
        msgs.add("* until the aggregator work is done.                            *");

      <requiresDirectInvocation>false</requiresDirectInvocation>
      <requiresProject>true</requiresProject>
      <requiresReports>false</requiresReports>
      <aggregator>false</aggregator>
      <requiresOnline>false</requiresOnline>
      <inheritedByDefault>true</inheritedByDefault>
      <phase>package</phase>
      <implementation>org.apache.maven.plugin.jar.JarMojo</implementation>

Guillaume Nodet <******@****.***> 1729859506 +0200