Original entity data resolves inverse 1-1 joins

lib/Doctrine/ORM/Cache/Persister/Entity/AbstractEntityPersister.php

@@ -582,9 +582,9 @@ public function loadOneToManyCollection(array $assoc, $sourceEntity, PersistentC
     /**
      * {@inheritDoc}
      */
-    public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [])
+    public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [], array $sourceEntityData = [])
     {
-        return $this->persister->loadOneToOneEntity($assoc, $sourceEntity, $identifier);
+        return $this->persister->loadOneToOneEntity($assoc, $sourceEntity, $identifier, $sourceEntityData);
     }
 
     /**

lib/Doctrine/ORM/Persisters/Entity/BasicEntityPersister.php

@@ -792,7 +792,7 @@ public function loadById(array $identifier, $entity = null)
     /**
      * {@inheritDoc}
      */
-    public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [])
+    public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [], array $sourceEntityData = [])
     {
         $foundEntity = $this->em->getUnitOfWork()->tryGetById($identifier, $assoc['targetEntity']);
         if ($foundEntity !== false) {
@@ -830,14 +830,32 @@ public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifie
         // TRICKY: since the association is specular source and target are flipped
         foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
             if (! isset($sourceClass->fieldNames[$sourceKeyColumn])) {
-                throw MappingException::joinColumnMustPointToMappedField(
-                    $sourceClass->name,
-                    $sourceKeyColumn
-                );
-            }
+                // The likely case here is that the column is a join column
+                // in an association mapping. However, there is no guarantee
+                // at this point that a corresponding (generally identifying)
+                // association has been mapped in the source entity. To handle
+                // this case we directly reference the column-keyed data used
+                // to initialize the source entity before throwing an exception.
+                $resolvedSourceData = false;
+                if (isset($sourceEntityData[$sourceKeyColumn])) {
+                    $dataValue = $sourceEntityData[$sourceKeyColumn];
+                    if ($dataValue !== null) {
+                        $resolvedSourceData                                                    = true;
+                        $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
+                            $dataValue;
+                    }
+                }
 
-            $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
-                $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
+                if (! $resolvedSourceData) {
+                    throw MappingException::joinColumnMustPointToMappedField(
+                        $sourceClass->name,
+                        $sourceKeyColumn
+                    );
+                }
+            } else {
+                $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
+                    $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
+            }
         }
 
         $targetEntity = $this->load($computedIdentifier, null, $assoc);

lib/Doctrine/ORM/Persisters/Entity/EntityPersister.php

@@ -217,16 +217,21 @@ public function loadById(array $identifier, $entity = null);
      * association from another entity.
      *
      * @param object $sourceEntity The entity that owns the association (not necessarily the "owning side").
-     * @psalm-param array<string, mixed> $identifier The identifier of the entity to load. Must be provided if
-     *                                               the association to load represents the owning side, otherwise
-     *                                               the identifier is derived from the $sourceEntity.
-     * @psalm-param AssociationMapping $assoc        The association to load.
+     * @psalm-param array<string, mixed> $sourceEntityData The data used to create the sourceEntity. If the sourceEntity
+     *                                                     is identified by an association, then that association may
+     *                                                     not be initialize before this call. This original data is used
+     *                                                     as a backup to access originating state that has not yet been
+     *                                                     written to a newly initialized sourceEntity.
+     * @psalm-param array<string, mixed> $identifier       The identifier of the entity to load. Must be provided if
+     *                                                     the association to load represents the owning side, otherwise
+     *                                                     the identifier is derived from the $sourceEntity.
+     * @psalm-param AssociationMapping $assoc              The association to load.
      *
      * @return object The loaded and managed entity instance or NULL if the entity can not be found.
      *
      * @throws MappingException
      */
-    public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = []);
+    public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [], array $sourceEntityData = []);
 
     /**
      * Refreshes a managed entity.

lib/Doctrine/ORM/UnitOfWork.php

@@ -2963,7 +2963,7 @@ public function createEntity($className, array $data, &$hints = [])
                         }
 
                         // Inverse side of x-to-one can never be lazy
-                        $class->reflFields[$field]->setValue($entity, $this->getEntityPersister($assoc['targetEntity'])->loadOneToOneEntity($assoc, $entity));
+                        $class->reflFields[$field]->setValue($entity, $this->getEntityPersister($assoc['targetEntity'])->loadOneToOneEntity($assoc, $entity, [], $data));
 
                         continue 2;
                     }
@@ -3038,7 +3038,7 @@ public function createEntity($className, array $data, &$hints = [])
                             // If it might be a subtype, it can not be lazy. There isn't even
                             // a way to solve this with deferred eager loading, which means putting
                             // an entity with subclasses at a *-to-one location is really bad! (performance-wise)
-                            $newValue = $this->getEntityPersister($assoc['targetEntity'])->loadOneToOneEntity($assoc, $entity, $associatedId);
+                            $newValue = $this->getEntityPersister($assoc['targetEntity'])->loadOneToOneEntity($assoc, $entity, $associatedId, $data);
                             break;
 
                         default:

tests/Doctrine/Tests/Models/OneToOneInverseSideWithAssociativeIdLoad/InverseSide.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\OneToOneInverseSideWithAssociativeIdLoad;
+
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\Id;
+use Doctrine\ORM\Mapping\JoinColumn;
+use Doctrine\ORM\Mapping\OneToOne;
+use Doctrine\ORM\Mapping\Table;
+
+/**
+ * @Entity()
+ * @Table(name="one_to_one_inverse_side_assoc_id_load_inverse")
+ */
+class InverseSide
+{
+    /**
+     * Associative id (owning identifier)
+     *
+     * @var InverseSideIdTarget
+     * @Id()
+     * @OneToOne(targetEntity=InverseSideIdTarget::class, inversedBy="inverseSide")
+     * @JoinColumn(nullable=false, name="associativeId")
+     */
+    public $associativeId;
+
+    /**
+     * @var OwningSide
+     * @OneToOne(targetEntity=OwningSide::class, mappedBy="inverse")
+     */
+    public $owning;
+}

