Introduced finalizeAndExecute to the AbstractSqlWalker, unified SingleStatementExecutor

psalm-baseline.xml

@@ -861,20 +861,6 @@
       <code><![CDATA[$this->sqlStatements]]></code>
     </PossiblyInvalidArgument>
   </file>
-  <file src="src/Query/Exec/SingleTableDeleteUpdateExecutor.php">
-    <InvalidReturnStatement>
-      <code><![CDATA[$conn->executeStatement($this->sqlStatements, $params, $types)]]></code>
-    </InvalidReturnStatement>
-    <InvalidReturnType>
-      <code><![CDATA[int]]></code>
-    </InvalidReturnType>
-    <PossiblyInvalidArgument>
-      <code><![CDATA[$this->sqlStatements]]></code>
-    </PossiblyInvalidArgument>
-    <PropertyNotSetInConstructor>
-      <code><![CDATA[SingleTableDeleteUpdateExecutor]]></code>
-    </PropertyNotSetInConstructor>
-  </file>
   <file src="src/Query/Expr/Andx.php">
     <NonInvariantDocblockPropertyType>
       <code><![CDATA[$allowedClasses]]></code>

src/Query.php

@@ -281,7 +281,7 @@ protected function _doExecute(): Result|int
             $this->em->getConnection()->getParams(),
         );
 
-        return $executor->execute($this->em->getConnection(), $sqlParams, $types);
+        return $executor->finalizeAndExecute($this, $this->em->getConnection(), $sqlParams, $types);
     }
 
     /**
@@ -660,7 +660,6 @@ protected function getQueryCacheId(): string
             $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 .
             '&hydrationMode=' . $this->hydrationMode . '&types=' . serialize($this->parsedTypes) . 'DOCTRINE_QUERY_CACHE_SALT',
         );
     }

src/Query/Exec/AbstractSqlExecutor.php

@@ -4,12 +4,11 @@
 
 namespace Doctrine\ORM\Query\Exec;
 
-use Doctrine\DBAL\ArrayParameterType;
 use Doctrine\DBAL\Cache\QueryCacheProfile;
 use Doctrine\DBAL\Connection;
-use Doctrine\DBAL\ParameterType;
 use Doctrine\DBAL\Result;
-use Doctrine\DBAL\Types\Type;
+use Doctrine\ORM\Query;
+use Doctrine\ORM\Query\SqlWalker;
 
 /**
  * Base class for SQL statement executors.
@@ -20,7 +19,7 @@
  * @psalm-type WrapperParameterType = string|Type|ParameterType::*|ArrayParameterType::*
  * @psalm-type WrapperParameterTypeArray = array<int<0, max>, WrapperParameterType>|array<string, WrapperParameterType>
  */
 abstract class AbstractSqlExecutor
 {
     /** @var list<string>|string */
     protected array|string $sqlStatements;
@@ -50,12 +49,25 @@
         $this->queryCacheProfile = null;
     }
 
+    /**
+     * Finalize and executes all sql statements.
+     *
+     * @param Query                            $query  The query to be finalized and executed.
+     * @param Connection                       $conn   The database connection that is used to execute the queries.
+     * @param list<mixed>|array<string, mixed> $params The parameters.
+     * @psalm-param WrapperParameterTypeArray  $types  The parameter types.
+     */
+    public function finalizeAndExecute(Query $query, Connection $connection, array $params, array $types)
+    {
+        return $this->execute($connection, $params, $types);
+    }
+
     /**
      * Executes all sql statements.
      *
      * @param Connection                       $conn   The database connection that is used to execute the queries.
      * @param list<mixed>|array<string, mixed> $params The parameters.
      * @psalm-param WrapperParameterTypeArray  $types  The parameter types.
      */
     abstract public function execute(Connection $conn, array $params, array $types): Result|int;
 }

src/Query/Exec/SingleStatementExecutor.php

