Make serialized SQL executors forward compatible

UPGRADE.md

@@ -1,5 +1,9 @@
 # Upgrade to 2.17
 
+## Deprecate `Doctrine\ORM\Query\Exec\AbstractSqlExecutor::_sqlStatements`
+
+Use `Doctrine\ORM\Query\Exec\AbstractSqlExecutor::sqlStatements` instead.
+
 ## Undeprecate `Doctrine\ORM\Proxy\Autoloader`
 
 It will be a full-fledged class, no longer extending

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

@@ -9,6 +9,9 @@
 use Doctrine\DBAL\Result;
 use Doctrine\DBAL\Types\Type;
 
+use function array_diff_key;
+use function array_keys;
+
 /**
  * Base class for SQL statement executors.
  *
@@ -18,34 +21,43 @@
  */
 abstract class AbstractSqlExecutor
 {
-    /** @var list<string>|string */
+    /**
+     * @deprecated use $sqlStatements instead
+     *
+     * @var list<string>|string
+     */
     protected $_sqlStatements;
 
+    /** @var list<string>|string */
+    protected $sqlStatements;
+
     /** @var QueryCacheProfile */
     protected $queryCacheProfile;
 
+    public function __construct()
+    {
+        $this->_sqlStatements = &$this->sqlStatements;
+    }
+
     /**
      * Gets the SQL statements that are executed by the executor.
      *
      * @return mixed[]|string  All the SQL update statements.
      */
     public function getSqlStatements()
     {
-        return $this->_sqlStatements;
+        return $this->sqlStatements;
     }
 
-    /** @return void */
-    public function setQueryCacheProfile(QueryCacheProfile $qcp)
+    public function setQueryCacheProfile(QueryCacheProfile $qcp): void
     {
         $this->queryCacheProfile = $qcp;
     }
 
     /**
      * Do not use query cache
-     *
-     * @return void
      */
-    public function removeQueryCacheProfile()
+    public function removeQueryCacheProfile(): void
     {
         $this->queryCacheProfile = null;
     }
@@ -60,4 +72,15 @@ public function removeQueryCacheProfile()
      * @return Result|int
      */
     abstract public function execute(Connection $conn, array $params, array $types);
+
+    /** @return list<string> */
+    public function __sleep(): array
+    {
+        return array_diff_key(array_keys((array) $this), ['*_sqlStatements']);
+    }
+
+    public function __wakeup(): void
+    {
+        $this->_sqlStatements = &$this->sqlStatements;
+    }
 }

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

@@ -45,6 +45,8 @@ class MultiTableDeleteExecutor extends AbstractSqlExecutor
      */
     public function __construct(AST\Node $AST, $sqlWalker)
     {
+        parent::__construct();
+
         $em            = $sqlWalker->getEntityManager();
         $conn          = $em->getConnection();
         $platform      = $conn->getDatabasePlatform();
@@ -84,7 +86,7 @@ public function __construct(AST\Node $AST, $sqlWalker)
         $classNames = array_merge($primaryClass->parentClasses, [$primaryClass->name], $primaryClass->subClasses);
         foreach (array_reverse($classNames) as $className) {
             $tableName              = $quoteStrategy->getTableName($em->getClassMetadata($className), $platform);
-            $this->_sqlStatements[] = 'DELETE FROM ' . $tableName
+            $this->sqlStatements[] = 'DELETE FROM ' . $tableName
                     . ' WHERE (' . $idColumnList . ') IN (' . $idSubselect . ')';
         }
 
@@ -117,7 +119,7 @@ public function execute(Connection $conn, array $params, array $types)
             $numDeleted = $conn->executeStatement($this->insertSql, $params, $types);
 
             // Execute DELETE statements
-            foreach ($this->_sqlStatements as $sql) {
+            foreach ($this->sqlStatements as $sql) {
                 $conn->executeStatement($sql);
             }
         } catch (Throwable $exception) {

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

@@ -50,6 +50,8 @@ class MultiTableUpdateExecutor extends AbstractSqlExecutor
      */
     public function __construct(AST\Node $AST, $sqlWalker)
     {
+        parent::__construct();
+
         $em            = $sqlWalker->getEntityManager();
         $conn          = $em->getConnection();
         $platform      = $conn->getDatabasePlatform();
@@ -119,7 +121,7 @@ public function __construct(AST\Node $AST, $sqlWalker)
             }
 
             if ($affected) {
-                $this->_sqlStatements[$i] = $updateSql . ' WHERE (' . $idColumnList . ') IN (' . $idSubselect . ')';
+                $this->sqlStatements[$i] = $updateSql . ' WHERE (' . $idColumnList . ') IN (' . $idSubselect . ')';
             }
         }
 
@@ -163,7 +165,7 @@ public function execute(Connection $conn, array $params, array $types)
             );
 
             // Execute UPDATE statements
