vendor/doctrine/orm/lib/Doctrine/ORM/Tools/Pagination/Paginator.php line 253

  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Tools\Pagination;
  7. use ArrayIterator;
  8. use Countable;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\ORM\Internal\SQLResultCasing;
  11. use Doctrine\ORM\NoResultException;
  12. use Doctrine\ORM\Query;
  13. use Doctrine\ORM\Query\Parameter;
  14. use Doctrine\ORM\Query\Parser;
  15. use Doctrine\ORM\Query\ResultSetMapping;
  16. use Doctrine\ORM\QueryBuilder;
  17. use IteratorAggregate;
  18. use ReturnTypeWillChange;
  19. use Traversable;
  21. use function array_key_exists;
  22. use function array_map;
  23. use function array_sum;
  24. use function assert;
  25. use function is_string;
  27. /**
  28.  * The paginator can handle various complex scenarios with DQL.
  29.  *
  30.  * @template-covariant T
  31.  * @implements IteratorAggregate<array-key, T>
  32.  */
  33. class Paginator implements Countable, IteratorAggregate
  34. {
  35.     use SQLResultCasing;
  37.     /** @var Query */
  38.     private $query;
  40.     /** @var bool */
  41.     private $fetchJoinCollection;
  43.     /** @var bool|null */
  44.     private $useOutputWalkers;
  46.     /** @var int|null */
  47.     private $count;
  49.     /**
  50.      * @param Query|QueryBuilder $query               A Doctrine ORM query or query builder.
  51.      * @param bool               $fetchJoinCollection Whether the query joins a collection (true by default).
  52.      */
  53.     public function __construct($query, $fetchJoinCollection = true)
  54.     {
  55.         if ($query instanceof QueryBuilder) {
  56.             $query = $query->getQuery();
  57.         }
  59.         $this->query               = $query;
  60.         $this->fetchJoinCollection = (bool) $fetchJoinCollection;
  61.     }
  63.     /**
  64.      * Returns the query.
  65.      *
  66.      * @return Query
  67.      */
  68.     public function getQuery()
  69.     {
  70.         return $this->query;
  71.     }
  73.     /**
  74.      * Returns whether the query joins a collection.
  75.      *
  76.      * @return bool Whether the query joins a collection.
  77.      */
  78.     public function getFetchJoinCollection()
  79.     {
  80.         return $this->fetchJoinCollection;
  81.     }
  83.     /**
  84.      * Returns whether the paginator will use an output walker.
  85.      *
  86.      * @return bool|null
  87.      */
  88.     public function getUseOutputWalkers()
  89.     {
  90.         return $this->useOutputWalkers;
  91.     }
  93.     /**
  94.      * Sets whether the paginator will use an output walker.
  95.      *
  96.      * @param bool|null $useOutputWalkers
  97.      *
  98.      * @return $this
  99.      * @psalm-return static<T>
  100.      */
  101.     public function setUseOutputWalkers($useOutputWalkers)
  102.     {
  103.         $this->useOutputWalkers = $useOutputWalkers;
  105.         return $this;
  106.     }
  108.     /**
  109.      * {@inheritDoc}
  110.      *
  111.      * @return int
  112.      */
  113.     #[ReturnTypeWillChange]
  114.     public function count()
  115.     {
  116.         if ($this->count === null) {
  117.             try {
  118.                 $this->count = (int) array_sum(array_map('current', $this->getCountQuery()->getScalarResult()));
  119.             } catch (NoResultException $e) {
  120.                 $this->count = 0;
  121.             }
  122.         }
  124.         return $this->count;
  125.     }
  127.     /**
  128.      * {@inheritDoc}
  129.      *
  130.      * @return Traversable
  131.      * @psalm-return Traversable<array-key, T>
  132.      */
  133.     #[ReturnTypeWillChange]
  134.     public function getIterator()
  135.     {
  136.         $offset = $this->query->getFirstResult();
  137.         $length = $this->query->getMaxResults();
  139.         if ($this->fetchJoinCollection && $length !== null) {
  140.             $subQuery = $this->cloneQuery($this->query);
  142.             if ($this->useOutputWalker($subQuery)) {
  143.                 $subQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
  144.             } else {
  145.                 $this->appendTreeWalker($subQuery, LimitSubqueryWalker::class);
  146.                 $this->unbindUnusedQueryParams($subQuery);
  147.             }
  149.             $subQuery->setFirstResult($offset)->setMaxResults($length);
  151.             $foundIdRows = $subQuery->getScalarResult();
  153.             // don't do this for an empty id array
  154.             if ($foundIdRows === []) {
  155.                 return new ArrayIterator([]);
  156.             }
  158.             $whereInQuery = $this->cloneQuery($this->query);
  159.             $ids          = array_map('current', $foundIdRows);
  161.             $this->appendTreeWalker($whereInQuery, WhereInWalker::class);
  162.             $whereInQuery->setHint(WhereInWalker::HINT_PAGINATOR_HAS_IDS, true);
  163.             $whereInQuery->setFirstResult(0)->setMaxResults(null);
  164.             $whereInQuery->setCacheable($this->query->isCacheable());
  166.             $databaseIds = $this->convertWhereInIdentifiersToDatabaseValues($ids);
  167.             $whereInQuery->setParameter(WhereInWalker::PAGINATOR_ID_ALIAS, $databaseIds);
  169.             $result = $whereInQuery->getResult($this->query->getHydrationMode());
  170.         } else {
  171.             $result = $this->cloneQuery($this->query)
  172.                 ->setMaxResults($length)
  173.                 ->setFirstResult($offset)
  174.                 ->setCacheable($this->query->isCacheable())
  175.                 ->getResult($this->query->getHydrationMode());
  176.         }
  178.         return new ArrayIterator($result);
  179.     }
  181.     private function cloneQuery(Query $query): Query
  182.     {
  183.         $cloneQuery = clone $query;
  185.         $cloneQuery->setParameters(clone $query->getParameters());
  186.         $cloneQuery->setCacheable(false);
  188.         foreach ($query->getHints() as $name => $value) {
  189.             $cloneQuery->setHint($name, $value);
  190.         }
  192.         return $cloneQuery;
  193.     }
  195.     /**
  196.      * Determines whether to use an output walker for the query.
  197.      */
  198.     private function useOutputWalker(Query $query): bool
  199.     {
  200.         if ($this->useOutputWalkers === null) {
  201.             return (bool) $query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER) === false;
  202.         }
  204.         return $this->useOutputWalkers;
  205.     }
  207.     /**
  208.      * Appends a custom tree walker to the tree walkers hint.
  209.      *
  210.      * @psalm-param class-string $walkerClass
  211.      */
  212.     private function appendTreeWalker(Query $query, string $walkerClass): void
  213.     {
  214.         $hints = $query->getHint(Query::HINT_CUSTOM_TREE_WALKERS);
  216.         if ($hints === false) {
  217.             $hints = [];
  218.         }
  220.         $hints[] = $walkerClass;
  221.         $query->setHint(Query::HINT_CUSTOM_TREE_WALKERS, $hints);
  222.     }
  224.     /**
  225.      * Returns Query prepared to count.
  226.      */
  227.     private function getCountQuery(): Query
  228.     {
  229.         $countQuery = $this->cloneQuery($this->query);
  231.         if (! $countQuery->hasHint(CountWalker::HINT_DISTINCT)) {
  232.             $countQuery->setHint(CountWalker::HINT_DISTINCT, true);
  233.         }
  235.         if ($this->useOutputWalker($countQuery)) {
  236.             $platform = $countQuery->getEntityManager()->getConnection()->getDatabasePlatform(); // law of demeter win
  238.             $rsm = new ResultSetMapping();
  239.             $rsm->addScalarResult($this->getSQLResultCasing($platform, 'dctrn_count'), 'count');
  241.             $countQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, CountOutputWalker::class);
  242.             $countQuery->setResultSetMapping($rsm);
  243.         } else {
  244.             $this->appendTreeWalker($countQuery, CountWalker::class);
  245.             $this->unbindUnusedQueryParams($countQuery);
  246.         }
  248.         $countQuery->setFirstResult(0)->setMaxResults(null);
  250.         return $countQuery;
  251.     }
  253.     private function unbindUnusedQueryParams(Query $query): void
  254.     {
  255.         $parser            = new Parser($query);
  256.         $parameterMappings = $parser->parse()->getParameterMappings();
  257.         /** @var Collection|Parameter[] $parameters */
  258.         $parameters = $query->getParameters();
  260.         foreach ($parameters as $key => $parameter) {
  261.             $parameterName = $parameter->getName();
  263.             if (! (isset($parameterMappings[$parameterName]) || array_key_exists($parameterName, $parameterMappings))) {
  264.                 unset($parameters[$key]);
  265.             }
  266.         }
  268.         $query->setParameters($parameters);
  269.     }
  271.     /**
  272.      * @param mixed[] $identifiers
  273.      *
  274.      * @return mixed[]
  275.      */
  276.     private function convertWhereInIdentifiersToDatabaseValues(array $identifiers): array
  277.     {
  278.         $query = $this->cloneQuery($this->query);
  279.         $query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, RootTypeWalker::class);
  281.         $connection = $this->query->getEntityManager()->getConnection();
  282.         $type       = $query->getSQL();
  283.         assert(is_string($type));
  285.         return array_map(static function ($id) use ($connection, $type) {
  286.             return $connection->convertToDatabaseValue($id, $type);
  287.         }, $identifiers);
  288.     }
  289. }