@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Query\Exec;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Connections\PrimaryReadReplicaConnection;
+use Doctrine\DBAL\LockMode;
+use Doctrine\DBAL\Result;
+use Doctrine\ORM\OptimisticLockException;
+use Doctrine\ORM\Query;
+use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\AST;
+use Doctrine\ORM\Utility\LockSqlHelper;
+
+/**
+ * Executor that executes the SQL statement for simple DQL SELECT/UPDATE/DELETE statements.
+ *
+ * @link        www.doctrine-project.org
+ */
+class SingleStatementExecutor extends AbstractSqlExecutor
+{
+    use LockSqlHelper;
+
+    private array $selectedClasses;
+
+    public function __construct(AST\Node $AST, SqlWalker $sqlWalker)
+    {
+        $this->selectedClasses = $sqlWalker->getSelectedClasses();
+        if ($AST instanceof AST\SelectStatement) {
+            $this->sqlStatements = $sqlWalker->walkSelectStatement($AST);
+        } elseif ($AST instanceof AST\UpdateStatement) {
+            $this->sqlStatements = $sqlWalker->walkUpdateStatement($AST);
+        } elseif ($AST instanceof AST\DeleteStatement) {
+            $this->sqlStatements = $sqlWalker->walkDeleteStatement($AST);
+        }
+    }
+
+    public function finalizeAndExecute(Query $query, Connection $connection, array $params, array $types)
+    {
+        $platform = $connection->getDatabasePlatform();
+        $lockMode = $query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE;
+
+        $this->sqlStatements = $platform->modifyLimitQuery(
+            $this->sqlStatements,
+            $query->getFirstResult(),
+            $query->getMaxResults()
+        );
+
+        if ($lockMode === LockMode::PESSIMISTIC_READ) {
+            $this->sqlStatements = $this->sqlStatements . ' ' . $this->getReadLockSQL($platform);
+        } elseif ($lockMode === LockMode::PESSIMISTIC_WRITE) {
+            $this->sqlStatements = $this->sqlStatements . ' ' . $this->getWriteLockSQL($platform);
+        } elseif ($lockMode === LockMode::OPTIMISTIC) {
+            foreach ($this->selectedClasses as $selectedClass) {
+                if (!$selectedClass['class']->isVersioned) {
+                    throw OptimisticLockException::lockFailed($selectedClass['class']->name);
+                }
+            }
+        }
+
+        return parent::finalizeAndExecute($query, $connection, $params, $types);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function execute(Connection $conn, array $params, array $types): Result
+    {
+        if ($conn instanceof PrimaryReadReplicaConnection) {
+            $conn->ensureConnectedToPrimary();
+        }
+        return $conn->executeQuery($this->sqlStatements, $params, $types, $this->queryCacheProfile);
+    }
+}

src/Query/SqlWalker.php

@@ -225,15 +225,15 @@ public function getExecutor(AST\SelectStatement|AST\UpdateStatement|AST\DeleteSt
     {
         return match (true) {
             $statement instanceof AST\SelectStatement
-                => new Exec\SingleSelectExecutor($statement, $this),
+                => new Exec\SingleStatementExecutor($statement, $this),
             $statement instanceof AST\UpdateStatement
                 => $this->em->getClassMetadata($statement->updateClause->abstractSchemaName)->isInheritanceTypeJoined()
                     ? new Exec\MultiTableUpdateExecutor($statement, $this)
-                    : new Exec\SingleTableDeleteUpdateExecutor($statement, $this),
+                    : new Exec\SingleStatementExecutor($statement, $this),
             $statement instanceof AST\DeleteStatement
                 => $this->em->getClassMetadata($statement->deleteClause->abstractSchemaName)->isInheritanceTypeJoined()
                     ? new Exec\MultiTableDeleteExecutor($statement, $this)
-                    : new Exec\SingleTableDeleteUpdateExecutor($statement, $this),
+                    : new Exec\SingleStatementExecutor($statement, $this),
         };
     }
 
@@ -464,10 +464,7 @@ private function generateFilterConditionSQL(
      */
     public function walkSelectStatement(AST\SelectStatement $selectStatement): string
     {
-        $limit    = $this->query->getMaxResults();
-        $offset   = $this->query->getFirstResult();
-        $lockMode = $this->query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE;
-        $sql      = $this->walkSelectClause($selectStatement->selectClause)
+        $sql = $this->walkSelectClause($selectStatement->selectClause)
             . $this->walkFromClause($selectStatement->fromClause)
             . $this->walkWhereClause($selectStatement->whereClause);
 
@@ -488,30 +485,6 @@ public function walkSelectStatement(AST\SelectStatement $selectStatement): strin
             $sql .= ' ORDER BY ' . $orderBySql;
         }
 
-        $sql = $this->platform->modifyLimitQuery($sql, $limit, $offset);
-
-        if ($lockMode === LockMode::NONE) {
-            return $sql;
-        }
-
-        if ($lockMode === LockMode::PESSIMISTIC_READ) {
-            return $sql . ' ' . $this->getReadLockSQL($this->platform);
-        }
-
-        if ($lockMode === LockMode::PESSIMISTIC_WRITE) {
-            return $sql . ' ' . $this->getWriteLockSQL($this->platform);
-        }
-
-        if ($lockMode !== LockMode::OPTIMISTIC) {
-            throw QueryException::invalidLockMode();
-        }
-
-        foreach ($this->selectedClasses as $selectedClass) {
-            if (! $selectedClass['class']->isVersioned) {
-                throw OptimisticLockException::lockFailed($selectedClass['class']->name);
-            }
-        }
-
         return $sql;
     }
 
@@ -2226,6 +2199,14 @@ public function walkResultVariable(string $resultVariable): string
         return $resultAlias;
     }
 
+    /**
+     * @return array A list of classes that appear in non-scalar SelectExpressions.
+     */
+    public function getSelectedClasses(): array
+    {
+        return $this->selectedClasses;
+    }
+
     /**
      * @return string The list in parentheses of valid child discriminators from the given class
      *

tests/Tests/ORM/Functional/ParserResultSerializationTest.php

@@ -6,7 +6,7 @@
 
 use Closure;
 use Doctrine\ORM\Query;
-use Doctrine\ORM\Query\Exec\SingleSelectExecutor;
+use Doctrine\ORM\Query\Exec\SingleStatementExecutor;
 use Doctrine\ORM\Query\ParserResult;
 use Doctrine\ORM\Query\ResultSetMapping;
 use Doctrine\Tests\OrmFunctionalTestCase;
@@ -43,7 +43,7 @@ public function testSerializeParserResult(Closure $toSerializedAndBack): void
         $this->assertInstanceOf(ParserResult::class, $unserialized);
         $this->assertInstanceOf(ResultSetMapping::class, $unserialized->getResultSetMapping());
         $this->assertEquals(['name' => [0]], $unserialized->getParameterMappings());
-        $this->assertInstanceOf(SingleSelectExecutor::class, $unserialized->getSqlExecutor());
+        $this->assertInstanceOf(SingleStatementExecutor::class, $unserialized->getSqlExecutor());
     }
 
     /** @return Generator<string, array{Closure(ParserResult): ParserResult}> */
@@ -75,7 +75,7 @@ public function testUnserializeSingleSelectResult(string $serialized): void
         $this->assertInstanceOf(ParserResult::class, $unserialized);
         $this->assertInstanceOf(ResultSetMapping::class, $unserialized->getResultSetMapping());
         $this->assertEquals(['name' => [0]], $unserialized->getParameterMappings());
-        $this->assertInstanceOf(SingleSelectExecutor::class, $unserialized->getSqlExecutor());
+        $this->assertInstanceOf(SingleStatementExecutor::class, $unserialized->getSqlExecutor());
         $this->assertIsString($unserialized->getSqlExecutor()->getSqlStatements());
     }
 
@@ -87,7 +87,7 @@ public static function provideSerializedSingleSelectResults(): Generator
 
     public function testSymfony44ProvidedData(): void
     {
-        $sqlExecutor      = $this->createMock(SingleSelectExecutor::class);
+        $sqlExecutor      = $this->createMock(SingleStatementExecutor::class);
         $resultSetMapping = $this->createMock(ResultSetMapping::class);
 
         $parserResult = new ParserResult();
@@ -101,7 +101,7 @@ public function testSymfony44ProvidedData(): void
         $this->assertInstanceOf(ParserResult::class, $unserialized);
         $this->assertInstanceOf(ResultSetMapping::class, $unserialized->getResultSetMapping());
         $this->assertEquals(['name' => [0]], $unserialized->getParameterMappings());
-        $this->assertInstanceOf(SingleSelectExecutor::class, $unserialized->getSqlExecutor());
+        $this->assertInstanceOf(SingleStatementExecutor::class, $unserialized->getSqlExecutor());
     }
 
     private static function parseQuery(Query $query): ParserResult