vendor/shopware/core/Framework/DataAbstractionLayer/Dbal/CriteriaQueryBuilder.php line 72

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\DataAbstractionLayer\Dbal;
  5. use Shopware\Core\Framework\Context;
  6. use Shopware\Core\Framework\DataAbstractionLayer\Dbal\Exception\InvalidSortingDirectionException;
  7. use Shopware\Core\Framework\DataAbstractionLayer\Dbal\FieldResolver\CriteriaPartResolver;
  8. use Shopware\Core\Framework\DataAbstractionLayer\EntityDefinition;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Field\StorageAware;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\AndFilter;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\Filter;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Search\Parser\SqlQueryParser;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Search\Query\ScoreQuery;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Search\Sorting\CountSorting;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Search\Sorting\FieldSorting;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Search\Term\EntityScoreQueryBuilder;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Search\Term\SearchTermInterpreter;
  19. use Shopware\Core\Framework\Log\Package;
  21. /**
  22.  * @internal
  23.  */
  24. #[Package('core')]
  25. class CriteriaQueryBuilder
  26. {
  27.     public function __construct(
  28.         private readonly SqlQueryParser $parser,
  29.         /***
  30.          * @var EntityDefinitionQueryHelper
  31.          */
  32.         private readonly EntityDefinitionQueryHelper $helper,
  33.         private readonly SearchTermInterpreter $interpreter,
  34.         private readonly EntityScoreQueryBuilder $scoreBuilder,
  35.         private readonly JoinGroupBuilder $joinGrouper,
  36.         private readonly CriteriaPartResolver $criteriaPartResolver
  37.     ) {
  38.     }
  40.     public function build(QueryBuilder $query, EntityDefinition $definition, Criteria $criteria, Context $context, array $paths = []): QueryBuilder
  41.     {
  42.         $query = $this->helper->getBaseQuery($query, $definition, $context);
  44.         if ($definition->isInheritanceAware() && $context->considerInheritance()) {
  45.             $parent = $definition->getFields()->get('parent');
  47.             if ($parent) {
  48.                 $this->helper->resolveField($parent, $definition, $definition->getEntityName(), $query, $context);
  49.             }
  50.         }
  52.         if ($criteria->getTerm()) {
  53.             $pattern = $this->interpreter->interpret((string) $criteria->getTerm());
  54.             $queries = $this->scoreBuilder->buildScoreQueries($pattern, $definition, $definition->getEntityName(), $context);
  55.             $criteria->addQuery(...$queries);
  56.         }
  58.         $filters = $this->groupFilters($definition, $criteria, $paths);
  60.         $this->criteriaPartResolver->resolve($filters, $definition, $query, $context);
  62.         $this->criteriaPartResolver->resolve($criteria->getQueries(), $definition, $query, $context);
  64.         $this->criteriaPartResolver->resolve($criteria->getSorting(), $definition, $query, $context);
  66.         // do not use grouped filters, because the grouped filters are mapped flat and the logical OR/AND are removed
  67.         $filter = new AndFilter(array_merge(
  68.             $criteria->getFilters(),
  69.             $criteria->getPostFilters()
  70.         ));
  72.         $this->addFilter($definition, $filter, $query, $context);
  74.         $this->addQueries($definition, $criteria, $query, $context);
  76.         if ($criteria->getLimit() === 1) {
  77.             $query->removeState(EntityDefinitionQueryHelper::HAS_TO_MANY_JOIN);
  78.         }
  80.         $this->addSortings($definition, $criteria, $criteria->getSorting(), $query, $context);
  82.         return $query;
  83.     }
  85.     public function addFilter(EntityDefinition $definition, ?Filter $filter, QueryBuilder $query, Context $context): void
  86.     {
  87.         if (!$filter) {
  88.             return;
  89.         }
  91.         $parsed = $this->parser->parse($filter, $definition, $context);
  93.         if (empty($parsed->getWheres())) {
  94.             return;
  95.         }
  97.         $query->andWhere(implode(' AND ', $parsed->getWheres()));
  98.         foreach ($parsed->getParameters() as $key => $value) {
  99.             $query->setParameter($key, $value, $parsed->getType($key));
  100.         }
  101.     }
  103.     public function addSortings(EntityDefinition $definition, Criteria $criteria, array $sortings, QueryBuilder $query, Context $context): void
  104.     {
  105.         /** @var FieldSorting $sorting */
  106.         foreach ($sortings as $sorting) {
  107.             $this->validateSortingDirection($sorting->getDirection());
  109.             if ($sorting->getField() === '_score') {
  110.                 if (!$this->hasQueriesOrTerm($criteria)) {
  111.                     continue;
  112.                 }
  114.                 // Only add manual _score sorting if the query contains a _score calculation and selection (i.e. the
  115.                 // criteria has a term or queries). Otherwise the SQL selection would fail because no _score field
  116.                 // exists in any entity.
  117.                 $query->addOrderBy('_score', $sorting->getDirection());
  118.                 $query->addState('_score');
  120.                 continue;
  121.             }
  123.             $accessor = $this->helper->getFieldAccessor($sorting->getField(), $definition, $definition->getEntityName(), $context);
  125.             if ($sorting instanceof CountSorting) {
  126.                 $query->addOrderBy(sprintf('COUNT(%s)', $accessor), $sorting->getDirection());
  128.                 continue;
  129.             }
  131.             if ($sorting->getNaturalSorting()) {
  132.                 $query->addOrderBy('LENGTH(' . $accessor . ')', $sorting->getDirection());
  133.             }
  135.             if (!$this->hasGroupBy($criteria, $query)) {
  136.                 $query->addOrderBy($accessor, $sorting->getDirection());
  138.                 continue;
  139.             }
  141.             if (!\in_array($sorting->getField(), ['product.cheapestPrice', 'cheapestPrice'], true)) {
  142.                 if ($sorting->getDirection() === FieldSorting::ASCENDING) {
  143.                     $accessor = 'MIN(' . $accessor . ')';
  144.                 } else {
  145.                     $accessor = 'MAX(' . $accessor . ')';
  146.                 }
  147.             }
  148.             $query->addOrderBy($accessor, $sorting->getDirection());
  149.         }
  150.     }
  152.     private function addQueries(EntityDefinition $definition, Criteria $criteria, QueryBuilder $query, Context $context): void
  153.     {
  154.         $queries = $this->parser->parseRanking(
  155.             $criteria->getQueries(),
  156.             $definition,
  157.             $definition->getEntityName(),
  158.             $context
  159.         );
  160.         if (empty($queries->getWheres())) {
  161.             return;
  162.         }
  164.         $query->addState(EntityDefinitionQueryHelper::HAS_TO_MANY_JOIN);
  166.         $primary = $definition->getPrimaryKeys()->first();
  168.         \assert($primary instanceof StorageAware);
  170.         $select = 'SUM(' . implode(' + ', $queries->getWheres()) . ') / ' . \sprintf('COUNT(%s.%s)', $definition->getEntityName(), $primary->getStorageName());
  171.         $query->addSelect($select . ' as _score');
  173.         // Sort by _score primarily if the criteria has a score query or search term
  174.         if (!$this->hasScoreSorting($criteria)) {
  175.             $criteria->addSorting(new FieldSorting('_score', FieldSorting::DESCENDING));
  176.         }
  178.         $minScore = array_map(fn (ScoreQuery $query) => $query->getScore(), $criteria->getQueries());
  180.         $minScore = min($minScore);
  182.         $query->andHaving('_score >= :_minScore');
  183.         $query->setParameter('_minScore', $minScore);
  184.         $query->addState('_score');
  186.         foreach ($queries->getParameters() as $key => $value) {
  187.             $query->setParameter($key, $value, $queries->getType($key));
  188.         }
  189.     }
  191.     private function hasGroupBy(Criteria $criteria, QueryBuilder $query): bool
  192.     {
  193.         if ($query->hasState(EntityReader::MANY_TO_MANY_LIMIT_QUERY)) {
  194.             return false;
  195.         }
  197.         return $query->hasState(EntityDefinitionQueryHelper::HAS_TO_MANY_JOIN) || !empty($criteria->getGroupFields());
  198.     }
  200.     private function groupFilters(EntityDefinition $definition, Criteria $criteria, array $additionalFields = []): array
  201.     {
  202.         $filters = [];
  203.         foreach ($criteria->getFilters() as $filter) {
  204.             $filters[] = new AndFilter([$filter]);
  205.         }
  207.         foreach ($criteria->getPostFilters() as $filter) {
  208.             $filters[] = new AndFilter([$filter]);
  209.         }
  211.         // $additionalFields is used by the entity aggregator.
  212.         // For example, if an aggregation is to be created on a to many association that is already stored as a filter.
  213.         // 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.
  214.         return $this->joinGrouper->group($filters, $definition, $additionalFields);
  215.     }
  217.     private function hasScoreSorting(Criteria $criteria): bool
  218.     {
  219.         foreach ($criteria->getSorting() as $sorting) {
  220.             if ($sorting->getField() === '_score') {
  221.                 return true;
  222.             }
  223.         }
  225.         return false;
  226.     }
  228.     private function hasQueriesOrTerm(Criteria $criteria): bool
  229.     {
  230.         return !empty($criteria->getQueries()) || $criteria->getTerm();
  231.     }
  233.     /**
  234.      * @throws InvalidSortingDirectionException
  235.      */
  236.     private function validateSortingDirection(string $direction): void
  237.     {
  238.         if (!\in_array(mb_strtoupper($direction), [FieldSorting::ASCENDING, FieldSorting::DESCENDING], true)) {
  239.             throw new InvalidSortingDirectionException($direction);
  240.         }
  241.     }
  242. }