src/Core/Framework/DataAbstractionLayer/Dbal/EntityAggregator.php line 187

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\DataAbstractionLayer\Dbal;
  5. use Doctrine\DBAL\Connection;
  6. use Shopware\Core\Framework\Context;
  7. use Shopware\Core\Framework\DataAbstractionLayer\DefinitionInstanceRegistry;
  8. use Shopware\Core\Framework\DataAbstractionLayer\EntityCollection;
  9. use Shopware\Core\Framework\DataAbstractionLayer\EntityDefinition;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Exception\InvalidAggregationQueryException;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Field\AssociationField;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Field\Field;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Field\FkField;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\PrimaryKey;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Field\FloatField;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Field\IdField;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Field\IntField;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToManyAssociationField;
  19. use Shopware\Core\Framework\DataAbstractionLayer\Field\OneToManyAssociationField;
  20. use Shopware\Core\Framework\DataAbstractionLayer\Field\PriceField;
  21. use Shopware\Core\Framework\DataAbstractionLayer\Field\StorageAware;
  22. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Aggregation;
  23. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Bucket\BucketAggregation;
  24. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Bucket\DateHistogramAggregation;
  25. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Bucket\FilterAggregation;
  26. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Bucket\TermsAggregation;
  27. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\AvgAggregation;
  28. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\CountAggregation;
  29. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\EntityAggregation;
  30. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\MaxAggregation;
  31. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\MinAggregation;
  32. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\RangeAggregation;
  33. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\StatsAggregation;
  34. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\SumAggregation;
  35. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\AggregationResult;
  36. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\AggregationResultCollection;
  37. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Bucket\Bucket;
  38. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Bucket\DateHistogramResult;
  39. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Bucket\TermsResult;
  40. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Metric\AvgResult;
  41. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Metric\CountResult;
  42. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Metric\EntityResult;
  43. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Metric\MaxResult;
  44. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Metric\MinResult;
  45. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Metric\RangeResult;
  46. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Metric\StatsResult;
  47. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Metric\SumResult;
  48. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  49. use Shopware\Core\Framework\DataAbstractionLayer\Search\EntityAggregatorInterface;
  50. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\MultiFilter;
  51. use Shopware\Core\Framework\DataAbstractionLayer\Search\Sorting\FieldSorting;
  52. use Shopware\Core\Framework\DataAbstractionLayer\Search\Term\EntityScoreQueryBuilder;
  53. use Shopware\Core\Framework\DataAbstractionLayer\Search\Term\SearchTermInterpreter;
  54. use Shopware\Core\Framework\Log\Package;
  56. /**
  57.  * Allows to execute aggregated queries for all entities in the system
  58.  *
  59.  * @internal
  60.  */
  61. #[Package('core')]
  62. class EntityAggregator implements EntityAggregatorInterface
  63. {
  64.     public function __construct(
  65.         private readonly Connection $connection,
  66.         private readonly EntityDefinitionQueryHelper $queryHelper,
  67.         private readonly DefinitionInstanceRegistry $registry,
  68.         private readonly CriteriaQueryBuilder $criteriaQueryBuilder,
  69.         private readonly bool $timeZoneSupportEnabled,
  70.         private readonly SearchTermInterpreter $interpreter,
  71.         private readonly EntityScoreQueryBuilder $scoreBuilder
  72.     ) {
  73.     }
  75.     public function aggregate(EntityDefinition $definition, Criteria $criteria, Context $context): AggregationResultCollection
  76.     {
  77.         $aggregations = new AggregationResultCollection();
  78.         foreach ($criteria->getAggregations() as $aggregation) {
  79.             $result = $this->fetchAggregation($aggregation, $definition, $criteria, $context);
  80.             $aggregations->add($result);
  81.         }
  83.         return $aggregations;
  84.     }
  86.     public static function formatDate(string $interval, \DateTime $date): string
  87.     {
  88.         switch ($interval) {
  89.             case DateHistogramAggregation::PER_MINUTE:
  90.                 return $date->format('Y-m-d H:i:00');
  91.             case DateHistogramAggregation::PER_HOUR:
  92.                 return $date->format('Y-m-d H:00:00');
  93.             case DateHistogramAggregation::PER_DAY:
  94.                 return $date->format('Y-m-d 00:00:00');
  95.             case DateHistogramAggregation::PER_WEEK:
  96.                 return $date->format('Y W');
  97.             case DateHistogramAggregation::PER_MONTH:
  98.                 return $date->format('Y-m-01 00:00:00');
  99.             case DateHistogramAggregation::PER_QUARTER:
  100.                 $month = (int) $date->format('m');
  102.                 return $date->format('Y') . ' ' . ceil($month / 3);
  103.             case DateHistogramAggregation::PER_YEAR:
  104.                 return $date->format('Y-01-01 00:00:00');
  105.             default:
  106.                 throw new \RuntimeException('Provided date format is not supported');
  107.         }
  108.     }
  110.     private function fetchAggregation(Aggregation $aggregation, EntityDefinition $definition, Criteria $criteria, Context $context): AggregationResult
  111.     {
  112.         $clone = clone $criteria;
  113.         $clone->resetAggregations();
  114.         $clone->resetSorting();
  115.         $clone->resetPostFilters();
  116.         $clone->resetGroupFields();
  118.         // Early resolve terms to extract score queries
  119.         if ($clone->getTerm()) {
  120.             $pattern = $this->interpreter->interpret((string) $criteria->getTerm());
  121.             $queries = $this->scoreBuilder->buildScoreQueries($pattern, $definition, $definition->getEntityName(), $context);
  122.             $clone->addQuery(...$queries);
  123.             $clone->setTerm(null);
  124.         }
  126.         $scoreCritera = clone $clone;
  127.         $clone->resetQueries();
  129.         $query = new QueryBuilder($this->connection);
  131.         // If an aggregation is to be created on a to many association that is already stored as a filter.
  132.         // The association is therefore referenced twice in the query and would have to be created as a sub-join in each case. But since only the filters are considered, the association is referenced only once.
  133.         // In this case we add the aggregation field as path to the criteria builder and the join group builder will consider this path for the sub-join logic
  134.         $paths = array_filter([$this->findToManyPath($aggregation, $definition)]);
  136.         $query = $this->criteriaQueryBuilder->build($query, $definition, $clone, $context, $paths);
  137.         $query->resetQueryPart('orderBy');
  139.         if ($criteria->getTitle()) {
  140.             $query->setTitle($criteria->getTitle() . '::aggregation::' . $aggregation->getName());
  141.         }
  143.         $this->queryHelper->addIdCondition($criteria, $definition, $query);
  145.         $table = $definition->getEntityName();
  147.         if (\count($scoreCritera->getQueries()) > 0) {
  148.             $escapedTable = EntityDefinitionQueryHelper::escape($table);
  149.             $scoreQuery = new QueryBuilder($this->connection);
  151.             $scoreQuery = $this->criteriaQueryBuilder->build($scoreQuery, $definition, $scoreCritera, $context, $paths);
  152.             $pks = $definition->getFields()->filterByFlag(PrimaryKey::class)->map(fn (StorageAware $f) => $f->getStorageName());
  154.             $join = '';
  155.             foreach ($pks as $pk) {
  156.                 $scoreQuery->addGroupBy($pk);
  158.                 $pk = EntityDefinitionQueryHelper::escape($pk);
  159.                 $scoreQuery->addSelect($escapedTable . '.' . $pk);
  161.                 $join .= \sprintf('score_table.%s = %s.%s AND ', $pk, $escapedTable, $pk);
  162.             }
  164.             // Remove remaining AND
  165.             $join = substr($join, 0, -4);
  167.             foreach ($scoreQuery->getParameters() as $key => $value) {
  168.                 $query->setParameter($key, $value, $scoreQuery->getParameterType($key));
  169.             }
  171.             $query->join(
  172.                 EntityDefinitionQueryHelper::escape($table),
  173.                 '(' . $scoreQuery->getSQL() . ')',
  174.                 'score_table',
  175.                 $join
  176.             );
  177.         }
  179.         foreach ($aggregation->getFields() as $fieldName) {
  180.             $this->queryHelper->resolveAccessor($fieldName, $definition, $table, $query, $context, $aggregation);
  181.         }
  183.         $query->resetQueryPart('groupBy');
  185.         $this->extendQuery($aggregation, $query, $definition, $context);
  187.         $rows = $query->executeQuery()->fetchAllAssociative();
  189.         return $this->hydrateResult($aggregation, $definition, $rows, $context);
  190.     }
  192.     private function findToManyPath(Aggregation $aggregation, EntityDefinition $definition): ?string
  193.     {
  194.         $fields = EntityDefinitionQueryHelper::getFieldsOfAccessor($definition, $aggregation->getField(), false);
  196.         if (\count($fields) === 0) {
  197.             return null;
  198.         }
  200.         // contains later the path to the first to many association
  201.         $path = [$definition->getEntityName()];
  203.         $found = false;
  205.         /** @var Field $field */
  206.         foreach ($fields as $field) {
  207.             if (!($field instanceof AssociationField)) {
  208.                 break;
  209.             }
  211.             // if to many not already detected, continue with path building
  212.             $path[] = $field->getPropertyName();
  214.             if ($field instanceof ManyToManyAssociationField || $field instanceof OneToManyAssociationField) {
  215.                 $found = true;
  216.             }
  217.         }
  219.         if ($found) {
  220.             return implode('.', $path);
  221.         }
  223.         return null;
  224.     }
  226.     private function extendQuery(Aggregation $aggregation, QueryBuilder $query, EntityDefinition $definition, Context $context): void
  227.     {
  228.         match (true) {
  229.             $aggregation instanceof DateHistogramAggregation => $this->parseDateHistogramAggregation($aggregation, $query, $definition, $context),
  230.             $aggregation instanceof TermsAggregation => $this->parseTermsAggregation($aggregation, $query, $definition, $context),
  231.             $aggregation instanceof FilterAggregation => $this->parseFilterAggregation($aggregation, $query, $definition, $context),
  232.             $aggregation instanceof AvgAggregation => $this->parseAvgAggregation($aggregation, $query, $definition, $context),
  233.             $aggregation instanceof SumAggregation => $this->parseSumAggregation($aggregation, $query, $definition, $context),
  234.             $aggregation instanceof MaxAggregation => $this->parseMaxAggregation($aggregation, $query, $definition, $context),
  235.             $aggregation instanceof MinAggregation => $this->parseMinAggregation($aggregation, $query, $definition, $context),
  236.             $aggregation instanceof CountAggregation => $this->parseCountAggregation($aggregation, $query, $definition, $context),
  237.             $aggregation instanceof StatsAggregation => $this->parseStatsAggregation($aggregation, $query, $definition, $context),
  238.             $aggregation instanceof EntityAggregation => $this->parseEntityAggregation($aggregation, $query, $definition, $context),
  239.             $aggregation instanceof RangeAggregation => $this->parseRangeAggregation($aggregation, $query, $definition, $context),
  240.             default => throw new InvalidAggregationQueryException(sprintf('Aggregation of type %s not supported', $aggregation::class)),
  241.         };
  242.     }
  244.     private function parseFilterAggregation(FilterAggregation $aggregation, QueryBuilder $query, EntityDefinition $definition, Context $context): void
  245.     {
  246.         if (!empty($aggregation->getFilter())) {
  247.             $this->criteriaQueryBuilder->addFilter($definition, new MultiFilter(MultiFilter::CONNECTION_AND, $aggregation->getFilter()), $query, $context);
  248.         }
  250.         /** @var Aggregation $aggregationStruct FilterAggregations always have an aggregation */
  251.         $aggregationStruct = $aggregation->getAggregation();
  253.         $this->extendQuery($aggregationStruct, $query, $definition, $context);
  254.     }
  256.     private function parseDateHistogramAggregation(DateHistogramAggregation $aggregation, QueryBuilder $query, EntityDefinition $definition, Context $context): void
  257.     {
  258.         $accessor = $this->queryHelper->getFieldAccessor($aggregation->getField(), $definition, $definition->getEntityName(), $context);
  260.         if ($this->timeZoneSupportEnabled && $aggregation->getTimeZone()) {
  261.             $accessor = 'CONVERT_TZ(' . $accessor . ', "UTC", "' . $aggregation->getTimeZone() . '")';
  262.         }
  264.         $groupBy = match ($aggregation->getInterval()) {
  265.             DateHistogramAggregation::PER_MINUTE => 'DATE_FORMAT(' . $accessor . ', \'%Y-%m-%d %H:%i\')',
  266.             DateHistogramAggregation::PER_HOUR => 'DATE_FORMAT(' . $accessor . ', \'%Y-%m-%d %H\')',
  267.             DateHistogramAggregation::PER_DAY => 'DATE_FORMAT(' . $accessor . ', \'%Y-%m-%d\')',
  268.             DateHistogramAggregation::PER_WEEK => 'DATE_FORMAT(' . $accessor . ', \'%Y-%v\')',
  269.             DateHistogramAggregation::PER_MONTH => 'DATE_FORMAT(' . $accessor . ', \'%Y-%m\')',
  270.             DateHistogramAggregation::PER_QUARTER => 'CONCAT(DATE_FORMAT(' . $accessor . ', \'%Y\'), \'-\', QUARTER(' . $accessor . '))',
  271.             DateHistogramAggregation::PER_YEAR => 'DATE_FORMAT(' . $accessor . ', \'%Y\')',
  272.             default => throw new \RuntimeException('Provided date format is not supported'),
  273.         };
  274.         $query->addGroupBy($groupBy);
  276.         $key = $aggregation->getName() . '.key';
  277.         $query->addSelect(sprintf('MIN(%s) as `%s`', $accessor, $key));
  279.         $key = $aggregation->getName() . '.count';
  280.         $countAccessor = $this->queryHelper->getFieldAccessor('id', $definition, $definition->getEntityName(), $context);
  281.         $query->addSelect(sprintf('COUNT(%s) as `%s`', $countAccessor, $key));
  283.         if ($aggregation->getSorting()) {
  284.             $this->addSorting($aggregation->getSorting(), $definition, $query, $context);
  285.         } else {
  286.             $query->addOrderBy($accessor);
  287.         }
  289.         if ($aggregation->getAggregation()) {
  290.             $this->extendQuery($aggregation->getAggregation(), $query, $definition, $context);
  291.         }
  292.     }
  294.     private function parseTermsAggregation(TermsAggregation $aggregation, QueryBuilder $query, EntityDefinition $definition, Context $context): void
  295.     {
  296.         $keyAccessor = $this->queryHelper->getFieldAccessor($aggregation->getField(), $definition, $definition->getEntityName(), $context);
  297.         $query->addGroupBy($keyAccessor);
  299.         $key = $aggregation->getName() . '.key';
  301.         $field = $this->queryHelper->getField($aggregation->getField(), $definition, $definition->getEntityName());
  302.         if ($field instanceof FkField || $field instanceof IdField) {
  303.             $keyAccessor = 'LOWER(HEX(' . $keyAccessor . '))';
  304.         }
  306.         $query->addSelect(sprintf('%s as `%s`', $keyAccessor, $key));
  308.         $key = $aggregation->getName() . '.count';
  310.         $countAccessor = $this->queryHelper->getFieldAccessor('id', $definition, $definition->getEntityName(), $context);
  311.         $query->addSelect(sprintf('COUNT(%s) as `%s`', $countAccessor, $key));
  313.         if ($aggregation->getLimit()) {
  314.             $query->setMaxResults($aggregation->getLimit());
  315.         }
  317.         if ($aggregation->getSorting()) {
  318.             $this->addSorting($aggregation->getSorting(), $definition, $query, $context);
  319.         }
  321.         if ($aggregation->getAggregation()) {
  322.             $this->extendQuery($aggregation->getAggregation(), $query, $definition, $context);
  323.         }
  324.     }
  326.     private function parseAvgAggregation(AvgAggregation $aggregation, QueryBuilder $query, EntityDefinition $definition, Context $context): void
  327.     {
  328.         $accessor = $this->queryHelper->getFieldAccessor($aggregation->getField(), $definition, $definition->getEntityName(), $context);
  330.         $query->addSelect(sprintf('AVG(%s) as `%s`', $accessor, $aggregation->getName()));
  331.     }
  333.     private function parseSumAggregation(SumAggregation $aggregation, QueryBuilder $query, EntityDefinition $definition, Context $context): void
  334.     {
  335.         $accessor = $this->queryHelper->getFieldAccessor($aggregation->getField(), $definition, $definition->getEntityName(), $context);
  337.         $query->addSelect(sprintf('SUM(%s) as `%s`', $accessor, $aggregation->getName()));
  338.     }
  340.     private function parseMaxAggregation(MaxAggregation $aggregation, QueryBuilder $query, EntityDefinition $definition, Context $context): void
  341.     {
  342.         $accessor = $this->queryHelper->getFieldAccessor($aggregation->getField(), $definition, $definition->getEntityName(), $context);
  344.         $query->addSelect(sprintf('MAX(%s) as `%s`', $accessor, $aggregation->getName()));
  345.     }
  347.     private function parseMinAggregation(MinAggregation $aggregation, QueryBuilder $query, EntityDefinition $definition, Context $context): void
  348.     {
  349.         $accessor = $this->queryHelper->getFieldAccessor($aggregation->getField(), $definition, $definition->getEntityName(), $context);
  351.         $query->addSelect(sprintf('MIN(%s) as `%s`', $accessor, $aggregation->getName()));
  352.     }
  354.     private function parseCountAggregation(CountAggregation $aggregation, QueryBuilder $query, EntityDefinition $definition, Context $context): void
  355.     {
  356.         $accessor = $this->queryHelper->getFieldAccessor($aggregation->getField(), $definition, $definition->getEntityName(), $context);
  358.         $query->addSelect(sprintf('COUNT(DISTINCT %s) as `%s`', $accessor, $aggregation->getName()));
  359.     }
  361.     private function parseStatsAggregation(StatsAggregation $aggregation, QueryBuilder $query, EntityDefinition $definition, Context $context): void
  362.     {
  363.         $accessor = $this->queryHelper->getFieldAccessor($aggregation->getField(), $definition, $definition->getEntityName(), $context);
  365.         if ($aggregation->fetchAvg()) {
  366.             $query->addSelect(sprintf('AVG(%s) as `%s.avg`', $accessor, $aggregation->getName()));
  367.         }
  368.         if ($aggregation->fetchMin()) {
  369.             $query->addSelect(sprintf('MIN(%s) as `%s.min`', $accessor, $aggregation->getName()));
  370.         }
  371.         if ($aggregation->fetchMax()) {
  372.             $query->addSelect(sprintf('MAX(%s) as `%s.max`', $accessor, $aggregation->getName()));
  373.         }
  374.         if ($aggregation->fetchSum()) {
  375.             $query->addSelect(sprintf('SUM(%s) as `%s.sum`', $accessor, $aggregation->getName()));
  376.         }
  377.     }
  379.     private function parseRangeAggregation(RangeAggregation $aggregation, QueryBuilder $query, EntityDefinition $definition, Context $context): void
  380.     {
  381.         $accessor = $this->queryHelper->getFieldAccessor($aggregation->getField(), $definition, $definition->getEntityName(), $context);
  382.         $field = $this->queryHelper->getField($aggregation->getField(), $definition, $definition->getEntityName());
  383.         if (!$field instanceof PriceField && !$field instanceof FloatField && !$field instanceof IntField) {
  384.             throw new \RuntimeException(sprintf('Provided field "%s" is not supported in RangeAggregation (supports : PriceField, FloatField, IntField)', $aggregation->getField()));
  385.         }
  386.         // build SUM() with range criteria for each range and add it to select
  387.         foreach ($aggregation->getRanges() as $range) {
  388.             $id = $range['key'] ?? (($range['from'] ?? '*') . '-' . ($range['to'] ?? '*'));
  389.             $sum = '1';
  390.             if (isset($range['from'])) {
  391.                 $sum .= sprintf(' AND %s >= %f', $accessor, $range['from']);
  392.             }
  393.             if (isset($range['to'])) {
  394.                 $sum .= sprintf(' AND %s < %f', $accessor, $range['to']);
  395.             }
  397.             $query->addSelect(sprintf('SUM(%s) as `%s.%s`', $sum, $aggregation->getName(), $id));
  398.         }
  399.     }
  401.     private function parseEntityAggregation(EntityAggregation $aggregation, QueryBuilder $query, EntityDefinition $definition, Context $context): void
  402.     {
  403.         $accessor = $this->queryHelper->getFieldAccessor($aggregation->getField(), $definition, $definition->getEntityName(), $context);
  404.         $query->addGroupBy($accessor);
  406.         $accessor = 'LOWER(HEX(' . $accessor . '))';
  407.         $query->addSelect(sprintf('%s as `%s`', $accessor, $aggregation->getName()));
  408.     }
  410.     /**
  411.      * @param array<mixed> $rows
  412.      */
  413.     private function hydrateResult(Aggregation $aggregation, EntityDefinition $definition, array $rows, Context $context): AggregationResult
  414.     {
  415.         $name = $aggregation->getName();
  417.         switch (true) {
  418.             case $aggregation instanceof DateHistogramAggregation:
  420.                 return $this->hydrateDateHistogramAggregation($aggregation, $definition, $rows, $context);
  422.             case $aggregation instanceof TermsAggregation:
  424.                 return $this->hydrateTermsAggregation($aggregation, $definition, $rows, $context);
  426.             case $aggregation instanceof FilterAggregation:
  427.                 /** @var Aggregation $aggregationStruct FilterAggregations always have an aggregation */
  428.                 $aggregationStruct = $aggregation->getAggregation();
  430.                 return $this->hydrateResult($aggregationStruct, $definition, $rows, $context);
  432.             case $aggregation instanceof AvgAggregation:
  433.                 $value = isset($rows[0]) ? $rows[0][$name] : 0;
  435.                 return new AvgResult($aggregation->getName(), (float) $value);
  437.             case $aggregation instanceof SumAggregation:
  438.                 $value = isset($rows[0]) ? $rows[0][$name] : 0;
  440.                 return new SumResult($aggregation->getName(), (float) $value);
  442.             case $aggregation instanceof MaxAggregation:
  443.                 $value = isset($rows[0]) ? $rows[0][$name] : 0;
  445.                 return new MaxResult($aggregation->getName(), $value);
  447.             case $aggregation instanceof MinAggregation:
  448.                 $value = isset($rows[0]) ? $rows[0][$name] : 0;
  450.                 return new MinResult($aggregation->getName(), $value);
  452.             case $aggregation instanceof CountAggregation:
  453.                 $value = isset($rows[0]) ? $rows[0][$name] : 0;
  455.                 return new CountResult($aggregation->getName(), (int) $value);
  457.             case $aggregation instanceof StatsAggregation:
  458.                 if (empty($rows)) {
  459.                     return new StatsResult($aggregation->getName(), 0, 0, 0.0, 0.0);
  460.                 }
  462.                 $min = $rows[0][$name . '.min'] ?? null;
  463.                 $max = $rows[0][$name . '.max'] ?? null;
  464.                 $avg = isset($rows[0][$name . '.avg']) ? (float) $rows[0][$name . '.avg'] : null;
  465.                 $sum = isset($rows[0][$name . '.sum']) ? (float) $rows[0][$name . '.sum'] : null;
  467.                 return new StatsResult($aggregation->getName(), $min, $max, $avg, $sum);
  469.             case $aggregation instanceof EntityAggregation:
  471.                 return $this->hydrateEntityAggregation($aggregation, $rows, $context);
  472.             case $aggregation instanceof RangeAggregation:
  473.                 return $this->hydrateRangeAggregation($aggregation, $rows);
  474.             default:
  475.                 throw new InvalidAggregationQueryException(sprintf('Aggregation of type %s not supported', $aggregation::class));
  476.         }
  477.     }
  479.     /**
  480.      * @param array<mixed> $rows
  481.      */
  482.     private function hydrateEntityAggregation(EntityAggregation $aggregation, array $rows, Context $context): EntityResult
  483.     {
  484.         $ids = array_filter(array_column($rows, $aggregation->getName()));
  486.         if (empty($ids)) {
  487.             return new EntityResult($aggregation->getName(), new EntityCollection());
  488.         }
  490.         $repository = $this->registry->getRepository($aggregation->getEntity());
  492.         $criteria = new Criteria($ids);
  493.         $criteria->setTitle($aggregation->getName() . '-aggregation');
  495.         $entities = $repository->search($criteria, $context);
  497.         return new EntityResult($aggregation->getName(), $entities->getEntities());
  498.     }
  500.     /**
  501.      * @param array<mixed> $rows
  502.      */
  503.     private function hydrateDateHistogramAggregation(DateHistogramAggregation $aggregation, EntityDefinition $definition, array $rows, Context $context): DateHistogramResult
  504.     {
  505.         if (empty($rows)) {
  506.             return new DateHistogramResult($aggregation->getName(), []);
  507.         }
  509.         $buckets = [];
  511.         $grouped = $this->groupBuckets($aggregation, $rows);
  513.         foreach ($grouped as $value => $group) {
  514.             $count = $group['count'];
  515.             $nested = null;
  517.             if ($aggregation->getAggregation()) {
  518.                 $nested = $this->hydrateResult($aggregation->getAggregation(), $definition, $group['buckets'], $context);
  519.             }
  521.             $date = new \DateTime($value);
  523.             if ($aggregation->getFormat()) {
  524.                 $value = $date->format($aggregation->getFormat());
  525.             } else {
  526.                 $value = self::formatDate($aggregation->getInterval(), $date);
  527.             }
  529.             $buckets[] = new Bucket($value, $count, $nested);
  530.         }
  532.         return new DateHistogramResult($aggregation->getName(), $buckets);
  533.     }
  535.     /**
  536.      * @param array<mixed> $rows
  537.      */
  538.     private function hydrateTermsAggregation(TermsAggregation $aggregation, EntityDefinition $definition, array $rows, Context $context): TermsResult
  539.     {
  540.         $buckets = [];
  542.         $grouped = $this->groupBuckets($aggregation, $rows);
  544.         foreach ($grouped as $value => $group) {
  545.             $count = $group['count'];
  546.             $nested = null;
  548.             if ($aggregation->getAggregation()) {
  549.                 $nested = $this->hydrateResult($aggregation->getAggregation(), $definition, $group['buckets'], $context);
  550.             }
  552.             $buckets[] = new Bucket((string) $value, $count, $nested);
  553.         }
  555.         return new TermsResult($aggregation->getName(), $buckets);
  556.     }
  558.     private function addSorting(FieldSorting $sorting, EntityDefinition $definition, QueryBuilder $query, Context $context): void
  559.     {
  560.         if ($sorting->getField() !== '_count') {
  561.             $this->criteriaQueryBuilder->addSortings($definition, new Criteria(), [$sorting], $query, $context);
  563.             return;
  564.         }
  566.         $countAccessor = $this->queryHelper->getFieldAccessor('id', $definition, $definition->getEntityName(), $context);
  567.         $countAccessor = sprintf('COUNT(%s)', $countAccessor);
  569.         $direction = $sorting->getDirection() === FieldSorting::ASCENDING ? FieldSorting::ASCENDING : FieldSorting::DESCENDING;
  571.         $query->addOrderBy($countAccessor, $direction);
  572.     }
  574.     /**
  575.      * @param array<mixed> $rows
  576.      *
  577.      * @return array<array{ count: int, buckets: list<mixed>}>
  578.      */
  579.     private function groupBuckets(BucketAggregation $aggregation, array $rows): array
  580.     {
  581.         $valueKey = $aggregation->getName() . '.key';
  583.         $countKey = $aggregation->getName() . '.count';
  585.         $grouped = [];
  586.         foreach ($rows as $row) {
  587.             $value = $row[$valueKey];
  588.             $count = (int) $row[$countKey];
  590.             if (isset($grouped[$value])) {
  591.                 $grouped[$value]['count'] += $count;
  592.             } else {
  593.                 $grouped[$value] = ['count' => $count, 'buckets' => []];
  594.             }
  596.             if ($aggregation->getAggregation()) {
  597.                 $grouped[$value]['buckets'][] = $row;
  598.             }
  599.         }
  601.         return $grouped;
  602.     }
  604.     /**
  605.      * @param array<array<string,string>> $rows
  606.      */
  607.     private function hydrateRangeAggregation(RangeAggregation $aggregation, array $rows): RangeResult
  608.     {
  609.         $ranges = [];
  611.         $row = array_shift($rows);
  612.         if ($row) {
  613.             foreach ($aggregation->getRanges() as $range) {
  614.                 $ranges[(string) $range['key']] = (int) $row[sprintf('%s.%s', $aggregation->getName(), $range['key'])];
  615.             }
  616.         }
  618.         return new RangeResult($aggregation->getName(), $ranges);
  619.     }
  620. }