Merge branch '2.19.x' into 3.2.x

* 2.19.x:
  Fix OneToManyPersister::deleteEntityCollection missing discriminator column/value. (doctrineGH-11500)
  Skip joined entity creation for empty relation (doctrine#10889)
  ci: maintained and stable mariadb version (11.4 current lts) (doctrine#11490)
  fix(docs): use string value in `addAttribute`
  Replace assertion with exception (doctrine#11489)
  Use ramsey/composer-install in PHPBench workflow
  update EntityManager#transactional to EntityManager#wrapInTransaction
  Fix cloning entities
  Consider usage of setFetchMode when checking for simultaneous usage of fetch-mode EAGER and WITH condition.

.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"

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

@@ -88,29 +88,31 @@ 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:
 
 .. 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);
             }

psalm-baseline.xml

@@ -756,7 +756,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/Internal/Hydration/ObjectHydrator.php

@@ -356,11 +356,15 @@ protected function hydrateRowData(array $row, array &$result): void
                     $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/Persisters/Collection/OneToManyPersister.php

@@ -8,6 +8,8 @@
 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 @@ public function loadCriteria(PersistentCollection $collection, Criteria $criteri
         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 @@ private function deleteEntityCollection(PersistentCollection $collection): int
         $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 @@ protected function skipClass(ClassMetadata $metadata): bool
     /**
      * 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 @@ private function createLazyInitializer(ClassMetadata $classMetadata, EntityPersi
             $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 @@ private function getProxyFactory(string $className): Closure
         $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

@@ -2563,7 +2563,10 @@ public function ArithmeticPrimary(): AST\Node|string
             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 @@ public function walkJoinAssociationDeclaration(
             }
         }
 
-        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);
         }
 

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/Functional/EagerFetchCollectionTest.php

@@ -89,6 +89,14 @@ public function testSubselectFetchJoinWithNotAllowed(): void
         $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 @@ protected function setUp(): void
     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\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 @@ public function testCloneProxy(): void
         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,
+    ) {
+    }
+}