Fix different first/max result values taking up query cache space

lib/Doctrine/ORM/Query.php

@@ -1,4 +1,4 @@
 <?php
 
 declare(strict_types=1);
 
@@ -18,6 +18,7 @@
 use Doctrine\ORM\Query\AST\SelectStatement;
 use Doctrine\ORM\Query\AST\UpdateStatement;
 use Doctrine\ORM\Query\Exec\AbstractSqlExecutor;
+use Doctrine\ORM\Query\OutputWalker;
 use Doctrine\ORM\Query\Parameter;
 use Doctrine\ORM\Query\ParameterTypeInferer;
 use Doctrine\ORM\Query\Parser;
@@ -33,6 +34,7 @@
 use function count;
 use function get_debug_type;
 use function in_array;
+use function is_a;
 use function is_int;
 use function ksort;
 use function md5;
@@ -147,6 +149,9 @@
      */
     private $parserResult;
 
+    /** @var AbstractSqlExecutor */
+    private $sqlExecutor = null;
+
     /**
      * The first result to return (the "offset").
      *
@@ -196,7 +201,7 @@
      */
     public function getSQL()
     {
-        return $this->parse()->getSqlExecutor()->getSqlStatements();
+        return $this->getSqlExecutor()->getSqlStatements();
     }
 
     /**
@@ -254,6 +259,7 @@
             $parser = new Parser($this);
 
             $this->parserResult = $parser->parse();
+            $this->initializeSqlExecutor();
 
             return $this->parserResult;
         }
@@ -265,6 +271,7 @@
             if ($cached instanceof ParserResult) {
                 // Cache hit.
                 $this->parserResult = $cached;
+                $this->initializeSqlExecutor();
 
                 return $this->parserResult;
             }
@@ -277,15 +284,26 @@
 
         $queryCache->save($cacheItem->set($this->parserResult)->expiresAfter($this->queryCacheTTL));
 
+        $this->initializeSqlExecutor();
+
         return $this->parserResult;
     }
 
+    private function initializeSqlExecutor(): void
+    {
+        if ($this->parserResult->hasSqlFinalizer()) {
+            $this->sqlExecutor = $this->parserResult->getSqlFinalizer()->createExecutor($this);
+        } else {
+            $this->sqlExecutor = $this->parserResult->getSqlExecutor();
+        }
+    }
+
     /**
      * {@inheritDoc}
      */
     protected function _doExecute()
     {
-        $executor = $this->parse()->getSqlExecutor();
+        $executor = $this->getSqlExecutor();
 
         if ($this->_queryCacheProfile) {
             $executor->setQueryCacheProfile($this->_queryCacheProfile);
@@ -812,11 +830,23 @@
     {
         ksort($this->_hints);
 
+        if (! $this->hasHint(self::HINT_CUSTOM_OUTPUT_WALKER)) {
+            // Assume Parser will create the SqlOutputWalker; save is_a call, which might trigger a class load
+            $firstAndMaxResult = '';
+        } else {
+            $outputWalkerClass = $this->getHint(self::HINT_CUSTOM_OUTPUT_WALKER);
+            if (is_a($outputWalkerClass, OutputWalker::class, true)) {
+                $firstAndMaxResult = '';
+            } else {
+                $firstAndMaxResult = '&firstResult=' . $this->firstResult . '&maxResult=' . $this->maxResults;
+            }
+        }
+
         return md5(
             $this->getDQL() . serialize($this->_hints) .
             '&platform=' . get_debug_type($this->getEntityManager()->getConnection()->getDatabasePlatform()) .
             ($this->_em->hasFilters() ? $this->_em->getFilters()->getHash() : '') .
-            '&firstResult=' . $this->firstResult . '&maxResult=' . $this->maxResults .
+            $firstAndMaxResult .
             '&hydrationMode=' . $this->_hydrationMode . '&types=' . serialize($this->parsedTypes) . 'DOCTRINE_QUERY_CACHE_SALT'
         );
     }
@@ -835,4 +865,11 @@
 
         $this->state = self::STATE_DIRTY;
     }
+
+    private function getSqlExecutor(): AbstractSqlExecutor
+    {
+        $this->parse();
+
+        return $this->sqlExecutor;
+    }
 }

