vendor/doctrine/orm/src/Tools/Pagination/CountOutputWalker.php line 68

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Tools\Pagination;
  7. use Doctrine\DBAL\Platforms\AbstractPlatform;
  8. use Doctrine\DBAL\Platforms\SQLServerPlatform;
  9. use Doctrine\ORM\Query;
  10. use Doctrine\ORM\Query\AST\SelectStatement;
  11. use Doctrine\ORM\Query\Parser;
  12. use Doctrine\ORM\Query\ParserResult;
  13. use Doctrine\ORM\Query\ResultSetMapping;
  14. use Doctrine\ORM\Query\SqlWalker;
  15. use RuntimeException;
  17. use function array_diff;
  18. use function array_keys;
  19. use function count;
  20. use function implode;
  21. use function reset;
  22. use function sprintf;
  24. /**
  25.  * Wraps the query in order to accurately count the root objects.
  26.  *
  27.  * Given a DQL like `SELECT u FROM User u` it will generate an SQL query like:
  28.  * SELECT COUNT(*) (SELECT DISTINCT <id> FROM (<original SQL>))
  29.  *
  30.  * Works with composite keys but cannot deal with queries that have multiple
  31.  * root entities (e.g. `SELECT f, b from Foo, Bar`)
  32.  *
  33.  * Note that the ORDER BY clause is not removed. Many SQL implementations (e.g. MySQL)
  34.  * are able to cache subqueries. By keeping the ORDER BY clause intact, the limitSubQuery
  35.  * that will most likely be executed next can be read from the native SQL cache.
  36.  *
  37.  * @psalm-import-type QueryComponent from Parser
  38.  */
  39. class CountOutputWalker extends SqlWalker
  40. {
  41.     /** @var AbstractPlatform */
  42.     private $platform;
  44.     /** @var ResultSetMapping */
  45.     private $rsm;
  47.     /**
  48.      * Stores various parameters that are otherwise unavailable
  49.      * because Doctrine\ORM\Query\SqlWalker keeps everything private without
  50.      * accessors.
  51.      *
  52.      * @param Query        $query
  53.      * @param ParserResult $parserResult
  54.      * @param mixed[]      $queryComponents
  55.      * @psalm-param array<string, QueryComponent> $queryComponents
  56.      */
  57.     public function __construct($query, $parserResult, array $queryComponents)
  58.     {
  59.         $this->platform = $query->getEntityManager()->getConnection()->getDatabasePlatform();
  60.         $this->rsm      = $parserResult->getResultSetMapping();
  62.         parent::__construct($query, $parserResult, $queryComponents);
  63.     }
  65.     /**
  66.      * {@inheritDoc}
  67.      */
  68.     public function walkSelectStatement(SelectStatement $AST)
  69.     {
  70.         if ($this->platform instanceof SQLServerPlatform) {
  71.             $AST->orderByClause = null;
  72.         }
  74.         $sql = parent::walkSelectStatement($AST);
  76.         if ($AST->groupByClause) {
  77.             return sprintf(
  78.                 'SELECT COUNT(*) AS dctrn_count FROM (%s) dctrn_table',
  79.                 $sql
  80.             );
  81.         }
  83.         // Find out the SQL alias of the identifier column of the root entity
  84.         // It may be possible to make this work with multiple root entities but that
  85.         // would probably require issuing multiple queries or doing a UNION SELECT
  86.         // so for now, It's not supported.
  88.         // Get the root entity and alias from the AST fromClause
  89.         $from = $AST->fromClause->identificationVariableDeclarations;
  90.         if (count($from) > 1) {
  91.             throw new RuntimeException('Cannot count query which selects two FROM components, cannot make distinction');
  92.         }
  94.         $fromRoot       = reset($from);
  95.         $rootAlias      = $fromRoot->rangeVariableDeclaration->aliasIdentificationVariable;
  96.         $rootClass      = $this->getMetadataForDqlAlias($rootAlias);
  97.         $rootIdentifier = $rootClass->identifier;
  99.         // For every identifier, find out the SQL alias by combing through the ResultSetMapping
  100.         $sqlIdentifier = [];
  101.         foreach ($rootIdentifier as $property) {
  102.             if (isset($rootClass->fieldMappings[$property])) {
  103.                 foreach (array_keys($this->rsm->fieldMappings, $property, true) as $alias) {
  104.                     if ($this->rsm->columnOwnerMap[$alias] === $rootAlias) {
  105.                         $sqlIdentifier[$property] = $alias;
  106.                     }
  107.                 }
  108.             }
  110.             if (isset($rootClass->associationMappings[$property])) {
  111.                 $joinColumn = $rootClass->associationMappings[$property]['joinColumns'][0]['name'];
  113.                 foreach (array_keys($this->rsm->metaMappings, $joinColumn, true) as $alias) {
  114.                     if ($this->rsm->columnOwnerMap[$alias] === $rootAlias) {
  115.                         $sqlIdentifier[$property] = $alias;
  116.                     }
  117.                 }
  118.             }
  119.         }
  121.         if (count($rootIdentifier) !== count($sqlIdentifier)) {
  122.             throw new RuntimeException(sprintf(
  123.                 'Not all identifier properties can be found in the ResultSetMapping: %s',
  124.                 implode(', ', array_diff($rootIdentifier, array_keys($sqlIdentifier)))
  125.             ));
  126.         }
  128.         // Build the counter query
  129.         return sprintf(
  130.             'SELECT COUNT(*) AS dctrn_count FROM (SELECT DISTINCT %s FROM (%s) dctrn_result) dctrn_table',
  131.             implode(', ', $sqlIdentifier),
  132.             $sql
  133.         );
  134.     }
  135. }