vendor/shopware/core/Framework/DataAbstractionLayer/Search/Parser/SqlQueryParser.php line 109

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\DataAbstractionLayer\Search\Parser;
  5. use Doctrine\DBAL\ArrayParameterType;
  6. use Doctrine\DBAL\Connection;
  7. use Shopware\Core\Framework\Context;
  8. use Shopware\Core\Framework\DataAbstractionLayer\Dbal\EntityDefinitionQueryHelper;
  9. use Shopware\Core\Framework\DataAbstractionLayer\EntityDefinition;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Field\FkField;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Field\IdField;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Field\ListField;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\ContainsFilter;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsAnyFilter;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\Filter;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\MultiFilter;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\NotFilter;
  19. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\PrefixFilter;
  20. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\RangeFilter;
  21. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\SingleFieldFilter;
  22. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\SuffixFilter;
  23. use Shopware\Core\Framework\DataAbstractionLayer\Search\Query\ScoreQuery;
  24. use Shopware\Core\Framework\Log\Package;
  25. use Shopware\Core\Framework\Uuid\Uuid;
  27. /**
  28.  * @internal
  29.  */
  30. #[Package('core')]
  31. class SqlQueryParser
  32. {
  33.     /**
  34.      * @internal
  35.      */
  36.     public function __construct(
  37.         private readonly EntityDefinitionQueryHelper $queryHelper,
  38.         private readonly Connection $connection
  39.     ) {
  40.     }
  42.     public function parseRanking(
  43.         array $queries,
  44.         EntityDefinition $definition,
  45.         string $root,
  46.         Context $context
  47.     ): ParseResult {
  48.         $result = new ParseResult();
  50.         /** @var ScoreQuery $query */
  51.         foreach ($queries as $query) {
  52.             $parsed = $this->parse($query->getQuery(), $definition, $context, $root);
  54.             foreach ($parsed->getWheres() as $where) {
  55.                 if ($query->getScoreField()) {
  56.                     $field = $this->queryHelper->getFieldAccessor(
  57.                         $query->getScoreField(),
  58.                         $definition,
  59.                         $root,
  60.                         $context
  61.                     );
  63.                     $result->addWhere(
  64.                         sprintf('IF(%s , %s * %s, 0)', $where, (string) $this->connection->quote($query->getScore()), $field)
  65.                     );
  67.                     continue;
  68.                 }
  70.                 $result->addWhere(
  71.                     sprintf('IF(%s , %s, 0)', $where, (string) $this->connection->quote($query->getScore()))
  72.                 );
  73.             }
  75.             foreach ($parsed->getParameters() as $key => $parameter) {
  76.                 $result->addParameter($key, $parameter, $parsed->getType($key));
  77.             }
  78.         }
  80.         return $result;
  81.     }
  83.     public function parse(
  84.         Filter $query,
  85.         EntityDefinition $definition,
  86.         Context $context,
  87.         ?string $root = null,
  88.         bool $negated = false
  89.     ): ParseResult {
  90.         if ($root === null) {
  91.             $root = $definition->getEntityName();
  92.         }
  94.         if ($query instanceof SingleFieldFilter && $query->getResolved()) {
  95.             $result = new ParseResult();
  96.             $result->addWhere((string) $query->getResolved());
  98.             return $result;
  99.         }
  101.         return match (true) {
  102.             $query instanceof EqualsFilter => $this->parseEqualsFilter($query, $definition, $root, $context, $negated),
  103.             $query instanceof EqualsAnyFilter => $this->parseEqualsAnyFilter($query, $definition, $root, $context),
  104.             $query instanceof ContainsFilter => $this->parseContainsFilter($query, $definition, $root, $context),
  105.             $query instanceof PrefixFilter => $this->parsePrefixFilter($query, $definition, $root, $context),
  106.             $query instanceof SuffixFilter => $this->parseSuffixFilter($query, $definition, $root, $context),
  107.             $query instanceof RangeFilter => $this->parseRangeFilter($query, $definition, $root, $context),
  108.             $query instanceof NotFilter => $this->parseNotFilter($query, $definition, $root, $context),
  109.             $query instanceof MultiFilter => $this->parseMultiFilter($query, $definition, $root, $context, $negated),
  110.             default => throw new \RuntimeException(sprintf('Unsupported query %s', $query::class)),
  111.         };
  112.     }
  114.     private function parseRangeFilter(
  115.         RangeFilter $query,
  116.         EntityDefinition $definition,
  117.         string $root,
  118.         Context $context
  119.     ): ParseResult {
  120.         $result = new ParseResult();
  122.         $key = $this->getKey();
  124.         $field = $this->queryHelper->getFieldAccessor($query->getField(), $definition, $root, $context);
  126.         $where = [];
  128.         if ($query->hasParameter(RangeFilter::GT)) {
  129.             $where[] = $field . ' > :' . $key;
  130.             $result->addParameter($key, $query->getParameter(RangeFilter::GT));
  131.         } elseif ($query->hasParameter(RangeFilter::GTE)) {
  132.             $where[] = $field . ' >= :' . $key;
  133.             $result->addParameter($key, $query->getParameter(RangeFilter::GTE));
  134.         }
  136.         $key = $this->getKey();
  138.         if ($query->hasParameter(RangeFilter::LT)) {
  139.             $where[] = $field . ' < :' . $key;
  140.             $result->addParameter($key, $query->getParameter(RangeFilter::LT));
  141.         } elseif ($query->hasParameter(RangeFilter::LTE)) {
  142.             $where[] = $field . ' <= :' . $key;
  143.             $result->addParameter($key, $query->getParameter(RangeFilter::LTE));
  144.         }
  146.         $where = '(' . implode(' AND ', $where) . ')';
  147.         $result->addWhere($where);
  149.         return $result;
  150.     }
  152.     private function parseContainsFilter(ContainsFilter $query, EntityDefinition $definition, string $root, Context $context): ParseResult
  153.     {
  154.         $key = $this->getKey();
  156.         $field = $this->queryHelper->getFieldAccessor($query->getField(), $definition, $root, $context);
  158.         $result = new ParseResult();
  159.         $result->addWhere($field . ' LIKE :' . $key);
  161.         $escaped = addcslashes((string) $query->getValue(), '\\_%');
  162.         $result->addParameter($key, '%' . $escaped . '%');
  164.         return $result;
  165.     }
  167.     private function parsePrefixFilter(PrefixFilter $query, EntityDefinition $definition, string $root, Context $context): ParseResult
  168.     {
  169.         $key = $this->getKey();
  171.         $field = $this->queryHelper->getFieldAccessor($query->getField(), $definition, $root, $context);
  173.         $result = new ParseResult();
  174.         $result->addWhere($field . ' LIKE :' . $key);
  176.         $escaped = addcslashes($query->getValue(), '\\_%');
  177.         $result->addParameter($key, $escaped . '%');
  179.         return $result;
  180.     }
  182.     private function parseSuffixFilter(SuffixFilter $query, EntityDefinition $definition, string $root, Context $context): ParseResult
  183.     {
  184.         $key = $this->getKey();
  186.         $field = $this->queryHelper->getFieldAccessor($query->getField(), $definition, $root, $context);
  188.         $result = new ParseResult();
  189.         $result->addWhere($field . ' LIKE :' . $key);
  191.         $escaped = addcslashes($query->getValue(), '\\_%');
  192.         $result->addParameter($key, '%' . $escaped);
  194.         return $result;
  195.     }
  197.     private function parseEqualsAnyFilter(EqualsAnyFilter $query, EntityDefinition $definition, string $root, Context $context): ParseResult
  198.     {
  199.         $key = $this->getKey();
  200.         $select = $this->queryHelper->getFieldAccessor($query->getField(), $definition, $root, $context);
  201.         $field = $this->queryHelper->getField($query->getField(), $definition, $root);
  203.         $result = new ParseResult();
  205.         if ($field instanceof ListField) {
  206.             $where = [];
  208.             foreach ($query->getValue() as $value) {
  209.                 $key = $this->getKey();
  210.                 $where[] = sprintf('JSON_CONTAINS(%s, JSON_ARRAY(%s))', $select, ':' . $key);
  211.                 $result->addParameter($key, $value);
  212.             }
  213.             $result->addWhere('(' . implode(' OR ', $where) . ')');
  215.             return $result;
  216.         }
  218.         $result->addWhere($select . ' IN (:' . $key . ')');
  220.         $value = array_values($query->getValue());
  221.         if ($field instanceof IdField || $field instanceof FkField) {
  222.             $value = array_filter(array_map(fn (bool|float|int|string $id): string => Uuid::fromHexToBytes((string) $id), $value));
  223.         }
  224.         $result->addParameter($key, $value, ArrayParameterType::STRING);
  226.         return $result;
  227.     }
  229.     private function parseEqualsFilter(EqualsFilter $query, EntityDefinition $definition, string $root, Context $context, bool $negated): ParseResult
  230.     {
  231.         $key = $this->getKey();
  232.         $select = $this->queryHelper->getFieldAccessor($query->getField(), $definition, $root, $context);
  233.         $field = $this->queryHelper->getField($query->getField(), $definition, $root);
  235.         $result = new ParseResult();
  237.         if ($field instanceof ListField) {
  238.             $result->addWhere('JSON_CONTAINS(' . $select . ', JSON_ARRAY(:' . $key . '))');
  239.             $result->addParameter($key, $query->getValue());
  241.             return $result;
  242.         }
  244.         if ($negated || $query->getValue() === null) {
  245.             $result->addWhere($select . ' <=> :' . $key);
  246.         } else {
  247.             $result->addWhere($select . ' = :' . $key);
  248.         }
  250.         $value = $query->getValue();
  251.         if ($value === null) {
  252.             $result->addParameter($key, null);
  254.             return $result;
  255.         }
  257.         if ($field instanceof IdField || $field instanceof FkField) {
  258.             $value = Uuid::fromHexToBytes((string) $value);
  259.         }
  261.         $result->addParameter($key, $value);
  263.         return $result;
  264.     }
  266.     private function parseMultiFilter(MultiFilter $query, EntityDefinition $definition, string $root, Context $context, bool $negated): ParseResult
  267.     {
  268.         $result = $this->iterateNested($query, $definition, $root, $context, $negated);
  270.         $wheres = $result->getWheres();
  272.         $result->resetWheres();
  274.         $glue = ' ' . $query->getOperator() . ' ';
  275.         if (!empty($wheres)) {
  276.             $result->addWhere('(' . implode($glue, $wheres) . ')');
  277.         }
  279.         return $result;
  280.     }
  282.     private function parseNotFilter(NotFilter $query, EntityDefinition $definition, string $root, Context $context): ParseResult
  283.     {
  284.         $result = $this->iterateNested($query, $definition, $root, $context, true);
  286.         $wheres = $result->getWheres();
  288.         $result->resetWheres();
  290.         $glue = ' ' . $query->getOperator() . ' ';
  292.         if (!empty($wheres)) {
  293.             $result->addWhere('NOT (' . implode($glue, $wheres) . ')');
  294.         }
  296.         return $result;
  297.     }
  299.     private function iterateNested(MultiFilter $query, EntityDefinition $definition, string $root, Context $context, bool $negated): ParseResult
  300.     {
  301.         $result = new ParseResult();
  302.         foreach ($query->getQueries() as $multiFilter) {
  303.             $result = $result->merge(
  304.                 $this->parse($multiFilter, $definition, $context, $root, $negated)
  305.             );
  306.         }
  308.         return $result;
  309.     }
  311.     private function getKey(): string
  312.     {
  313.         return 'param_' . Uuid::randomHex();
  314.     }
  315. }