Merge pull request #11525 from greg0ire/3.2.x

Merge 2.19.x up into 3.2.x

.doctrine-project.json

@@ -11,17 +11,23 @@
             "slug": "latest",
             "upcoming": true
         },
+        {
+            "name": "3.3",
+            "branchName": "3.3.x",
+            "slug": "3.3",
+            "upcoming": true
+        },
         {
             "name": "3.2",
             "branchName": "3.2.x",
             "slug": "3.2",
-            "upcoming": true
+            "current": true
         },
         {
             "name": "3.1",
             "branchName": "3.1.x",
             "slug": "3.1",
-            "current": true
+            "maintained": false
         },
         {
             "name": "3.0",

.github/workflows/continuous-integration.yml

@@ -185,7 +185,7 @@ jobs:
           - "3.7"
           - "4@dev"
         mariadb-version:
-          - "10.9"
+          - "11.4"
         extension:
           - "mysqli"
           - "pdo_mysql"
@@ -194,11 +194,11 @@ jobs:
       mariadb:
         image: "mariadb:${{ matrix.mariadb-version }}"
         env:
-          MYSQL_ALLOW_EMPTY_PASSWORD: yes
-          MYSQL_DATABASE: "doctrine_tests"
+          MARIADB_ALLOW_EMPTY_ROOT_PASSWORD: yes
+          MARIADB_DATABASE: "doctrine_tests"
 
         options: >-
-          --health-cmd "mysqladmin ping --silent"
+          --health-cmd "healthcheck.sh --connect --innodb_initialized"
 
         ports:
           - "3306:3306"

README.md

@@ -1,7 +1,7 @@
-|                      [4.0.x][4.0]                      |                      [3.2.x][3.2]                      |                      [3.1.x][3.1]                      |                      [2.20.x][2.20]                      |                      [2.19.x][2.19]                      |
+|                      [4.0.x][4.0]                      |                      [3.3.x][3.3]                      |                      [3.2.x][3.2]                      |                      [2.20.x][2.20]                      |                      [2.19.x][2.19]                      |
 |:------------------------------------------------------:|:------------------------------------------------------:|:------------------------------------------------------:|:--------------------------------------------------------:|:--------------------------------------------------------:|
-|           [![Build status][4.0 image]][4.0]            |           [![Build status][3.2 image]][3.2]            |           [![Build status][3.1 image]][3.1]            |           [![Build status][2.20 image]][2.20]            |           [![Build status][2.19 image]][2.19]            |
-| [![Coverage Status][4.0 coverage image]][4.0 coverage] | [![Coverage Status][3.2 coverage image]][3.2 coverage] | [![Coverage Status][3.1 coverage image]][3.1 coverage] | [![Coverage Status][2.20 coverage image]][2.20 coverage] | [![Coverage Status][2.19 coverage image]][2.19 coverage] |
+|           [![Build status][4.0 image]][4.0]            |           [![Build status][3.3 image]][3.3]            |           [![Build status][3.2 image]][3.2]            |           [![Build status][2.20 image]][2.20]            |           [![Build status][2.19 image]][2.19]            |
+| [![Coverage Status][4.0 coverage image]][4.0 coverage] | [![Coverage Status][3.3 coverage image]][3.3 coverage] | [![Coverage Status][3.2 coverage image]][3.2 coverage] | [![Coverage Status][2.20 coverage image]][2.20 coverage] | [![Coverage Status][2.19 coverage image]][2.19 coverage] |
 
 [<h1 align="center">🇺🇦 UKRAINE NEEDS YOUR HELP NOW!</h1>](https://www.doctrine-project.org/stop-war.html)
 
@@ -22,14 +22,14 @@ without requiring unnecessary code duplication.
   [4.0]: https://github.com/doctrine/orm/tree/4.0.x
   [4.0 coverage image]: https://codecov.io/gh/doctrine/orm/branch/4.0.x/graph/badge.svg
   [4.0 coverage]: https://codecov.io/gh/doctrine/orm/branch/4.0.x
+  [3.3 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=3.3.x
+  [3.3]: https://github.com/doctrine/orm/tree/3.3.x
+  [3.3 coverage image]: https://codecov.io/gh/doctrine/orm/branch/3.3.x/graph/badge.svg
+  [3.3 coverage]: https://codecov.io/gh/doctrine/orm/branch/3.3.x
   [3.2 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=3.2.x
   [3.2]: https://github.com/doctrine/orm/tree/3.2.x
   [3.2 coverage image]: https://codecov.io/gh/doctrine/orm/branch/3.2.x/graph/badge.svg
   [3.2 coverage]: https://codecov.io/gh/doctrine/orm/branch/3.2.x
-  [3.1 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=3.1.x
-  [3.1]: https://github.com/doctrine/orm/tree/3.1.x
-  [3.1 coverage image]: https://codecov.io/gh/doctrine/orm/branch/3.1.x/graph/badge.svg
-  [3.1 coverage]: https://codecov.io/gh/doctrine/orm/branch/3.1.x
   [2.20 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=2.20.x
   [2.20]: https://github.com/doctrine/orm/tree/2.20.x
   [2.20 coverage image]: https://codecov.io/gh/doctrine/orm/branch/2.20.x/graph/badge.svg

UPGRADE.md

@@ -1,3 +1,29 @@
+# Upgrade to 3.2
+
+## Deprecate the `NotSupported` exception
+
+The class `Doctrine\ORM\Exception\NotSupported` is deprecated without replacement.
+
+## Deprecate remaining `Serializable` implementation
+
+Relying on `SequenceGenerator` implementing the `Serializable` is deprecated
+because that interface won't be implemented in ORM 4 anymore.
+
+The following methods are deprecated:
+
+* `SequenceGenerator::serialize()`
+* `SequenceGenerator::unserialize()`
+
+## `orm:schema-tool:update` option `--complete` is deprecated
+
+That option behaves as a no-op, and is deprecated. It will be removed in 4.0.
+
+## Deprecate properties `$indexes` and `$uniqueConstraints` of `Doctrine\ORM\Mapping\Table`
+
+The properties `$indexes` and `$uniqueConstraints` have been deprecated since they had no effect at all.
+The preferred way of defining indices and unique constraints is by
+using the `\Doctrine\ORM\Mapping\UniqueConstraint` and `\Doctrine\ORM\Mapping\Index` attributes.
+
 # Upgrade to 3.1
 
 ## Deprecate `Doctrine\ORM\Mapping\ReflectionEnumProperty`

docs/en/reference/transactions-and-concurrency.rst

@@ -88,7 +88,7 @@ requirement.
 
 A more convenient alternative for explicit transaction demarcation is the use
 of provided control abstractions in the form of
-``Connection#transactional($func)`` and ``EntityManager#transactional($func)``.
+``Connection#transactional($func)`` and ``EntityManager#wrapInTransaction($func)``.
 When used, these control abstractions ensure that you never forget to rollback
 the transaction, in addition to the obvious code reduction. An example that is
 functionally equivalent to the previously shown code looks as follows:
@@ -96,21 +96,23 @@ functionally equivalent to the previously shown code looks as follows:
 .. code-block:: php
 
     <?php
+    // transactional with Connection instance
+    // $conn instanceof Connection
+    $conn->transactional(function($conn) {
+        // ... do some work
+        $user = new User;
+        $user->setName('George');
+    });
+
+    // transactional with EntityManager instance
     // $em instanceof EntityManager
-    $em->transactional(function($em) {
+    $em->wrapInTransaction(function($em) {
         // ... do some work
         $user = new User;
         $user->setName('George');
         $em->persist($user);
     });
 
-.. warning::
-
-    For historical reasons, ``EntityManager#transactional($func)`` will return
-    ``true`` whenever the return value of ``$func`` is loosely false.
-    Some examples of this include ``array()``, ``"0"``, ``""``, ``0``, and
-    ``null``.
-
 The difference between ``Connection#transactional($func)`` and
 ``EntityManager#transactional($func)`` is that the latter
 abstraction flushes the ``EntityManager`` prior to transaction

docs/en/tutorials/composite-primary-keys.rst

@@ -145,7 +145,7 @@ We keep up the example of an Article with arbitrary attributes, the mapping look
             #[OneToMany(targetEntity: ArticleAttribute::class, mappedBy: 'article', cascade: ['ALL'], indexBy: 'attribute')]
             private Collection $attributes;
 
-            public function addAttribute(string $name, ArticleAttribute $value): void
+            public function addAttribute(string $name, string $value): void
             {
                 $this->attributes[$name] = new ArticleAttribute($name, $value, $this);
             }

phpcs.xml.dist

@@ -14,7 +14,6 @@
     <file>src</file>
     <file>tests</file>
 
-    <exclude-pattern>*/src/Mapping/InverseJoinColumn.php</exclude-pattern>
     <exclude-pattern>*/tests/Tests/Proxies/__CG__*</exclude-pattern>
     <exclude-pattern>*/tests/Tests/ORM/Tools/Export/export/*</exclude-pattern>
 

psalm-baseline.xml

@@ -497,13 +497,8 @@
     <InvalidPropertyAssignmentValue>
       <code><![CDATA[$metadata->table]]></code>
     </InvalidPropertyAssignmentValue>
-    <InvalidPropertyFetch>
-      <code><![CDATA[$xmlRoot->{'discriminator-column'}]]></code>
-      <code><![CDATA[$xmlRoot->{'discriminator-map'}]]></code>
-    </InvalidPropertyFetch>
     <InvalidReturnStatement>
       <code><![CDATA[$mapping]]></code>
-      <code><![CDATA[$result]]></code>
       <code><![CDATA[[
             'usage'  => $usage,
             'region' => $region,
@@ -527,20 +522,10 @@
       *                   options?: array
       *               }]]></code>
       <code><![CDATA[array{usage: int|null, region?: string}]]></code>
-      <code><![CDATA[loadMappingFile]]></code>
     </InvalidReturnType>
     <MoreSpecificImplementedParamType>
       <code><![CDATA[$metadata]]></code>
     </MoreSpecificImplementedParamType>
-    <NoInterfaceProperties>
-      <code><![CDATA[$xmlRoot->{'discriminator-column'}]]></code>
-      <code><![CDATA[$xmlRoot->{'discriminator-map'}]]></code>
-    </NoInterfaceProperties>
-    <TypeDoesNotContainType>
-      <code><![CDATA[$xmlRoot->getName() === 'embeddable']]></code>
-      <code><![CDATA[$xmlRoot->getName() === 'entity']]></code>
-      <code><![CDATA[$xmlRoot->getName() === 'mapped-superclass']]></code>
-    </TypeDoesNotContainType>
   </file>
   <file src="src/Mapping/ManyToManyInverseSideMapping.php">
     <PropertyNotSetInConstructor>
@@ -756,7 +741,9 @@
       <code><![CDATA[$autoGenerate > 4]]></code>
     </TypeDoesNotContainType>
     <UndefinedMethod>
-      <code><![CDATA[self::createLazyGhost($initializer, $skippedProperties)]]></code>
+      <code><![CDATA[self::createLazyGhost(static function (InternalProxy $object) use ($initializer, $identifier): void {
+                $initializer($object, $identifier);
+            }, $skippedProperties)]]></code>
     </UndefinedMethod>
     <UnresolvableInclude>
       <code><![CDATA[require $fileName]]></code>

src/EntityManager.php

@@ -63,27 +63,27 @@ class EntityManager implements EntityManagerInterface
     /**
      * The metadata factory, used to retrieve the ORM metadata of entity classes.
      */
-    private readonly ClassMetadataFactory $metadataFactory;
+    private ClassMetadataFactory $metadataFactory;
 
     /**
      * The UnitOfWork used to coordinate object-level transactions.
      */
-    private readonly UnitOfWork $unitOfWork;
+    private UnitOfWork $unitOfWork;
 
     /**
      * The event manager that is the central point of the event system.
      */
-    private readonly EventManager $eventManager;
+    private EventManager $eventManager;
 
     /**
      * The proxy factory used to create dynamic proxies.
      */
-    private readonly ProxyFactory $proxyFactory;
+    private ProxyFactory $proxyFactory;
 
     /**
      * The repository factory used to create dynamic repositories.
      */
-    private readonly RepositoryFactory $repositoryFactory;
+    private RepositoryFactory $repositoryFactory;
 
     /**
      * The expression builder instance used to generate query expressions.
@@ -112,8 +112,8 @@ class EntityManager implements EntityManagerInterface
      * @param Connection $conn The database connection used by the EntityManager.
      */
     public function __construct(
-        private readonly Connection $conn,
-        private readonly Configuration $config,
+        private Connection $conn,
+        private Configuration $config,
         EventManager|null $eventManager = null,
     ) {
         if (! $config->getMetadataDriverImpl()) {

src/Exception/NotSupported.php

@@ -8,6 +8,7 @@ use LogicException;
 
 use function sprintf;
 
+/** @deprecated */
 final class NotSupported extends LogicException implements ORMException
 {
     public static function create(): self

src/Id/SequenceGenerator.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Id;
 
 use Doctrine\DBAL\Connections\PrimaryReadReplicaConnection;
+use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\EntityManagerInterface;
 use Serializable;
 
@@ -65,8 +66,17 @@ class SequenceGenerator extends AbstractIdGenerator implements Serializable
         return $this->nextValue;
     }
 
+    /** @deprecated without replacement. */
     final public function serialize(): string
     {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/11468',
+            '%s() is deprecated, use __serialize() instead. %s won\'t implement the Serializable interface anymore in ORM 4.',
+            __METHOD__,
+            self::class,
+        );
+
         return serialize($this->__serialize());
     }
 
@@ -79,8 +89,17 @@ class SequenceGenerator extends AbstractIdGenerator implements Serializable
         ];
     }
 
+    /** @deprecated without replacement. */
     final public function unserialize(string $serialized): void
     {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/11468',
+            '%s() is deprecated, use __unserialize() instead. %s won\'t implement the Serializable interface anymore in ORM 4.',
+            __METHOD__,
+            self::class,
+        );
+
         $this->__unserialize(unserialize($serialized));
     }
 

src/Internal/Hydration/ObjectHydrator.php

@@ -356,11 +356,15 @@ class ObjectHydrator extends AbstractHydrator
                     $parentObject = $this->resultPointers[$parentAlias];
                 } else {
                     // Parent object of relation not found, mark as not-fetched again
-                    $element = $this->getEntity($data, $dqlAlias);
+                    if (isset($nonemptyComponents[$dqlAlias])) {
+                        $element = $this->getEntity($data, $dqlAlias);
 
-                    // Update result pointer and provide initial fetch data for parent
-                    $this->resultPointers[$dqlAlias]               = $element;
-                    $rowData['data'][$parentAlias][$relationField] = $element;
+                        // Update result pointer and provide initial fetch data for parent
+                        $this->resultPointers[$dqlAlias]               = $element;
+                        $rowData['data'][$parentAlias][$relationField] = $element;
+                    } else {
+                        $element = null;
+                    }
 
                     // Mark as not-fetched again
                     unset($this->hints['fetched'][$parentAlias][$relationField]);

src/Mapping/Driver/XmlDriver.php

@@ -38,6 +38,8 @@ use function strtoupper;
  * XmlDriver is a metadata driver that enables mapping through XML files.
  *
  * @link        www.doctrine-project.org
+ *
+ * @template-extends FileDriver<SimpleXMLElement>
  */
 class XmlDriver extends FileDriver
 {
@@ -78,7 +80,6 @@ class XmlDriver extends FileDriver
     public function loadMetadataForClass($className, PersistenceClassMetadata $metadata): void
     {
         $xmlRoot = $this->getElement($className);
-        assert($xmlRoot instanceof SimpleXMLElement);
 
         if ($xmlRoot->getName() === 'entity') {
             if (isset($xmlRoot['repository-class'])) {
@@ -134,6 +135,7 @@ class XmlDriver extends FileDriver
                     ];
 
                     if (isset($discrColumn['options'])) {
+                        assert($discrColumn['options'] instanceof SimpleXMLElement);
                         $columnDef['options'] = $this->parseOptions($discrColumn['options']->children());
                     }
 
@@ -145,6 +147,7 @@ class XmlDriver extends FileDriver
                 // Evaluate <discriminator-map...>
                 if (isset($xmlRoot->{'discriminator-map'})) {
                     $map = [];
+                    assert($xmlRoot->{'discriminator-map'}->{'discriminator-mapping'} instanceof SimpleXMLElement);
                     foreach ($xmlRoot->{'discriminator-map'}->{'discriminator-mapping'} as $discrMapElement) {
                         $map[(string) $discrMapElement['value']] = (string) $discrMapElement['class'];
                     }

src/Mapping/InverseJoinColumn.php

@@ -2,7 +2,6 @@
 
 declare(strict_types=1);
 
-
 namespace Doctrine\ORM\Mapping;
 
 use Attribute;

src/Mapping/Table.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Mapping;
 
 use Attribute;
+use Doctrine\Deprecations\Deprecation;
 
 #[Attribute(Attribute::TARGET_CLASS)]
 final class Table implements MappingAttribute
@@ -21,5 +22,24 @@ final class Table implements MappingAttribute
         public readonly array|null $uniqueConstraints = null,
         public readonly array $options = [],
     ) {
+        if ($this->indexes !== null) {
+            Deprecation::trigger(
+                'doctrine/orm',
+                'https://github.com/doctrine/orm/pull/11357',
+                'Providing the property $indexes on %s does not have any effect and will be removed in Doctrine ORM 4.0. Please use the %s attribute instead.',
+                self::class,
+                Index::class,
+            );
+        }
+
+        if ($this->uniqueConstraints !== null) {
+            Deprecation::trigger(
+                'doctrine/orm',
+                'https://github.com/doctrine/orm/pull/11357',
+                'Providing the property $uniqueConstraints on %s does not have any effect and will be removed in Doctrine ORM 4.0. Please use the %s attribute instead.',
+                self::class,
+                UniqueConstraint::class,
+            );
+        }
     }
 }

src/Persisters/Collection/OneToManyPersister.php

@@ -8,6 +8,8 @@ use BadMethodCallException;
 use Doctrine\Common\Collections\Criteria;
 use Doctrine\DBAL\Exception as DBALException;
 use Doctrine\DBAL\Types\Type;
+use Doctrine\ORM\EntityNotFoundException;
+use Doctrine\ORM\Mapping\MappingException;
 use Doctrine\ORM\Mapping\OneToManyAssociationMapping;
 use Doctrine\ORM\PersistentCollection;
 use Doctrine\ORM\Utility\PersisterHelper;
@@ -146,7 +148,11 @@ class OneToManyPersister extends AbstractCollectionPersister
         throw new BadMethodCallException('Filtering a collection by Criteria is not supported by this CollectionPersister.');
     }
 
-    /** @throws DBALException */
+    /**
+     * @throws DBALException
+     * @throws EntityNotFoundException
+     * @throws MappingException
+     */
     private function deleteEntityCollection(PersistentCollection $collection): int
     {
         $mapping     = $this->getMapping($collection);
@@ -166,6 +172,13 @@ class OneToManyPersister extends AbstractCollectionPersister
         $statement = 'DELETE FROM ' . $this->quoteStrategy->getTableName($targetClass, $this->platform)
             . ' WHERE ' . implode(' = ? AND ', $columns) . ' = ?';
 
+        if ($targetClass->isInheritanceTypeSingleTable()) {
+            $discriminatorColumn = $targetClass->getDiscriminatorColumn();
+            $statement          .= ' AND ' . $discriminatorColumn->name . ' = ?';
+            $parameters[]        = $targetClass->discriminatorValue;
+            $types[]             = $discriminatorColumn->type;
+        }
+
         $numAffected = $this->conn->executeStatement($statement, $parameters, $types);
 
         assert(is_int($numAffected));

src/Proxy/ProxyFactory.php

@@ -210,15 +210,14 @@ EOPHP;
     /**
      * Creates a closure capable of initializing a proxy
      *
-     * @return Closure(InternalProxy, InternalProxy):void
+     * @return Closure(InternalProxy, array):void
      *
      * @throws EntityNotFoundException
      */
     private function createLazyInitializer(ClassMetadata $classMetadata, EntityPersister $entityPersister, IdentifierFlattener $identifierFlattener): Closure
     {
-        return static function (InternalProxy $proxy) use ($entityPersister, $classMetadata, $identifierFlattener): void {
-            $identifier = $classMetadata->getIdentifierValues($proxy);
-            $original   = $entityPersister->loadById($identifier);
+        return static function (InternalProxy $proxy, array $identifier) use ($entityPersister, $classMetadata, $identifierFlattener): void {
+            $original = $entityPersister->loadById($identifier);
 
             if ($original === null) {
                 throw EntityNotFoundException::fromClassNameAndIdentifier(
@@ -234,7 +233,7 @@ EOPHP;
             $class = $entityPersister->getClassMetadata();
 
             foreach ($class->getReflectionProperties() as $property) {
-                if (! $property || ! $class->hasField($property->getName()) && ! $class->hasAssociation($property->getName())) {
+                if (! $property || isset($identifier[$property->getName()]) || ! $class->hasField($property->getName()) && ! $class->hasAssociation($property->getName())) {
                     continue;
                 }
 
@@ -283,7 +282,9 @@ EOPHP;
         $identifierFields = array_intersect_key($class->getReflectionProperties(), $identifiers);
 
         $proxyFactory = Closure::bind(static function (array $identifier) use ($initializer, $skippedProperties, $identifierFields, $className): InternalProxy {
-            $proxy = self::createLazyGhost($initializer, $skippedProperties);
+            $proxy = self::createLazyGhost(static function (InternalProxy $object) use ($initializer, $identifier): void {
+                $initializer($object, $identifier);
+            }, $skippedProperties);
 
             foreach ($identifierFields as $idField => $reflector) {
                 if (! isset($identifier[$idField])) {
@@ -386,12 +387,18 @@ EOPHP;
         $code = substr($code, 7 + (int) strpos($code, "\n{"));
         $code = substr($code, 0, (int) strpos($code, "\n}"));
         $code = str_replace('LazyGhostTrait;', str_replace("\n    ", "\n", 'LazyGhostTrait {
-            initializeLazyObject as __load;
+            initializeLazyObject as private;
             setLazyObjectAsInitialized as public __setInitialized;
             isLazyObjectInitialized as private;
             createLazyGhost as private;
             resetLazyObject as private;
-        }'), $code);
+        }
+
+        public function __load(): void
+        {
+            $this->initializeLazyObject();
+        }
+        '), $code);
 
         return $code;
     }

src/Query/Parser.php

@@ -2563,7 +2563,10 @@ final class Parser
             return new AST\ParenthesisExpression($expr);
         }
 
-        assert($this->lexer->lookahead !== null);
+        if ($this->lexer->lookahead === null) {
+            $this->syntaxError('ArithmeticPrimary');
+        }
+
         switch ($this->lexer->lookahead->type) {
             case TokenType::T_COALESCE:
             case TokenType::T_NULLIF:

src/Query/SqlWalker.php

@@ -911,7 +911,9 @@ class SqlWalker
             }
         }
 
-        if ($relation->fetch === ClassMetadata::FETCH_EAGER && $condExpr !== null) {
+        $fetchMode = $this->query->getHint('fetchMode')[$assoc->sourceEntity][$assoc->fieldName] ?? $relation->fetch;
+
+        if ($fetchMode === ClassMetadata::FETCH_EAGER && $condExpr !== null) {
             throw QueryException::eagerFetchJoinWithNotAllowed($assoc->sourceEntity, $assoc->fieldName);
         }
 

src/Tools/Console/Command/SchemaTool/UpdateCommand.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Tools\Console\Command\SchemaTool;
 
+use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\Tools\SchemaTool;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
@@ -28,7 +29,7 @@ class UpdateCommand extends AbstractCommand
         $this->setName($this->name)
              ->setDescription('Executes (or dumps) the SQL needed to update the database schema to match the current mapping metadata')
              ->addOption('em', null, InputOption::VALUE_REQUIRED, 'Name of the entity manager to operate on')
-             ->addOption('complete', null, InputOption::VALUE_NONE, 'This option is a no-op and will be removed in 4.0')
+             ->addOption('complete', null, InputOption::VALUE_NONE, 'This option is a no-op, is deprecated and will be removed in 4.0')
              ->addOption('dump-sql', null, InputOption::VALUE_NONE, 'Dumps the generated SQL statements to the screen (does not execute them).')
              ->addOption('force', 'f', InputOption::VALUE_NONE, 'Causes the generated SQL statements to be physically executed against your database.')
              ->setHelp(<<<'EOT'
@@ -75,6 +76,15 @@ EOT);
     {
         $notificationUi = $ui->getErrorStyle();
 
+        if ($input->getOption('complete') === true) {
+            Deprecation::trigger(
+                'doctrine/orm',
+                'https://github.com/doctrine/orm/pull/11354',
+                'The --complete option is a no-op, is deprecated and will be removed in Doctrine ORM 4.0.',
+            );
+            $notificationUi->warning('The --complete option is a no-op, is deprecated and will be removed in Doctrine ORM 4.0.');
+        }
+
         $sqls = $schemaTool->getUpdateSchemaSql($metadatas);
 
         if (empty($sqls)) {

src/UnitOfWork.php

@@ -2467,10 +2467,7 @@ class UnitOfWork implements PropertyChangedListener
                             } else {
                                 $associatedId[$targetClass->fieldNames[$targetColumn]] = $joinColumnValue;
                             }
-                        } elseif (
-                            $targetClass->containsForeignIdentifier
-                            && in_array($targetClass->getFieldForColumn($targetColumn), $targetClass->identifier, true)
-                        ) {
+                        } elseif (in_array($targetClass->getFieldForColumn($targetColumn), $targetClass->identifier, true)) {
                             // the missing key is part of target's entity primary key
                             $associatedId = [];
                             break;

tests/Tests/Models/CompositeKeyRelations/CustomerClass.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\CompositeKeyRelations;
+
+use Doctrine\ORM\Mapping\Column;
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\Id;
+
+#[Entity]
+class CustomerClass
+{
+    #[Id]
+    #[Column(type: 'string')]
+    public string $companyCode;
+
+    #[Id]
+    #[Column(type: 'string')]
+    public string $code;
+
+    #[Column(type: 'string')]
+    public string $name;
+}

tests/Tests/Models/CompositeKeyRelations/InvoiceClass.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\CompositeKeyRelations;
+
+use Doctrine\ORM\Mapping\Column;
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\Id;
+use Doctrine\ORM\Mapping\JoinColumn;
+use Doctrine\ORM\Mapping\ManyToOne;
+
+#[Entity]
+class InvoiceClass
+{
+    #[Id]
+    #[Column(type: 'string')]
+    public string $companyCode;
+
+    #[Id]
+    #[Column(type: 'string')]
+    public string $invoiceNumber;
+
+    #[ManyToOne(targetEntity: CustomerClass::class)]
+    #[JoinColumn(name: 'companyCode', referencedColumnName: 'companyCode')]
+    #[JoinColumn(name: 'customerCode', referencedColumnName: 'code')]
+    public CustomerClass|null $customer;
+
+    #[Column(type: 'string', nullable: true)]
+    public string|null $customerCode = null;
+}

tests/Tests/Models/ECommerce/ECommerceProduct2.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\ECommerce;
+
+use Doctrine\ORM\Mapping\Column;
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\GeneratedValue;
+use Doctrine\ORM\Mapping\Id;
+use Doctrine\ORM\Mapping\Index;
+use Doctrine\ORM\Mapping\Table;
+
+/**
+ * ECommerceProduct2
+ * Resets the id when being cloned.
+ */
+#[Entity]
+#[Table(name: 'ecommerce_products')]
+#[Index(name: 'name_idx', columns: ['name'])]
+class ECommerceProduct2
+{
+    #[Column]
+    #[Id]
+    #[GeneratedValue]
+    private int|null $id = null;
+
+    #[Column(length: 50, nullable: true)]
+    private string|null $name = null;
+
+    public function getId(): int|null
+    {
+        return $this->id;
+    }
+
+    public function getName(): string|null
+    {
+        return $this->name;
+    }
+
+    public function __clone()
+    {
+        $this->id   = null;
+        $this->name = 'Clone of ' . $this->name;
+    }
+}

tests/Tests/ORM/EntityManagerTest.php

@@ -7,6 +7,7 @@ namespace Doctrine\Tests\ORM;
 use Doctrine\Common\EventManager;
 use Doctrine\DBAL\Connection;
 use Doctrine\ORM\Configuration;
+use Doctrine\ORM\EntityManager;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Exception\EntityManagerClosed;
 use Doctrine\ORM\Mapping\ClassMetadataFactory;
@@ -21,7 +22,9 @@ use Doctrine\Tests\OrmTestCase;
 use Generator;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\Attributes\Group;
+use ReflectionProperty;
 use stdClass;
+use Symfony\Component\VarExporter\LazyGhostTrait;
 use TypeError;
 
 class EntityManagerTest extends OrmTestCase
@@ -172,4 +175,36 @@ class EntityManagerTest extends OrmTestCase
             self::assertFalse($this->entityManager->isOpen());
         }
     }
+
+    /** Resetting the EntityManager relies on lazy objects until https://github.com/doctrine/orm/issues/5933 is resolved */
+    public function testLazyGhostEntityManager(): void
+    {
+        $em = new class () extends EntityManager {
+            use LazyGhostTrait;
+
+            public function __construct()
+            {
+            }
+        };
+
+        $em = $em::createLazyGhost(static function ($em): void {
+            $r = new ReflectionProperty(EntityManager::class, 'unitOfWork');
+            $r->setValue($em, new class () extends UnitOfWork {
+                public function __construct()
+                {
+                }
+
+                public function clear(): void
+                {
+                }
+            });
+        });
+
+        $this->assertTrue($em->isOpen());
+        $em->close();
+        $this->assertFalse($em->isOpen());
+
+        $em->resetLazyObject();
+        $this->assertTrue($em->isOpen());
+    }
 }

tests/Tests/ORM/Functional/CompositeKeyRelationsTest.php

@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\ORM\Functional;
+
+use Doctrine\Tests\Models\CompositeKeyRelations\CustomerClass;
+use Doctrine\Tests\Models\CompositeKeyRelations\InvoiceClass;
+use Doctrine\Tests\OrmFunctionalTestCase;
+
+class CompositeKeyRelationsTest extends OrmFunctionalTestCase
+{
+    protected function setUp(): void
+    {
+        $this->useModelSet('compositekeyrelations');
+
+        parent::setUp();
+    }
+
+    public function testFindEntityWithNotNullRelation(): void
+    {
+        $this->_em->getConnection()->insert('CustomerClass', [
+            'companyCode' => 'AA',
+            'code' => 'CUST1',
+            'name' => 'Customer 1',
+        ]);
+
+        $this->_em->getConnection()->insert('InvoiceClass', [
+            'companyCode' => 'AA',
+            'invoiceNumber' => 'INV1',
+            'customerCode' => 'CUST1',
+        ]);
+
+        $entity = $this->findEntity('AA', 'INV1');
+        self::assertSame('AA', $entity->companyCode);
+        self::assertSame('INV1', $entity->invoiceNumber);
+        self::assertInstanceOf(CustomerClass::class, $entity->customer);
+        self::assertSame('Customer 1', $entity->customer->name);
+    }
+
+    public function testFindEntityWithNullRelation(): void
+    {
+        $this->_em->getConnection()->insert('InvoiceClass', [
+            'companyCode' => 'BB',
+            'invoiceNumber' => 'INV1',
+        ]);
+
+        $entity = $this->findEntity('BB', 'INV1');
+        self::assertSame('BB', $entity->companyCode);
+        self::assertSame('INV1', $entity->invoiceNumber);
+        self::assertNull($entity->customer);
+    }
+
+    private function findEntity(string $companyCode, string $invoiceNumber): InvoiceClass
+    {
+        return $this->_em->find(
+            InvoiceClass::class,
+            ['companyCode' => $companyCode, 'invoiceNumber' => $invoiceNumber],
+        );
+    }
+}

tests/Tests/ORM/Functional/EagerFetchCollectionTest.php

@@ -89,6 +89,14 @@ class EagerFetchCollectionTest extends OrmFunctionalTestCase
         $query->getResult();
     }
 
+    public function testSubselectFetchJoinWithAllowedWhenOverriddenNotEager(): void
+    {
+        $query = $this->_em->createQuery('SELECT o, c FROM ' . EagerFetchOwner::class . ' o JOIN o.children c WITH c.id = 1');
+        $query->setFetchMode(EagerFetchChild::class, 'owner', ORM\ClassMetadata::FETCH_LAZY);
+
+        $this->assertIsString($query->getSql());
+    }
+
     public function testEagerFetchWithIterable(): void
     {
         $this->createOwnerWithChildren(2);

tests/Tests/ORM/Functional/ProxiesLikeEntitiesTest.php

@@ -58,7 +58,7 @@ class ProxiesLikeEntitiesTest extends OrmFunctionalTestCase
     public function testPersistUpdate(): void
     {
         // Considering case (a)
-        $proxy = $this->_em->getProxyFactory()->getProxy(CmsUser::class, ['id' => 123]);
+        $proxy = $this->_em->getProxyFactory()->getProxy(CmsUser::class, ['id' => $this->user->getId()]);
 
         $proxy->id       = null;
         $proxy->username = 'ocra';

tests/Tests/ORM/Functional/ReferenceProxyTest.php

@@ -9,6 +9,7 @@ use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
 use Doctrine\ORM\Proxy\InternalProxy;
 use Doctrine\Tests\Models\Company\CompanyAuction;
 use Doctrine\Tests\Models\ECommerce\ECommerceProduct;
+use Doctrine\Tests\Models\ECommerce\ECommerceProduct2;
 use Doctrine\Tests\Models\ECommerce\ECommerceShipping;
 use Doctrine\Tests\OrmFunctionalTestCase;
 use PHPUnit\Framework\Attributes\Group;
@@ -112,6 +113,24 @@ class ReferenceProxyTest extends OrmFunctionalTestCase
         self::assertFalse($entity->isCloned);
     }
 
+    public function testCloneProxyWithResetId(): void
+    {
+        $id = $this->createProduct();
+
+        $entity = $this->_em->getReference(ECommerceProduct2::class, $id);
+        assert($entity instanceof ECommerceProduct2);
+
+        $clone = clone $entity;
+        assert($clone instanceof ECommerceProduct2);
+
+        self::assertEquals($id, $entity->getId());
+        self::assertEquals('Doctrine Cookbook', $entity->getName());
+
+        self::assertFalse($this->_em->contains($clone));
+        self::assertNull($clone->getId());
+        self::assertEquals('Clone of Doctrine Cookbook', $clone->getName());
+    }
+
     #[Group('DDC-733')]
     public function testInitializeProxy(): void
     {

tests/Tests/ORM/Functional/Ticket/GH10889Test.php

@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\ORM\Functional\Ticket;
+
+use Doctrine\ORM\Mapping as ORM;
+use Doctrine\Tests\OrmFunctionalTestCase;
+use PHPUnit\Framework\Attributes\Group;
+
+/** @see https://github.com/doctrine/orm/issues/10889 */
+#[Group('GH10889')]
+class GH10889Test extends OrmFunctionalTestCase
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->createSchemaForModels(
+            GH10889Person::class,
+            GH10889Company::class,
+            GH10889Resume::class,
+        );
+    }
+
+    public function testIssue(): void
+    {
+        $person = new GH10889Person();
+        $resume = new GH10889Resume($person, null);
+
+        $this->_em->persist($person);
+        $this->_em->persist($resume);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        /** @var list<GH10889Resume> $resumes */
+        $resumes = $this->_em
+            ->getRepository(GH10889Resume::class)
+            ->createQueryBuilder('resume')
+            ->leftJoin('resume.currentCompany', 'company')->addSelect('company')
+            ->getQuery()
+            ->getResult();
+
+        $this->assertArrayHasKey(0, $resumes);
+        $this->assertEquals(1, $resumes[0]->person->id);
+        $this->assertNull($resumes[0]->currentCompany);
+    }
+}
+
+#[ORM\Entity]
+class GH10889Person
+{
+    #[ORM\Id]
+    #[ORM\Column]
+    #[ORM\GeneratedValue]
+    public int|null $id = null;
+}
+
+#[ORM\Entity]
+class GH10889Company
+{
+    #[ORM\Id]
+    #[ORM\Column]
+    #[ORM\GeneratedValue]
+    public int|null $id = null;
+}
+
+#[ORM\Entity]
+class GH10889Resume
+{
+    public function __construct(
+        #[ORM\Id]
+        #[ORM\OneToOne]
+        public GH10889Person $person,
+        #[ORM\ManyToOne]
+        public GH10889Company|null $currentCompany,
+    ) {
+    }
+}

tests/Tests/ORM/Functional/Ticket/GH11487Test.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\ORM\Functional\Ticket;
+
+use Doctrine\ORM\Mapping\Column;
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\GeneratedValue;
+use Doctrine\ORM\Mapping\Id;
+use Doctrine\ORM\Query\QueryException;
+use Doctrine\Tests\OrmFunctionalTestCase;
+
+class GH11487Test extends OrmFunctionalTestCase
+{
+    public function testItThrowsASyntaxErrorOnUnfinishedQuery(): void
+    {
+        $this->expectException(QueryException::class);
+        $this->expectExceptionMessage('Syntax Error');
+        $this->_em->createQuery('UPDATE Doctrine\Tests\ORM\Functional\Ticket\TaxType t SET t.default =')->execute();
+    }
+}
+
+#[Entity]
+class TaxType
+{
+    #[Column]
+    #[Id]
+    #[GeneratedValue]
+    public int|null $id = null;
+
+    #[Column]
+    public bool $default = false;
+}

tests/Tests/ORM/Functional/Ticket/GH11500Test.php

@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\ORM\Functional\Ticket;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Exception\ORMException;
+use Doctrine\ORM\Mapping as ORM;
+use Doctrine\Tests\OrmFunctionalTestCase;
+
+class GH11500Test extends OrmFunctionalTestCase
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->setUpEntitySchema([
+            GH11500AbstractTestEntity::class,
+            GH11500TestEntityOne::class,
+            GH11500TestEntityTwo::class,
+            GH11500TestEntityHolder::class,
+        ]);
+    }
+
+    /** @throws ORMException */
+    public function testDeleteOneToManyCollectionWithSingleTableInheritance(): void
+    {
+        $testEntityOne    = new GH11500TestEntityOne();
+        $testEntityTwo    = new GH11500TestEntityTwo();
+        $testEntityHolder = new GH11500TestEntityHolder();
+
+        $testEntityOne->testEntityHolder = $testEntityHolder;
+        $testEntityHolder->testEntityOnes->add($testEntityOne);
+
+        $testEntityTwo->testEntityHolder = $testEntityHolder;
+        $testEntityHolder->testEntityTwos->add($testEntityTwo);
+
+        $em = $this->getEntityManager();
+        $em->persist($testEntityOne);
+        $em->persist($testEntityTwo);
+        $em->persist($testEntityHolder);
+        $em->flush();
+
+        $testEntityTwosBeforeRemovalOfTestEntityOnes = $testEntityHolder->testEntityTwos->toArray();
+
+        $testEntityHolder->testEntityOnes = new ArrayCollection();
+        $em->persist($testEntityHolder);
+        $em->flush();
+        $em->refresh($testEntityHolder);
+
+        static::assertEmpty($testEntityHolder->testEntityOnes->toArray(), 'All records should have been deleted');
+        static::assertEquals($testEntityTwosBeforeRemovalOfTestEntityOnes, $testEntityHolder->testEntityTwos->toArray(), 'Different Entity\'s records should not have been deleted');
+    }
+}
+
+
+
+#[ORM\Entity]
+#[ORM\Table(name: 'one_to_many_single_table_inheritance_test_entities')]
+#[ORM\InheritanceType('SINGLE_TABLE')]
+#[ORM\DiscriminatorColumn(name: 'type', type: 'string')]
+#[ORM\DiscriminatorMap(['test_entity_one' => 'GH11500TestEntityOne', 'test_entity_two' => 'GH11500TestEntityTwo'])]
+class GH11500AbstractTestEntity
+{
+    #[ORM\Id]
+    #[ORM\Column]
+    #[ORM\GeneratedValue]
+    public int|null $id = null;
+}
+
+
+#[ORM\Entity]
+class GH11500TestEntityOne extends GH11500AbstractTestEntity
+{
+    #[ORM\ManyToOne(inversedBy:'testEntityOnes')]
+    #[ORM\JoinColumn(name:'test_entity_holder_id', referencedColumnName:'id')]
+    public GH11500TestEntityHolder|null $testEntityHolder = null;
+}
+
+#[ORM\Entity]
+class GH11500TestEntityTwo extends GH11500AbstractTestEntity
+{
+    #[ORM\ManyToOne(inversedBy:'testEntityTwos')]
+    #[ORM\JoinColumn(name:'test_entity_holder_id', referencedColumnName:'id')]
+    public GH11500TestEntityHolder|null $testEntityHolder = null;
+}
+
+#[ORM\Entity]
+class GH11500TestEntityHolder
+{
+    #[ORM\Id]
+    #[ORM\Column]
+    #[ORM\GeneratedValue]
+    public int|null $id = null;
+
+    #[ORM\OneToMany(targetEntity: 'GH11500TestEntityOne', mappedBy: 'testEntityHolder', orphanRemoval: true)]
+    public Collection $testEntityOnes;
+
+    #[ORM\OneToMany(targetEntity: 'GH11500TestEntityTwo', mappedBy: 'testEntityHolder', orphanRemoval: true)]
+    public Collection $testEntityTwos;
+
+    public function __construct()
+    {
+        $this->testEntityOnes = new ArrayCollection();
+        $this->testEntityTwos = new ArrayCollection();
+    }
+}

tests/Tests/ORM/Mapping/TableMappingTest.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\ORM\Mapping;
+
+use Doctrine\Deprecations\PHPUnit\VerifyDeprecations;
+use Doctrine\ORM\Mapping\Table;
+use PHPUnit\Framework\TestCase;
+
+final class TableMappingTest extends TestCase
+{
+    use VerifyDeprecations;
+
+    public function testDeprecationOnIndexesPropertyIsTriggered(): void
+    {
+        $this->expectDeprecationWithIdentifier('https://github.com/doctrine/orm/pull/11357');
+
+        new Table(indexes: []);
+    }
+
+    public function testDeprecationOnUniqueConstraintsPropertyIsTriggered(): void
+    {
+        $this->expectDeprecationWithIdentifier('https://github.com/doctrine/orm/pull/11357');
+
+        new Table(uniqueConstraints: []);
+    }
+}

tests/Tests/OrmFunctionalTestCase.php

@@ -349,6 +349,10 @@ abstract class OrmFunctionalTestCase extends OrmTestCase
             SingleRootClass::class,
             SingleChildClass::class,
         ],
+        'compositekeyrelations' => [
+            Models\CompositeKeyRelations\InvoiceClass::class,
+            Models\CompositeKeyRelations\CustomerClass::class,
+        ],
         'taxi' => [
             PaidRide::class,
             Ride::class,