-            foreach ($this->_sqlStatements as $key => $statement) {
+            foreach ($this->sqlStatements as $key => $statement) {
                 $paramValues = [];
                 $paramTypes  = [];
 

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

@@ -18,7 +18,9 @@ class SingleSelectExecutor extends AbstractSqlExecutor
 {
     public function __construct(SelectStatement $AST, SqlWalker $sqlWalker)
     {
-        $this->_sqlStatements = $sqlWalker->walkSelectStatement($AST);
+        parent::__construct();
+
+        $this->sqlStatements = $sqlWalker->walkSelectStatement($AST);
     }
 
     /**
@@ -28,6 +30,6 @@ public function __construct(SelectStatement $AST, SqlWalker $sqlWalker)
      */
     public function execute(Connection $conn, array $params, array $types)
     {
-        return $conn->executeQuery($this->_sqlStatements, $params, $types, $this->queryCacheProfile);
+        return $conn->executeQuery($this->sqlStatements, $params, $types, $this->queryCacheProfile);
     }
 }

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

@@ -22,10 +22,12 @@ class SingleTableDeleteUpdateExecutor extends AbstractSqlExecutor
     /** @param SqlWalker $sqlWalker */
     public function __construct(AST\Node $AST, $sqlWalker)
     {
+        parent::__construct();
+
         if ($AST instanceof AST\UpdateStatement) {
-            $this->_sqlStatements = $sqlWalker->walkUpdateStatement($AST);
+            $this->sqlStatements = $sqlWalker->walkUpdateStatement($AST);
         } elseif ($AST instanceof AST\DeleteStatement) {
-            $this->_sqlStatements = $sqlWalker->walkDeleteStatement($AST);
+            $this->sqlStatements = $sqlWalker->walkDeleteStatement($AST);
         }
     }
 
@@ -40,6 +42,6 @@ public function execute(Connection $conn, array $params, array $types)
             $conn->ensureConnectedToPrimary();
         }
 
-        return $conn->executeStatement($this->_sqlStatements, $params, $types);
+        return $conn->executeStatement($this->sqlStatements, $params, $types);
     }
 }

tests/Doctrine/Tests/ORM/Functional/ParserResultSerializationTest.php

@@ -11,6 +11,7 @@
 use Doctrine\Tests\OrmFunctionalTestCase;
 use Generator;
 use ReflectionMethod;
+use ReflectionProperty;
 
 use function file_get_contents;
 use function rtrim;
@@ -33,12 +34,19 @@ public function testSerializeParserResult(): void
 
         $parserResult = self::parseQuery($query);
         $serialized   = serialize($parserResult);
+        $this->assertSame(rtrim(file_get_contents(__DIR__ . '/ParserResults/single_select_3_0_0.txt'), "\n"), $serialized);
         $unserialized = unserialize($serialized);
 
         $this->assertInstanceOf(ParserResult::class, $unserialized);
         $this->assertInstanceOf(ResultSetMapping::class, $unserialized->getResultSetMapping());
         $this->assertEquals(['name' => [0]], $unserialized->getParameterMappings());
         $this->assertInstanceOf(SingleSelectExecutor::class, $unserialized->getSqlExecutor());
+        $this->assertIsString($unserialized->getSqlExecutor()->getSqlStatements());
+
+        $r = new ReflectionProperty($unserialized->getSqlExecutor(), '_sqlStatements');
+        $r->setAccessible(true);
+
+        $this->assertIsString($r->getValue($unserialized->getSqlExecutor()));
     }
 
     /**