tests/Doctrine/Tests/Models/OneToOneInverseSideWithAssociativeIdLoad/InverseSideIdTarget.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\OneToOneInverseSideWithAssociativeIdLoad;
+
+use Doctrine\ORM\Mapping\Column;
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\GeneratedValue;
+use Doctrine\ORM\Mapping\Id;
+use Doctrine\ORM\Mapping\OneToOne;
+use Doctrine\ORM\Mapping\Table;
+
+/**
+ * @Entity()
+ * @Table(name="one_to_one_inverse_side_assoc_id_load_inverse_id_target")
+ */
+class InverseSideIdTarget
+{
+    /**
+     * @var string
+     * @Id()
+     * @Column(type="string", length=255)
+     * @GeneratedValue(strategy="NONE")
+     */
+    public $id;
+
+    /**
+     * @var InverseSide
+     * @OneToOne(targetEntity=InverseSide::class, mappedBy="associativeId")
+     */
+    public $inverseSide;
+}

tests/Doctrine/Tests/Models/OneToOneInverseSideWithAssociativeIdLoad/OwningSide.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\OneToOneInverseSideWithAssociativeIdLoad;
+
+use Doctrine\ORM\Mapping\Column;
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\GeneratedValue;
+use Doctrine\ORM\Mapping\Id;
+use Doctrine\ORM\Mapping\JoinColumn;
+use Doctrine\ORM\Mapping\OneToOne;
+use Doctrine\ORM\Mapping\Table;
+
+/**
+ * @Entity()
+ * @Table(name="one_to_one_inverse_side_assoc_id_load_owning")
+ */
+class OwningSide
+{
+    /**
+     * @var string
+     * @Id()
+     * @Column(type="string", length=255)
+     * @GeneratedValue(strategy="NONE")
+     */
+    public $id;
+
+    /**
+     * Owning side
+     *
+     * @var InverseSide
+     * @OneToOne(targetEntity=InverseSide::class, inversedBy="owning")
+     * @JoinColumn(name="inverse", referencedColumnName="associativeId")
+     */
+    public $inverse;
+}

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

@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\ORM\Functional;
+
+use Doctrine\Tests\Models\OneToOneInverseSideWithAssociativeIdLoad\InverseSide;
+use Doctrine\Tests\Models\OneToOneInverseSideWithAssociativeIdLoad\InverseSideIdTarget;
+use Doctrine\Tests\Models\OneToOneInverseSideWithAssociativeIdLoad\OwningSide;
+use Doctrine\Tests\OrmFunctionalTestCase;
+
+use function assert;
+
+class OneToOneInverseSideWithAssociativeIdLoadAfterDqlQueryTest extends OrmFunctionalTestCase
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->createSchemaForModels(OwningSide::class, InverseSideIdTarget::class, InverseSide::class);
+    }
+
+    /** @group GH-11108 */
+    public function testInverseSideWithAssociativeIdOneToOneLoadedAfterDqlQuery(): void
+    {
+        $owner     = new OwningSide();
+        $inverseId = new InverseSideIdTarget();
+        $inverse   = new InverseSide();
+
+        $owner->id              = 'owner';
+        $inverseId->id          = 'inverseId';
+        $inverseId->inverseSide = $inverse;
+        $inverse->associativeId = $inverseId;
+        $owner->inverse         = $inverse;
+        $inverse->owning        = $owner;
+
+        $this->_em->persist($owner);
+        $this->_em->persist($inverseId);
+        $this->_em->persist($inverse);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $fetchedInverse = $this
+            ->_em
+            ->createQueryBuilder()
+            ->select('inverse')
+            ->from(InverseSide::class, 'inverse')
+            ->andWhere('inverse.associativeId = :associativeId')
+            ->setParameter('associativeId', 'inverseId')
+            ->getQuery()
+            ->getSingleResult();
+        assert($fetchedInverse instanceof InverseSide);
+
+        self::assertInstanceOf(InverseSide::class, $fetchedInverse);
+        self::assertInstanceOf(InverseSideIdTarget::class, $fetchedInverse->associativeId);
+        self::assertInstanceOf(OwningSide::class, $fetchedInverse->owning);
+
+        $this->assertSQLEquals(
+            'select o0_.associativeid as associativeid_0 from one_to_one_inverse_side_assoc_id_load_inverse o0_ where o0_.associativeid = ?',
+            $this->getLastLoggedQuery(1)['sql']
+        );
+
+        $this->assertSQLEquals(
+            'select t0.id as id_1, t0.inverse as inverse_2 from one_to_one_inverse_side_assoc_id_load_owning t0 where t0.inverse = ?',
+            $this->getLastLoggedQuery()['sql']
+        );
+    }
+}