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

Open in your IDE?
  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.     /**
  28.      * @var SqlQueryParser
  29.      */
  30.     private $parser;
  32.     /***
  33.      * @var EntityDefinitionQueryHelper
  34.      */
  35.     private $helper;
  37.     /**
  38.      * @var SearchTermInterpreter
  39.      */
  40.     private $interpreter;
  42.     /**
  43.      * @var EntityScoreQueryBuilder
  44.      */
  45.     private $scoreBuilder;
  47.     /**
  48.      * @var JoinGroupBuilder
  49.      */
  50.     private $joinGrouper;
  52.     /**
  53.      * @var CriteriaPartResolver
  54.      */
  55.     private $criteriaPartResolver;
  57.     public function __construct(
  58.         SqlQueryParser $parser,
  59.         EntityDefinitionQueryHelper $helper,
  60.         SearchTermInterpreter $interpreter,
  61.         EntityScoreQueryBuilder $scoreBuilder,
  62.         JoinGroupBuilder $joinGrouper,
  63.         CriteriaPartResolver $criteriaPartResolver
  64.     ) {
  65.         $this->parser = $parser;
  66.         $this->helper = $helper;
  67.         $this->interpreter = $interpreter;
  68.         $this->scoreBuilder = $scoreBuilder;
  69.         $this->joinGrouper = $joinGrouper;
  70.         $this->criteriaPartResolver = $criteriaPartResolver;
  71.     }
  73.     public function build(QueryBuilder $query, EntityDefinition $definition, Criteria $criteria, Context $context, array $paths = []): QueryBuilder
  74.     {
  75.         $query = $this->helper->getBaseQuery($query, $definition, $context);
  77.         if ($definition->isInheritanceAware() && $context->considerInheritance()) {
  78.             $parent = $definition->getFields()->get('parent');
  80.             if ($parent) {
  81.                 $this->helper->resolveField($parent, $definition, $definition->getEntityName(), $query, $context);
  82.             }
  83.         }
  85.         if ($criteria->getTerm()) {
  86.             $pattern = $this->interpreter->interpret((string) $criteria->getTerm());
  87.             $queries = $this->scoreBuilder->buildScoreQueries($pattern, $definition, $definition->getEntityName(), $context);
  88.             $criteria->addQuery(...$queries);
  89.         }
  91.         $filters = $this->groupFilters($definition, $criteria, $paths);
  93.         $this->criteriaPartResolver->resolve($filters, $definition, $query, $context);
  95.         $this->criteriaPartResolver->resolve($criteria->getQueries(), $definition, $query, $context);
  97.         $this->criteriaPartResolver->resolve($criteria->getSorting(), $definition, $query, $context);
  99.         // do not use grouped filters, because the grouped filters are mapped flat and the logical OR/AND are removed
  100.         $filter = new AndFilter(array_merge(
  101.             $criteria->getFilters(),
  102.             $criteria->getPostFilters()
  103.         ));
  105.         $this->addFilter($definition, $filter, $query, $context);
  107.         $this->addQueries($definition, $criteria, $query, $context);
  109.         if ($criteria->getLimit() === 1) {
  110.             $query->removeState(EntityDefinitionQueryHelper::HAS_TO_MANY_JOIN);
  111.         }
  113.         $this->addSortings($definition, $criteria, $criteria->getSorting(), $query, $context);
  115.         return $query;
  116.     }
  118.     public function addFilter(EntityDefinition $definition, ?Filter $filter, QueryBuilder $query, Context $context): void
  119.     {
  120.         if (!$filter) {
  121.             return;
  122.         }
  124.         $parsed = $this->parser->parse($filter, $definition, $context);
  126.         if (empty($parsed->getWheres())) {
  127.             return;
  128.         }
  130.         $query->andWhere(implode(' AND ', $parsed->getWheres()));
  131.         foreach ($parsed->getParameters() as $key => $value) {
  132.             $query->setParameter($key, $value, $parsed->getType($key));
  133.         }
  134.     }
  136.     public function addSortings(EntityDefinition $definition, Criteria $criteria, array $sortings, QueryBuilder $query, Context $context): void
  137.     {
  138.         /** @var FieldSorting $sorting */
  139.         foreach ($sortings as $sorting) {
  140.             $this->validateSortingDirection($sorting->getDirection());
  142.             if ($sorting->getField() === '_score') {
  143.                 if (!$this->hasQueriesOrTerm($criteria)) {
  144.                     continue;
  145.                 }
  147.                 // Only add manual _score sorting if the query contains a _score calculation and selection (i.e. the
  148.                 // criteria has a term or queries). Otherwise the SQL selection would fail because no _score field
  149.                 // exists in any entity.
  150.                 $query->addOrderBy('_score', $sorting->getDirection());
  151.                 $query->addState('_score');
  153.                 continue;
  154.             }
  156.             $accessor = $this->helper->getFieldAccessor($sorting->getField(), $definition, $definition->getEntityName(), $context);
  158.             if ($sorting instanceof CountSorting) {
  159.                 $query->addOrderBy(sprintf('COUNT(%s)', $accessor), $sorting->getDirection());
  161.                 continue;
  162.             }
  164.             if ($sorting->getNaturalSorting()) {
  165.                 $query->addOrderBy('LENGTH(' . $accessor . ')', $sorting->getDirection());
  166.             }
  168.             if (!$this->hasGroupBy($criteria, $query)) {
  169.                 $query->addOrderBy($accessor, $sorting->getDirection());
  171.                 continue;
  172.             }
  174.             if (!\in_array($sorting->getField(), ['product.cheapestPrice', 'cheapestPrice'], true)) {
  175.                 if ($sorting->getDirection() === FieldSorting::ASCENDING) {
  176.                     $accessor = 'MIN(' . $accessor . ')';
  177.                 } else {
  178.                     $accessor = 'MAX(' . $accessor . ')';
  179.                 }
  180.             }
  181.             $query->addOrderBy($accessor, $sorting->getDirection());
  182.         }
  183.     }
  185.     private function addQueries(EntityDefinition $definition, Criteria $criteria, QueryBuilder $query, Context $context): void
  186.     {
  187.         $queries = $this->parser->parseRanking(
  188.             $criteria->getQueries(),
  189.             $definition,
  190.             $definition->getEntityName(),
  191.             $context
  192.         );
  193.         if (empty($queries->getWheres())) {
  194.             return;
  195.         }
  197.         $query->addState(EntityDefinitionQueryHelper::HAS_TO_MANY_JOIN);
  199.         $primary = $definition->getPrimaryKeys()->first();
  201.         \assert($primary instanceof StorageAware);
  203.         $select = 'SUM(' . implode(' + ', $queries->getWheres()) . ') / ' . \sprintf('COUNT(%s.%s)', $definition->getEntityName(), $primary->getStorageName());
  204.         $query->addSelect($select . ' as _score');
  206.         // Sort by _score primarily if the criteria has a score query or search term
  207.         if (!$this->hasScoreSorting($criteria)) {
  208.             $criteria->addSorting(new FieldSorting('_score', FieldSorting::DESCENDING));
  209.         }
  211.         $minScore = array_map(function (ScoreQuery $query) {
  212.             return $query->getScore();
  213.         }, $criteria->getQueries());
  215.         $minScore = min($minScore);
  217.         $query->andHaving('_score >= :_minScore');
  218.         $query->setParameter('_minScore', $minScore);
  219.         $query->addState('_score');
  221.         foreach ($queries->getParameters() as $key => $value) {
  222.             $query->setParameter($key, $value, $queries->getType($key));
  223.         }
  224.     }
  226.     private function hasGroupBy(Criteria $criteria, QueryBuilder $query): bool
  227.     {
  228.         if ($query->hasState(EntityReader::MANY_TO_MANY_LIMIT_QUERY)) {
  229.             return false;
  230.         }
  232.         return $query->hasState(EntityDefinitionQueryHelper::HAS_TO_MANY_JOIN) || !empty($criteria->getGroupFields());
  233.     }
  235.     private function groupFilters(EntityDefinition $definition, Criteria $criteria, array $additionalFields = []): array
  236.     {
  237.         $filters = [];
  238.         foreach ($criteria->getFilters() as $filter) {
  239.             $filters[] = new AndFilter([$filter]);
  240.         }
  242.         foreach ($criteria->getPostFilters() as $filter) {
  243.             $filters[] = new AndFilter([$filter]);
  244.         }
  246.         // $additionalFields is used by the entity aggregator.
  247.         // For example, if an aggregation is to be created on a to many association that is already stored as a filter.
  248.         // 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.
  249.         return $this->joinGrouper->group($filters, $definition, $additionalFields);
  250.     }
  252.     private function hasScoreSorting(Criteria $criteria): bool
  253.     {
  254.         foreach ($criteria->getSorting() as $sorting) {
  255.             if ($sorting->getField() === '_score') {
  256.                 return true;
  257.             }
  258.         }
  260.         return false;
  261.     }
  263.     private function hasQueriesOrTerm(Criteria $criteria): bool
  264.     {
  265.         return !empty($criteria->getQueries()) || $criteria->getTerm();
  266.     }
  268.     /**
  269.      * @throws InvalidSortingDirectionException
  270.      */
  271.     private function validateSortingDirection(string $direction): void
  272.     {
  273.         if (!\in_array(mb_strtoupper($direction), [FieldSorting::ASCENDING, FieldSorting::DESCENDING], true)) {
  274.             throw new InvalidSortingDirectionException($direction);
  275.         }
  276.     }
  277. }