Merge pull request #11526 from GromNaN/patch-1

doc: Use modern array syntax in getting started

.github/workflows/continuous-integration.yml

@@ -190,7 +190,7 @@ jobs:
           - "default"
           - "3@dev"
         mariadb-version:
-          - "10.9"
+          - "11.4"
         extension:
           - "mysqli"
           - "pdo_mysql"
@@ -204,11 +204,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"

.github/workflows/phpbench.yml

@@ -47,15 +47,8 @@ jobs:
           coverage: "pcov"
           ini-values: "zend.assertions=1, apc.enable_cli=1"
 
-      - name: "Cache dependencies installed with composer"
-        uses: "actions/cache@v3"
-        with:
-          path: "~/.composer/cache"
-          key: "php-${{ matrix.php-version }}-composer-locked-${{ hashFiles('composer.lock') }}"
-          restore-keys: "php-${{ matrix.php-version }}-composer-locked-"
-
-      - name: "Install dependencies with composer"
-        run: "composer update --no-interaction --no-progress"
+      - name: "Install dependencies with Composer"
+        uses: "ramsey/composer-install@v3"
 
       - name: "Run PHPBench"
         run: "vendor/bin/phpbench run --report=default"

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

@@ -188,7 +188,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);
             }

docs/en/tutorials/getting-started.rst

@@ -144,7 +144,7 @@ step:
 
     // Create a simple "default" Doctrine ORM configuration for Attributes
     $config = ORMSetup::createAttributeMetadataConfiguration(
-        paths: array(__DIR__."/src"),
+        paths: [__DIR__ . '/src'],
         isDevMode: true,
     );
     // or if you prefer annotation, YAML or XML
@@ -153,7 +153,7 @@ step:
     //    isDevMode: true,
     // );
     // $config = ORMSetup::createXMLMetadataConfiguration(
-    //    paths: array(__DIR__."/config/xml"),
+    //    paths: [__DIR__ . '/config/xml'],
     //    isDevMode: true,
     //);
     // $config = ORMSetup::createYAMLMetadataConfiguration(

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>
 

phpstan-dbal2.neon

@@ -74,3 +74,9 @@ parameters:
         -
             message: '#^Call to method injectObjectManager\(\) on an unknown class Doctrine\\Persistence\\ObjectManagerAware\.$#'
             path: src/UnitOfWork.php
+
+        -
+            message: '#contains generic type.*but class.*is not generic#'
+            paths:
+                - src/Mapping/Driver/XmlDriver.php
+                - src/Mapping/Driver/YamlDriver.php

phpstan-persistence2.neon

@@ -64,3 +64,9 @@ parameters:
 
         # Symfony cache supports passing a key prefix to the clear method.
         - '/^Method Psr\\Cache\\CacheItemPoolInterface\:\:clear\(\) invoked with 1 parameter, 0 required\.$/'
+
+        -
+            message: '#contains generic type.*but class.*is not generic#'
+            paths:
+                - src/Mapping/Driver/XmlDriver.php
+                - src/Mapping/Driver/YamlDriver.php

psalm-baseline.xml

@@ -932,13 +932,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,
@@ -962,7 +957,6 @@
       *                   options?: array
       *               }]]></code>
       <code><![CDATA[array{usage: int|null, region?: string}]]></code>
-      <code><![CDATA[loadMappingFile]]></code>
     </InvalidReturnType>
     <MissingParamType>
       <code><![CDATA[$fileExtension]]></code>
@@ -971,15 +965,6 @@
     <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/Driver/YamlDriver.php">
     <ArgumentTypeCoercion>
@@ -1011,38 +996,6 @@
     <MoreSpecificReturnType>
       <code><![CDATA[array{usage: int|null, region: string|null}]]></code>
     </MoreSpecificReturnType>
-    <PossiblyUndefinedMethod>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-    </PossiblyUndefinedMethod>
-    <UndefinedInterfaceMethod>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-      <code><![CDATA[$element]]></code>
-    </UndefinedInterfaceMethod>
   </file>
   <file src="src/Mapping/Embedded.php">
     <MissingParamType>