lib/Doctrine/ORM/Query/Exec/FinalizedSelectExecutor.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Query\Exec;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Result;
+use Doctrine\DBAL\Types\Type;
+
+/**
+ * SQL executor for a given, final, single SELECT SQL query
+ */
+class FinalizedSelectExecutor extends AbstractSqlExecutor
+{
+    public function __construct(string $sql)
+    {
+        parent::__construct();
+
+        $this->sqlStatements = $sql;
+    }
+
+    /**
+     * @param list<mixed>|array<string, mixed>                                     $params
+     * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types
+     */
+    public function execute(Connection $conn, array $params, array $types): Result
+    {
+        return $conn->executeQuery($this->getSqlStatements(), $params, $types, $this->queryCacheProfile);
+    }
+}

lib/Doctrine/ORM/Query/Exec/PreparedExecutorFinalizer.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Query\Exec;
+
+use Doctrine\ORM\Query;
+
+/**
+ * PreparedExecutorFinalizer is a wrapper for the SQL finalization
+ * phase that does nothing - it constructed with the sql executor
+ * already.
+ */
+final class PreparedExecutorFinalizer implements SqlFinalizer
+{
+    /** @var AbstractSqlExecutor */
+    private $executor;
+
+    public function __construct(AbstractSqlExecutor $exeutor)
+    {
+        $this->executor = $exeutor;
+    }
+
+    public function createExecutor(Query $query): AbstractSqlExecutor
+    {
+        return $this->executor;
+    }
+}

lib/Doctrine/ORM/Query/Exec/SingleSelectSqlFinalizer.php

@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Query\Exec;
+
+use Doctrine\DBAL\LockMode;
+use Doctrine\ORM\Query;
+use Doctrine\ORM\Query\QueryException;
+
+/**
+ * SingleSelectSqlFinalizer finalizes a given SQL query by applying
+ * the query's firstResult/maxResult values as well as extra read lock/write lock
+ * statements, both through the platform-specific methods.
+ *
+ * The resulting, "finalized" SQL is passed to a FinalizedSelectExecutor.
+ */
+class SingleSelectSqlFinalizer implements SqlFinalizer
+{
+    /** @var string */
+    private $sql;
+
+    public function __construct(string $sql)
+    {
+        $this->sql = $sql;
+    }
+
+    /**
+     * This method exists temporarily to support old SqlWalker interfaces.
+     *
+     * @internal
+     *
+     * @psalm-internal Doctrine\ORM\Query
+     */
+    public function finalizeSql(Query $query): string
+    {
+        $platform = $query->getEntityManager()->getConnection()->getDatabasePlatform();
+
+        $sql = $platform->modifyLimitQuery($this->sql, $query->getMaxResults(), $query->getFirstResult());
+
+        $lockMode = $query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE;
+
+        if ($lockMode !== LockMode::NONE && $lockMode !== LockMode::OPTIMISTIC && $lockMode !== LockMode::PESSIMISTIC_READ && $lockMode !== LockMode::PESSIMISTIC_WRITE) {
+            throw QueryException::invalidLockMode();
+        }
+
+        if ($lockMode === LockMode::PESSIMISTIC_READ) {
+            $sql .= ' ' . $platform->getReadLockSQL();
+        } elseif ($lockMode === LockMode::PESSIMISTIC_WRITE) {
+            $sql .= ' ' . $platform->getWriteLockSQL();
+        }
+
+        return $sql;
+    }
+
+    public function createExecutor(Query $query): AbstractSqlExecutor
+    {
+        return new FinalizedSelectExecutor($this->finalizeSql($query));
+    }
+}

lib/Doctrine/ORM/Query/Exec/SqlFinalizer.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Query\Exec;
+
+use Doctrine\ORM\Query;
+
+/**
+ * SqlFinalizers are created by OutputWalkers that traversed the DQL AST.
+ * The SqlFinalizer instance can be kept in the query cache and re-used
+ * at a later time.
+ *
+ * Once the SqlFinalizer has been created or retrieved from the query cache,
+ * it receives the Query object again in order to yield the AbstractSqlExecutor
+ * that will then be used to execute the query.
+ *
+ * The SqlFinalizer may assume that the DQL that was used to build the AST
+ * and run the OutputWalker (which created the SqlFinalizer) is equivalent to
+ * the query that will be passed to the createExecutor() method. Potential differences
+ * are the parameter values or firstResult/maxResult settings.
+ */
+interface SqlFinalizer
+{
+    public function createExecutor(Query $query): AbstractSqlExecutor;
+}

