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

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;
  20. /**
  21.  * @internal
  22.  */
  23. class CriteriaQueryBuilder
  24. {
  25.     /**
  26.      * @var SqlQueryParser
  27.      */
  28.     private $parser;
  30.     /***
  31.      * @var EntityDefinitionQueryHelper
  32.      */
  33.     private $helper;
  35.     /**
  36.      * @var SearchTermInterpreter
  37.      */
  38.     private $interpreter;
  40.     /**
  41.      * @var EntityScoreQueryBuilder
  42.      */
  43.     private $scoreBuilder;
  45.     /**
  46.      * @var JoinGroupBuilder
  47.      */
  48.     private $joinGrouper;
  50.     /**
  51.      * @var CriteriaPartResolver
  52.      */
  53.     private $criteriaPartResolver;
  55.     public function __construct(
  56.         SqlQueryParser $parser,
  57.         EntityDefinitionQueryHelper $helper,
  58.         SearchTermInterpreter $interpreter,
  59.         EntityScoreQueryBuilder $scoreBuilder,
  60.         JoinGroupBuilder $joinGrouper,
  61.         CriteriaPartResolver $criteriaPartResolver
  62.     ) {
  63.         $this->parser = $parser;
  64.         $this->helper = $helper;
  65.         $this->interpreter = $interpreter;
  66.         $this->scoreBuilder = $scoreBuilder;
  67.         $this->joinGrouper = $joinGrouper;
  68.         $this->criteriaPartResolver = $criteriaPartResolver;
  69.     }
  71.     public function build(QueryBuilder $query, EntityDefinition $definition, Criteria $criteria, Context $context, array $paths = []): QueryBuilder
  72.     {
  73.         $query = $this->helper->getBaseQuery($query, $definition, $context);
  75.         if ($definition->isInheritanceAware() && $context->considerInheritance()) {
  76.             $parent = $definition->getFields()->get('parent');
  78.             if ($parent) {
  79.                 $this->helper->resolveField($parent, $definition, $definition->getEntityName(), $query, $context);
  80.             }
  81.         }
  83.         if ($criteria->getTerm()) {
  84.             $pattern = $this->interpreter->interpret((string) $criteria->getTerm());
  85.             $queries = $this->scoreBuilder->buildScoreQueries($pattern, $definition, $definition->getEntityName(), $context);
  86.             $criteria->addQuery(...$queries);
  87.         }
  89.         $filters = $this->groupFilters($definition, $criteria, $paths);
  91.         $this->criteriaPartResolver->resolve($filters, $definition, $query, $context);
  93.         $this->criteriaPartResolver->resolve($criteria->getQueries(), $definition, $query, $context);
  95.         $this->criteriaPartResolver->resolve($criteria->getSorting(), $definition, $query, $context);
  97.         // do not use grouped filters, because the grouped filters are mapped flat and the logical OR/AND are removed
  98.         $filter = new AndFilter(array_merge(
  99.             $criteria->getFilters(),
  100.             $criteria->getPostFilters()
  101.         ));
  103.         $this->addFilter($definition, $filter, $query, $context);
  105.         $this->addQueries($definition, $criteria, $query, $context);
  107.         if ($criteria->getLimit() === 1) {
  108.             $query->removeState(EntityDefinitionQueryHelper::HAS_TO_MANY_JOIN);
  109.         }
  111.         $this->addSortings($definition, $criteria, $criteria->getSorting(), $query, $context);
  113.         return $query;
  114.     }
  116.     public function addFilter(EntityDefinition $definition, ?Filter $filter, QueryBuilder $query, Context $context): void
  117.     {
  118.         if (!$filter) {
  119.             return;
  120.         }
  122.         $parsed = $this->parser->parse($filter, $definition, $context);
  124.         if (empty($parsed->getWheres())) {
  125.             return;
  126.         }
  128.         $query->andWhere(implode(' AND ', $parsed->getWheres()));
  129.         foreach ($parsed->getParameters() as $key => $value) {
  130.             $query->setParameter($key, $value, $parsed->getType($key));
  131.         }
  132.     }
  134.     public function addSortings(EntityDefinition $definition, Criteria $criteria, array $sortings, QueryBuilder $query, Context $context): void
  135.     {
  136.         /** @var FieldSorting $sorting */
  137.         foreach ($sortings as $sorting) {
  138.             $this->validateSortingDirection($sorting->getDirection());
  140.             if ($sorting->getField() === '_score') {
  141.                 if (!$this->hasQueriesOrTerm($criteria)) {
  142.                     continue;
  143.                 }
  145.                 // Only add manual _score sorting if the query contains a _score calculation and selection (i.e. the
  146.                 // criteria has a term or queries). Otherwise the SQL selection would fail because no _score field
  147.                 // exists in any entity.
  148.                 $query->addOrderBy('_score', $sorting->getDirection());
  149.                 $query->addState('_score');
  151.                 continue;
  152.             }
  154.             $accessor = $this->helper->getFieldAccessor($sorting->getField(), $definition, $definition->getEntityName(), $context);
  156.             if ($sorting instanceof CountSorting) {
  157.                 $query->addOrderBy(sprintf('COUNT(%s)', $accessor), $sorting->getDirection());
  159.                 continue;
  160.             }
  162.             if ($sorting->getNaturalSorting()) {
  163.                 $query->addOrderBy('LENGTH(' . $accessor . ')', $sorting->getDirection());
  164.             }
  166.             if (!$this->hasGroupBy($criteria, $query)) {
  167.                 $query->addOrderBy($accessor, $sorting->getDirection());
  169.                 continue;
  170.             }
  172.             if (!\in_array($sorting->getField(), ['product.cheapestPrice', 'cheapestPrice'], true)) {
  173.                 if ($sorting->getDirection() === FieldSorting::ASCENDING) {
  174.                     $accessor = 'MIN(' . $accessor . ')';
  175.                 } else {
  176.                     $accessor = 'MAX(' . $accessor . ')';
  177.                 }
  178.             }
  179.             $query->addOrderBy($accessor, $sorting->getDirection());
  180.         }
  181.     }
  183.     private function addQueries(EntityDefinition $definition, Criteria $criteria, QueryBuilder $query, Context $context): void
  184.     {
  185.         $queries = $this->parser->parseRanking(
  186.             $criteria->getQueries(),
  187.             $definition,
  188.             $definition->getEntityName(),
  189.             $context
  190.         );
  191.         if (empty($queries->getWheres())) {
  192.             return;
  193.         }
  195.         $query->addState(EntityDefinitionQueryHelper::HAS_TO_MANY_JOIN);
  197.         $primary = $definition->getPrimaryKeys()->first();
  199.         \assert($primary instanceof StorageAware);
  201.         $select = 'SUM(' . implode(' + ', $queries->getWheres()) . ') / ' . \sprintf('COUNT(%s.%s)', $definition->getEntityName(), $primary->getStorageName());
  202.         $query->addSelect($select . ' as _score');
  204.         // Sort by _score primarily if the criteria has a score query or search term
  205.         if (!$this->hasScoreSorting($criteria)) {
  206.             $criteria->addSorting(new FieldSorting('_score', FieldSorting::DESCENDING));
  207.         }
  209.         $minScore = array_map(function (ScoreQuery $query) {
  210.             return $query->getScore();
  211.         }, $criteria->getQueries());
  213.         $minScore = min($minScore);
  215.         $query->andHaving('_score >= :_minScore');
  216.         $query->setParameter('_minScore', $minScore);
  217.         $query->addState('_score');
  219.         foreach ($queries->getParameters() as $key => $value) {
  220.             $query->setParameter($key, $value, $queries->getType($key));
  221.         }
  222.     }
  224.     private function hasGroupBy(Criteria $criteria, QueryBuilder $query): bool
  225.     {
  226.         if ($query->hasState(EntityReader::MANY_TO_MANY_LIMIT_QUERY)) {
  227.             return false;
  228.         }
  230.         return $query->hasState(EntityDefinitionQueryHelper::HAS_TO_MANY_JOIN) || !empty($criteria->getGroupFields());
  231.     }
  233.     private function groupFilters(EntityDefinition $definition, Criteria $criteria, array $additionalFields = []): array
  234.     {
  235.         $filters = [];
  236.         foreach ($criteria->getFilters() as $filter) {
  237.             $filters[] = new AndFilter([$filter]);
  238.         }
  240.         foreach ($criteria->getPostFilters() as $filter) {
  241.             $filters[] = new AndFilter([$filter]);
  242.         }
  244.         // $additionalFields is used by the entity aggregator.
  245.         // For example, if an aggregation is to be created on a to many association that is already stored as a filter.
  246.         // 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.
  247.         return $this->joinGrouper->group($filters, $definition, $additionalFields);
  248.     }
  250.     private function hasScoreSorting(Criteria $criteria): bool
  251.     {
  252.         foreach ($criteria->getSorting() as $sorting) {
  253.             if ($sorting->getField() === '_score') {
  254.                 return true;
  255.             }
  256.         }
  258.         return false;
  259.     }
  261.     private function hasQueriesOrTerm(Criteria $criteria): bool
  262.     {
  263.         return !empty($criteria->getQueries()) || $criteria->getTerm();
  264.     }
  266.     /**
  267.      * @throws InvalidSortingDirectionException
  268.      */
  269.     private function validateSortingDirection(string $direction): void
  270.     {
  271.         if (!\in_array(mb_strtoupper($direction), [FieldSorting::ASCENDING, FieldSorting::DESCENDING], true)) {
  272.             throw new InvalidSortingDirectionException($direction);
  273.         }
  274.     }
  275. }