@@ -1494,7 +1447,9 @@
       <code><![CDATA[__wakeup]]></code>
     </UndefinedInterfaceMethod>
     <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/Internal/Hydration/ObjectHydrator.php

@@ -367,11 +367,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

@@ -37,6 +37,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
 {
@@ -79,7 +81,6 @@ class XmlDriver extends FileDriver
     public function loadMetadataForClass($className, PersistenceClassMetadata $metadata)
     {
         $xmlRoot = $this->getElement($className);
-        assert($xmlRoot instanceof SimpleXMLElement);
 
         if ($xmlRoot->getName() === 'entity') {
             if (isset($xmlRoot['repository-class'])) {
@@ -203,6 +204,7 @@ class XmlDriver extends FileDriver
                     ];
 
                     if (isset($discrColumn['options'])) {
+                        assert($discrColumn['options'] instanceof SimpleXMLElement);
                         $columnDef['options'] = $this->parseOptions($discrColumn['options']->children());
                     }
 
@@ -214,6 +216,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/Driver/YamlDriver.php

@@ -31,6 +31,8 @@ use function substr;
  * The YamlDriver reads the mapping metadata from yaml schema files.
  *
  * @deprecated 2.7 This class is being removed from the ORM and won't have any replacement
+ *
+ * @template-extends FileDriver<array<string, mixed>>
  */
 class YamlDriver extends FileDriver
 {

src/Mapping/InverseJoinColumn.php

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

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\PersistentCollection;
 use Doctrine\ORM\Utility\PersisterHelper;
 
@@ -166,7 +168,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     = $collection->getMapping();
@@ -186,6 +192,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

@@ -354,15 +354,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(
@@ -378,7 +377,7 @@ EOPHP;
             $class = $entityPersister->getClassMetadata();
 
             foreach ($class->getReflectionProperties() as $property) {
-                if (! $class->hasField($property->name) && ! $class->hasAssociation($property->name)) {
+                if (isset($identifier[$property->name]) || ! $class->hasField($property->name) && ! $class->hasAssociation($property->name)) {
                     continue;
                 }
 
@@ -468,7 +467,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])) {

src/Query/Parser.php

@@ -2924,7 +2924,10 @@ 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

@@ -1062,7 +1062,9 @@ class SqlWalker implements TreeWalker
             }
         }
 
-        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/UnitOfWork.php

@@ -3053,10 +3053,7 @@ EXCEPTION
                             } 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,33 @@
+<?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
+{
+    /**
+     * @var string
+     * @Id
+     * @Column(type="string")
+     */
+    public $companyCode;
+
+    /**
+     * @var string
+     * @Id
+     * @Column(type="string")
+     */
+    public $code;
+
+    /**
+     * @var string
+     * @Column(type="string")
+     */
+    public $name;
+}

tests/Tests/Models/CompositeKeyRelations/InvoiceClass.php

@@ -0,0 +1,46 @@
+<?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\JoinColumns;
+use Doctrine\ORM\Mapping\ManyToOne;
+
+/** @Entity */
+class InvoiceClass
+{
+    /**
+     * @var string
+     * @Id
+     * @Column(type="string")
+     */
+    public $companyCode;
+
+    /**
+     * @var string
+     * @Id
+     * @Column(type="string")
+     */
+    public $invoiceNumber;
+
+    /**
+     * @var CustomerClass|null
+     * @ManyToOne(targetEntity="CustomerClass")
+     * @JoinColumns({
+     *     @JoinColumn(name="companyCode", referencedColumnName="companyCode"),
+     *     @JoinColumn(name="customerCode", referencedColumnName="code")
+     * })
+     */
+    public $customer;
+
+    /**
+     * @var string|null
+     * @Column(type="string", nullable=true)
+     */
+    public $customerCode;
+}

tests/Tests/Models/ECommerce/ECommerceProduct2.php

@@ -0,0 +1,52 @@
+<?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",indexes={@Index(name="name_idx", columns={"name"})})
+ */
+class ECommerceProduct2
+{
+    /**
+     * @var int|null
+     * @Column(type="integer")
+     * @Id
+     * @GeneratedValue
+     */
+    private $id;
+
+    /**
+     * @var string
+     * @Column(type="string", length=50, nullable=true)
+     */
+    private $name;
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    public function getName(): string
+    {
+        return $this->name;
+    }
+
+    public function __clone()
+    {
+        $this->id   = null;
+        $this->name = 'Clone of ' . $this->name;
+    }
+}

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

@@ -88,6 +88,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;
 
@@ -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,107 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\ORM\Functional\Ticket;
+
+use Doctrine\ORM\Mapping as ORM;
+use Doctrine\Tests\OrmFunctionalTestCase;
+
+/**
+ * @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(type="integer")
+     * @ORM\GeneratedValue
+     *
+     * @var int
+     */
+    public $id;
+}
+
+/**
+ * @ORM\Entity
+ */
+class GH10889Company
+{
+    /**
+     * @ORM\Id
+     * @ORM\Column(type="integer")
+     * @ORM\GeneratedValue
+     *
+     * @var int
+     */
+    public $id;
+}
+
+/**
+ * @ORM\Entity
+ */
+class GH10889Resume
+{
+    /**
+     * @ORM\Id
+     * @ORM\OneToOne(targetEntity="GH10889Person")
+     *
+     * @var GH10889Person
+     */
+    public $person;
+
+    /**
+     * @ORM\ManyToOne(targetEntity="GH10889Company")
+     *
+     * @var GH10889Company|null
+     */
+    public $currentCompany;
+
+    public function __construct(GH10889Person $person, ?GH10889Company $currentCompany)
+    {
+        $this->person         = $person;
+        $this->currentCompany = $currentCompany;
+    }
+}

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

@@ -0,0 +1,40 @@
+<?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
+{
+    /**
+     * @var int|null
+     * @Column(type="integer")
+     * @Id
+     * @GeneratedValue
+     */
+    public $id;
+
+    /**
+     * @var bool
+     * @Column(type="boolean")
+     */
+    public $default = false;
+}

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

@@ -0,0 +1,137 @@
+<?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(type="integer")
+     * @ORM\GeneratedValue
+     *
+     * @var int
+     */
+    public $id;
+}
+
+
+/** @ORM\Entity */
+class GH11500TestEntityOne extends GH11500AbstractTestEntity
+{
+    /**
+     * @ORM\ManyToOne(targetEntity="GH11500TestEntityHolder", inversedBy="testEntityOnes")
+     * @ORM\JoinColumn(name="test_entity_holder_id", referencedColumnName="id")
+     *
+     * @var GH11500TestEntityHolder
+     */
+    public $testEntityHolder;
+}
+
+/** @ORM\Entity */
+class GH11500TestEntityTwo extends GH11500AbstractTestEntity
+{
+    /**
+     * @ORM\ManyToOne(targetEntity="GH11500TestEntityHolder", inversedBy="testEntityTwos")
+     * @ORM\JoinColumn(name="test_entity_holder_id", referencedColumnName="id")
+     *
+     * @var GH11500TestEntityHolder
+     */
+    public $testEntityHolder;
+}
+
+/** @ORM\Entity */
+class GH11500TestEntityHolder
+{
+    /**
+     * @ORM\Id
+     * @ORM\Column(type="integer")
+     * @ORM\GeneratedValue
+     *
+     * @var int
+     */
+    public $id;
+
+    /**
+     * @ORM\OneToMany(targetEntity="GH11500TestEntityOne", mappedBy="testEntityHolder", orphanRemoval=true)
+     *
+     * @var Collection
+     */
+    public $testEntityOnes;
+
+    /**
+     * @ORM\OneToMany(targetEntity="GH11500TestEntityTwo", mappedBy="testEntityHolder", orphanRemoval=true)
+     *
+     * @var Collection
+     */
+    public $testEntityTwos;
+
+    public function __construct()
+    {
+        $this->testEntityOnes = new ArrayCollection();
+        $this->testEntityTwos = new ArrayCollection();
+    }
+}

tests/Tests/OrmFunctionalTestCase.php

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