lib/Doctrine/ORM/Query/OutputWalker.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Query;
+
+use Doctrine\ORM\Query\Exec\SqlFinalizer;
+
+/**
+ * Interface for output walkers
+ *
+ * Output walkers, like tree walkers, can traverse the DQL AST to perform
+ * their purpose.
+ *
+ * The goal of an OutputWalker is to ultimately provide the SqlFinalizer
+ * which produces the final, executable SQL statement in a "finalization" phase.
+ */
+interface OutputWalker extends TreeWalker
+{
+    /** @param AST\DeleteStatement|AST\UpdateStatement|AST\SelectStatement $AST */
+    public function getFinalizer($AST): SqlFinalizer;
+}

lib/Doctrine/ORM/Query/Parser.php

@@ -391,11 +391,16 @@ public function parse()
             $this->queryComponents = $treeWalkerChain->getQueryComponents();
         }
 
-        $outputWalkerClass = $this->customOutputWalker ?: SqlWalker::class;
+        $outputWalkerClass = $this->customOutputWalker ?: SqlOutputWalker::class;
         $outputWalker      = new $outputWalkerClass($this->query, $this->parserResult, $this->queryComponents);
 
-        // Assign an SQL executor to the parser result
-        $this->parserResult->setSqlExecutor($outputWalker->getExecutor($AST));
+        if ($outputWalker instanceof OutputWalker) {
+            $finalizer = $outputWalker->getFinalizer($AST);
+            $this->parserResult->setSqlFinalizer($finalizer);
+        } else {
+            $executor = $outputWalker->getExecutor($AST);
+            $this->parserResult->setSqlExecutor($executor);
+        }
 
         return $this->parserResult;
     }

lib/Doctrine/ORM/Query/ParserResult.php

@@ -5,6 +5,8 @@
 namespace Doctrine\ORM\Query;
 
 use Doctrine\ORM\Query\Exec\AbstractSqlExecutor;
+use Doctrine\ORM\Query\Exec\SqlFinalizer;
+use RuntimeException;
 
 use function sprintf;
 
@@ -20,6 +22,7 @@
         'sqlExecutor' => '_sqlExecutor',
         'resultSetMapping' => '_resultSetMapping',
         'parameterMappings' => '_parameterMappings',
+        'sqlFinalizer' => 'sqlFinalizer',
     ];
 
     /**
@@ -29,6 +32,13 @@
      */
     private $sqlExecutor;
 
+    /**
+     * The SQL executor used for executing the SQL.
+     *
+     * @var SqlFinalizer
+     */
+    private $sqlFinalizer = null;
+
     /**
      * The ResultSetMapping that describes how to map the SQL result set.
      *
@@ -94,6 +104,25 @@
         return $this->sqlExecutor;
     }
 
+    public function setSqlFinalizer(SqlFinalizer $finalizer): void
+    {
+        $this->sqlFinalizer = $finalizer;
+    }
+
+    public function getSqlFinalizer(): SqlFinalizer
+    {
+        if ($this->sqlFinalizer === null) {
+            throw new RuntimeException('This ParserResult was not created with an SqlFinalizer');
+        }
+
+        return $this->sqlFinalizer;
+    }
+
+    public function hasSqlFinalizer(): bool
+    {
+        return $this->sqlFinalizer !== null;
+    }
+
     /**
      * Adds a DQL to SQL parameter mapping. One DQL parameter name/position can map to
      * several SQL parameter positions.

lib/Doctrine/ORM/Query/SqlOutputWalker.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Query;
+
+use Doctrine\ORM\Query\Exec\PreparedExecutorFinalizer;
+use Doctrine\ORM\Query\Exec\SingleSelectSqlFinalizer;
+use Doctrine\ORM\Query\Exec\SqlFinalizer;
+
+class SqlOutputWalker extends SqlWalker implements OutputWalker
+{
+    public function getFinalizer($AST): SqlFinalizer
+    {
+        if (! $AST instanceof AST\SelectStatement) {
+            return new PreparedExecutorFinalizer(parent::getExecutor($AST));
+        }
+
+        return new SingleSelectSqlFinalizer($this->createSqlForFinalizer($AST));
+    }
+}