1. <?php
3. declare(strict_types=1);
5. namespace Doctrine\ORM;
7. use BackedEnum;
8. use DateTimeInterface;
9. use Doctrine\Common\Collections\ArrayCollection;
10. use Doctrine\Common\Collections\Collection;
11. use Doctrine\Common\EventManager;
12. use Doctrine\DBAL\Connections\PrimaryReadReplicaConnection;
13. use Doctrine\DBAL\LockMode;
14. use Doctrine\Deprecations\Deprecation;
15. use Doctrine\ORM\Cache\Persister\CachedPersister;
16. use Doctrine\ORM\Event\ListenersInvoker;
17. use Doctrine\ORM\Event\OnFlushEventArgs;
18. use Doctrine\ORM\Event\PostFlushEventArgs;
19. use Doctrine\ORM\Event\PostPersistEventArgs;
20. use Doctrine\ORM\Event\PostRemoveEventArgs;
21. use Doctrine\ORM\Event\PostUpdateEventArgs;
22. use Doctrine\ORM\Event\PreFlushEventArgs;
23. use Doctrine\ORM\Event\PrePersistEventArgs;
24. use Doctrine\ORM\Event\PreRemoveEventArgs;
25. use Doctrine\ORM\Event\PreUpdateEventArgs;
26. use Doctrine\ORM\Exception\ORMException;
27. use Doctrine\ORM\Exception\UnexpectedAssociationValue;
28. use Doctrine\ORM\Id\AssignedGenerator;
29. use Doctrine\ORM\Internal\CommitOrderCalculator;
30. use Doctrine\ORM\Internal\HydrationCompleteHandler;
31. use Doctrine\ORM\Mapping\ClassMetadata;
32. use Doctrine\ORM\Mapping\ClassMetadataInfo;
33. use Doctrine\ORM\Mapping\MappingException;
34. use Doctrine\ORM\Mapping\Reflection\ReflectionPropertiesGetter;
35. use Doctrine\ORM\Persisters\Collection\CollectionPersister;
36. use Doctrine\ORM\Persisters\Collection\ManyToManyPersister;
37. use Doctrine\ORM\Persisters\Collection\OneToManyPersister;
38. use Doctrine\ORM\Persisters\Entity\BasicEntityPersister;
39. use Doctrine\ORM\Persisters\Entity\EntityPersister;
40. use Doctrine\ORM\Persisters\Entity\JoinedSubclassPersister;
41. use Doctrine\ORM\Persisters\Entity\SingleTablePersister;
42. use Doctrine\ORM\Utility\IdentifierFlattener;
43. use Doctrine\Persistence\Mapping\RuntimeReflectionService;
44. use Doctrine\Persistence\NotifyPropertyChanged;
45. use Doctrine\Persistence\ObjectManagerAware;
46. use Doctrine\Persistence\PropertyChangedListener;
47. use Doctrine\Persistence\Proxy;
48. use Exception;
49. use InvalidArgumentException;
50. use RuntimeException;
51. use Throwable;
52. use UnexpectedValueException;
54. use function array_combine;
55. use function array_diff_key;
56. use function array_filter;
57. use function array_key_exists;
58. use function array_map;
59. use function array_merge;
60. use function array_pop;
61. use function array_sum;
62. use function array_values;
63. use function assert;
64. use function count;
65. use function current;
66. use function func_get_arg;
67. use function func_num_args;
68. use function get_class;
69. use function get_debug_type;
70. use function implode;
71. use function in_array;
72. use function is_array;
73. use function is_object;
74. use function method_exists;
75. use function reset;
76. use function spl_object_id;
77. use function sprintf;
79. /**
80.  * The UnitOfWork is responsible for tracking changes to objects during an
81.  * "object-level" transaction and for writing out changes to the database
82.  * in the correct order.
83.  *
84.  * Internal note: This class contains highly performance-sensitive code.
85.  *
86.  * @psalm-import-type AssociationMapping from ClassMetadataInfo
87.  */
88. class UnitOfWork implements PropertyChangedListener
89. {
90.     /**
91.      * An entity is in MANAGED state when its persistence is managed by an EntityManager.
92.      */
93.     public const STATE_MANAGED = 1;
95.     /**
96.      * An entity is new if it has just been instantiated (i.e. using the "new" operator)
97.      * and is not (yet) managed by an EntityManager.
98.      */
99.     public const STATE_NEW = 2;
101.     /**
102.      * A detached entity is an instance with persistent state and identity that is not
103.      * (or no longer) associated with an EntityManager (and a UnitOfWork).
104.      */
105.     public const STATE_DETACHED = 3;
107.     /**
108.      * A removed entity instance is an instance with a persistent identity,
109.      * associated with an EntityManager, whose persistent state will be deleted
110.      * on commit.
111.      */
112.     public const STATE_REMOVED = 4;
114.     /**
115.      * Hint used to collect all primary keys of associated entities during hydration
116.      * and execute it in a dedicated query afterwards
117.      *
118.      * @see https://www.doctrine-project.org/projects/doctrine-orm/en/stable/reference/dql-doctrine-query-language.html#temporarily-change-fetch-mode-in-dql
119.      */
120.     public const HINT_DEFEREAGERLOAD = 'deferEagerLoad';
122.     /**
123.      * The identity map that holds references to all managed entities that have
124.      * an identity. The entities are grouped by their class name.
125.      * Since all classes in a hierarchy must share the same identifier set,
126.      * we always take the root class name of the hierarchy.
127.      *
128.      * @var mixed[]
129.      * @psalm-var array<class-string, array<string, object|null>>
130.      */
131.     private $identityMap = [];
133.     /**
134.      * Map of all identifiers of managed entities.
135.      * Keys are object ids (spl_object_id).
136.      *
137.      * @var mixed[]
138.      * @psalm-var array<int, array<string, mixed>>
139.      */
140.     private $entityIdentifiers = [];
142.     /**
143.      * Map of the original entity data of managed entities.
144.      * Keys are object ids (spl_object_id). This is used for calculating changesets
145.      * at commit time.
146.      *
147.      * Internal note: Note that PHPs "copy-on-write" behavior helps a lot with memory usage.
148.      *                A value will only really be copied if the value in the entity is modified
149.      *                by the user.
150.      *
151.      * @psalm-var array<int, array<string, mixed>>
152.      */
153.     private $originalEntityData = [];
155.     /**
156.      * Map of entity changes. Keys are object ids (spl_object_id).
157.      * Filled at the beginning of a commit of the UnitOfWork and cleaned at the end.
158.      *
159.      * @psalm-var array<int, array<string, array{mixed, mixed}>>
160.      */
161.     private $entityChangeSets = [];
163.     /**
164.      * The (cached) states of any known entities.
165.      * Keys are object ids (spl_object_id).
166.      *
167.      * @psalm-var array<int, self::STATE_*>
168.      */
169.     private $entityStates = [];
171.     /**
172.      * Map of entities that are scheduled for dirty checking at commit time.
173.      * This is only used for entities with a change tracking policy of DEFERRED_EXPLICIT.
174.      * Keys are object ids (spl_object_id).
175.      *
176.      * @psalm-var array<class-string, array<int, mixed>>
177.      */
178.     private $scheduledForSynchronization = [];
180.     /**
181.      * A list of all pending entity insertions.
182.      *
183.      * @psalm-var array<int, object>
184.      */
185.     private $entityInsertions = [];
187.     /**
188.      * A list of all pending entity updates.
189.      *
190.      * @psalm-var array<int, object>
191.      */
192.     private $entityUpdates = [];
194.     /**
195.      * Any pending extra updates that have been scheduled by persisters.
196.      *
197.      * @psalm-var array<int, array{object, array<string, array{mixed, mixed}>}>
198.      */
199.     private $extraUpdates = [];
201.     /**
202.      * A list of all pending entity deletions.
203.      *
204.      * @psalm-var array<int, object>
205.      */
206.     private $entityDeletions = [];
208.     /**
209.      * New entities that were discovered through relationships that were not
210.      * marked as cascade-persist. During flush, this array is populated and
211.      * then pruned of any entities that were discovered through a valid
212.      * cascade-persist path. (Leftovers cause an error.)
213.      *
214.      * Keys are OIDs, payload is a two-item array describing the association
215.      * and the entity.
216.      *
217.      * @var object[][]|array[][] indexed by respective object spl_object_id()
218.      */
219.     private $nonCascadedNewDetectedEntities = [];
221.     /**
222.      * All pending collection deletions.
223.      *
224.      * @psalm-var array<int, PersistentCollection<array-key, object>>
225.      */
226.     private $collectionDeletions = [];
228.     /**
229.      * All pending collection updates.
230.      *
231.      * @psalm-var array<int, PersistentCollection<array-key, object>>
232.      */
233.     private $collectionUpdates = [];
235.     /**
236.      * List of collections visited during changeset calculation on a commit-phase of a UnitOfWork.
237.      * At the end of the UnitOfWork all these collections will make new snapshots
238.      * of their data.
239.      *
240.      * @psalm-var array<int, PersistentCollection<array-key, object>>
241.      */
242.     private $visitedCollections = [];
244.     /**
245.      * The EntityManager that "owns" this UnitOfWork instance.
246.      *
247.      * @var EntityManagerInterface
248.      */
249.     private $em;
251.     /**
252.      * The entity persister instances used to persist entity instances.
253.      *
254.      * @psalm-var array<string, EntityPersister>
255.      */
256.     private $persisters = [];
258.     /**
259.      * The collection persister instances used to persist collections.
260.      *
261.      * @psalm-var array<string, CollectionPersister>
262.      */
263.     private $collectionPersisters = [];
265.     /**
266.      * The EventManager used for dispatching events.
267.      *
268.      * @var EventManager
269.      */
270.     private $evm;
272.     /**
273.      * The ListenersInvoker used for dispatching events.
274.      *
275.      * @var ListenersInvoker
276.      */
277.     private $listenersInvoker;
279.     /**
280.      * The IdentifierFlattener used for manipulating identifiers
281.      *
282.      * @var IdentifierFlattener
283.      */
284.     private $identifierFlattener;
286.     /**
287.      * Orphaned entities that are scheduled for removal.
288.      *
289.      * @psalm-var array<int, object>
290.      */
291.     private $orphanRemovals = [];
293.     /**
294.      * Read-Only objects are never evaluated
295.      *
296.      * @var array<int, true>
297.      */
298.     private $readOnlyObjects = [];
300.     /**
301.      * Map of Entity Class-Names and corresponding IDs that should eager loaded when requested.
302.      *
303.      * @psalm-var array<class-string, array<string, mixed>>
304.      */
305.     private $eagerLoadingEntities = [];
307.     /** @var bool */
308.     protected $hasCache = false;
310.     /**
311.      * Helper for handling completion of hydration
312.      *
313.      * @var HydrationCompleteHandler
314.      */
315.     private $hydrationCompleteHandler;
317.     /** @var ReflectionPropertiesGetter */
318.     private $reflectionPropertiesGetter;
320.     /**
321.      * Initializes a new UnitOfWork instance, bound to the given EntityManager.
322.      */
323.     public function __construct(EntityManagerInterface $em)
324.     {
325.         $this->em                         = $em;
326.         $this->evm                        = $em->getEventManager();
327.         $this->listenersInvoker           = new ListenersInvoker($em);
328.         $this->hasCache                   = $em->getConfiguration()->isSecondLevelCacheEnabled();
329.         $this->identifierFlattener        = new IdentifierFlattener($this, $em->getMetadataFactory());
330.         $this->hydrationCompleteHandler   = new HydrationCompleteHandler($this->listenersInvoker, $em);
331.         $this->reflectionPropertiesGetter = new ReflectionPropertiesGetter(new RuntimeReflectionService());
332.     }
334.     /**
335.      * Commits the UnitOfWork, executing all operations that have been postponed
336.      * up to this point. The state of all managed entities will be synchronized with
337.      * the database.
338.      *
339.      * The operations are executed in the following order:
340.      *
341.      * 1) All entity insertions
342.      * 2) All entity updates
343.      * 3) All collection deletions
344.      * 4) All collection updates
345.      * 5) All entity deletions
346.      *
347.      * @param object|mixed[]|null $entity
348.      *
349.      * @return void
350.      *
351.      * @throws Exception
352.      */
353.     public function commit($entity = null)
354.     {
355.         if ($entity !== null) {
356.             Deprecation::triggerIfCalledFromOutside(
357.                 'doctrine/orm',
358.                 'https://github.com/doctrine/orm/issues/8459',
359.                 'Calling %s() with any arguments to commit specific entities is deprecated and will not be supported in Doctrine ORM 3.0.',
360.                 __METHOD__
361.             );
362.         }
364.         $connection = $this->em->getConnection();
366.         if ($connection instanceof PrimaryReadReplicaConnection) {
367.             $connection->ensureConnectedToPrimary();
368.         }
370.         // Raise preFlush
371.         if ($this->evm->hasListeners(Events::preFlush)) {
372.             $this->evm->dispatchEvent(Events::preFlush, new PreFlushEventArgs($this->em));
373.         }
375.         // Compute changes done since last commit.
376.         if ($entity === null) {
377.             $this->computeChangeSets();
378.         } elseif (is_object($entity)) {
379.             $this->computeSingleEntityChangeSet($entity);
380.         } elseif (is_array($entity)) {
381.             foreach ($entity as $object) {
382.                 $this->computeSingleEntityChangeSet($object);
383.             }
384.         }
386.         if (
387.             ! ($this->entityInsertions ||
388.                 $this->entityDeletions ||
389.                 $this->entityUpdates ||
390.                 $this->collectionUpdates ||
391.                 $this->collectionDeletions ||
392.                 $this->orphanRemovals)
393.         ) {
394.             $this->dispatchOnFlushEvent();
395.             $this->dispatchPostFlushEvent();
397.             $this->postCommitCleanup($entity);
399.             return; // Nothing to do.
400.         }
402.         $this->assertThatThereAreNoUnintentionallyNonPersistedAssociations();
404.         if ($this->orphanRemovals) {
405.             foreach ($this->orphanRemovals as $orphan) {
406.                 $this->remove($orphan);
407.             }
408.         }
410.         $this->dispatchOnFlushEvent();
412.         // Now we need a commit order to maintain referential integrity
413.         $commitOrder = $this->getCommitOrder();
415.         $conn = $this->em->getConnection();
416.         $conn->beginTransaction();
418.         try {
419.             // Collection deletions (deletions of complete collections)
420.             foreach ($this->collectionDeletions as $collectionToDelete) {
421.                 // Deferred explicit tracked collections can be removed only when owning relation was persisted
422.                 $owner = $collectionToDelete->getOwner();
424.                 if ($this->em->getClassMetadata(get_class($owner))->isChangeTrackingDeferredImplicit() || $this->isScheduledForDirtyCheck($owner)) {
425.                     $this->getCollectionPersister($collectionToDelete->getMapping())->delete($collectionToDelete);
426.                 }
427.             }
429.             if ($this->entityInsertions) {
430.                 foreach ($commitOrder as $class) {
431.                     $this->executeInserts($class);
432.                 }
433.             }
435.             if ($this->entityUpdates) {
436.                 foreach ($commitOrder as $class) {
437.                     $this->executeUpdates($class);
438.                 }
439.             }
441.             // Extra updates that were requested by persisters.
442.             if ($this->extraUpdates) {
443.                 $this->executeExtraUpdates();
444.             }
446.             // Collection updates (deleteRows, updateRows, insertRows)
447.             foreach ($this->collectionUpdates as $collectionToUpdate) {
448.                 $this->getCollectionPersister($collectionToUpdate->getMapping())->update($collectionToUpdate);
449.             }
451.             // Entity deletions come last and need to be in reverse commit order
452.             if ($this->entityDeletions) {
453.                 for ($count = count($commitOrder), $i = $count - 1; $i >= 0 && $this->entityDeletions; --$i) {
454.                     $this->executeDeletions($commitOrder[$i]);
455.                 }
456.             }
458.             // Commit failed silently
459.             if ($conn->commit() === false) {
460.                 $object = is_object($entity) ? $entity : null;
462.                 throw new OptimisticLockException('Commit failed', $object);
463.             }
464.         } catch (Throwable $e) {
465.             $this->em->close();
467.             if ($conn->isTransactionActive()) {
468.                 $conn->rollBack();
469.             }
471.             $this->afterTransactionRolledBack();
473.             throw $e;
474.         }
476.         $this->afterTransactionComplete();
478.         // Take new snapshots from visited collections
479.         foreach ($this->visitedCollections as $coll) {
480.             $coll->takeSnapshot();
481.         }
483.         $this->dispatchPostFlushEvent();
485.         $this->postCommitCleanup($entity);
486.     }
488.     /** @param object|object[]|null $entity */
489.     private function postCommitCleanup($entity): void
490.     {
491.         $this->entityInsertions               =
492.         $this->entityUpdates                  =
493.         $this->entityDeletions                =
494.         $this->extraUpdates                   =
495.         $this->collectionUpdates              =
496.         $this->nonCascadedNewDetectedEntities =
497.         $this->collectionDeletions            =
498.         $this->visitedCollections             =
499.         $this->orphanRemovals                 = [];
501.         if ($entity === null) {
502.             $this->entityChangeSets = $this->scheduledForSynchronization = [];
504.             return;
505.         }
507.         $entities = is_object($entity)
508.             ? [$entity]
509.             : $entity;
511.         foreach ($entities as $object) {
512.             $oid = spl_object_id($object);
514.             $this->clearEntityChangeSet($oid);
516.             unset($this->scheduledForSynchronization[$this->em->getClassMetadata(get_class($object))->rootEntityName][$oid]);
517.         }
518.     }
520.     /**
521.      * Computes the changesets of all entities scheduled for insertion.
522.      */
523.     private function computeScheduleInsertsChangeSets(): void
524.     {
525.         foreach ($this->entityInsertions as $entity) {
526.             $class = $this->em->getClassMetadata(get_class($entity));
528.             $this->computeChangeSet($class, $entity);
529.         }
530.     }
532.     /**
533.      * Only flushes the given entity according to a ruleset that keeps the UoW consistent.
534.      *
535.      * 1. All entities scheduled for insertion, (orphan) removals and changes in collections are processed as well!
536.      * 2. Read Only entities are skipped.
537.      * 3. Proxies are skipped.
538.      * 4. Only if entity is properly managed.
539.      *
540.      * @param object $entity
541.      *
542.      * @throws InvalidArgumentException
543.      */
544.     private function computeSingleEntityChangeSet($entity): void
545.     {
546.         $state = $this->getEntityState($entity);
548.         if ($state !== self::STATE_MANAGED && $state !== self::STATE_REMOVED) {
549.             throw new InvalidArgumentException('Entity has to be managed or scheduled for removal for single computation ' . self::objToStr($entity));
550.         }
552.         $class = $this->em->getClassMetadata(get_class($entity));
554.         if ($state === self::STATE_MANAGED && $class->isChangeTrackingDeferredImplicit()) {
555.             $this->persist($entity);
556.         }
558.         // Compute changes for INSERTed entities first. This must always happen even in this case.
559.         $this->computeScheduleInsertsChangeSets();
561.         if ($class->isReadOnly) {
562.             return;
563.         }
565.         // Ignore uninitialized proxy objects
566.         if ($entity instanceof Proxy && ! $entity->__isInitialized()) {
567.             return;
568.         }
570.         // Only MANAGED entities that are NOT SCHEDULED FOR INSERTION OR DELETION are processed here.
571.         $oid = spl_object_id($entity);
573.         if (! isset($this->entityInsertions[$oid]) && ! isset($this->entityDeletions[$oid]) && isset($this->entityStates[$oid])) {
574.             $this->computeChangeSet($class, $entity);
575.         }
576.     }
578.     /**
579.      * Executes any extra updates that have been scheduled.
580.      */
581.     private function executeExtraUpdates(): void
582.     {
583.         foreach ($this->extraUpdates as $oid => $update) {
584.             [$entity, $changeset] = $update;
586.             $this->entityChangeSets[$oid] = $changeset;
587.             $this->getEntityPersister(get_class($entity))->update($entity);
588.         }
590.         $this->extraUpdates = [];
591.     }
593.     /**
594.      * Gets the changeset for an entity.
595.      *
596.      * @param object $entity
597.      *
598.      * @return mixed[][]
599.      * @psalm-return array<string, array{mixed, mixed}|PersistentCollection>
600.      */
601.     public function & getEntityChangeSet($entity)
602.     {
603.         $oid  = spl_object_id($entity);
604.         $data = [];
606.         if (! isset($this->entityChangeSets[$oid])) {
607.             return $data;
608.         }
610.         return $this->entityChangeSets[$oid];
611.     }
613.     /**
614.      * Computes the changes that happened to a single entity.
615.      *
616.      * Modifies/populates the following properties:
617.      *
618.      * {@link _originalEntityData}
619.      * If the entity is NEW or MANAGED but not yet fully persisted (only has an id)
620.      * then it was not fetched from the database and therefore we have no original
621.      * entity data yet. All of the current entity data is stored as the original entity data.
622.      *
623.      * {@link _entityChangeSets}
624.      * The changes detected on all properties of the entity are stored there.
625.      * A change is a tuple array where the first entry is the old value and the second
626.      * entry is the new value of the property. Changesets are used by persisters
627.      * to INSERT/UPDATE the persistent entity state.
628.      *
629.      * {@link _entityUpdates}
630.      * If the entity is already fully MANAGED (has been fetched from the database before)
631.      * and any changes to its properties are detected, then a reference to the entity is stored
632.      * there to mark it for an update.
633.      *
634.      * {@link _collectionDeletions}
635.      * If a PersistentCollection has been de-referenced in a fully MANAGED entity,
636.      * then this collection is marked for deletion.
637.      *
638.      * @param ClassMetadata $class  The class descriptor of the entity.
639.      * @param object        $entity The entity for which to compute the changes.
640.      * @psalm-param ClassMetadata<T> $class
641.      * @psalm-param T $entity
642.      *
643.      * @return void
644.      *
645.      * @template T of object
646.      *
647.      * @ignore
648.      */
649.     public function computeChangeSet(ClassMetadata $class, $entity)
650.     {
651.         $oid = spl_object_id($entity);
653.         if (isset($this->readOnlyObjects[$oid])) {
654.             return;
655.         }
657.         if (! $class->isInheritanceTypeNone()) {
658.             $class = $this->em->getClassMetadata(get_class($entity));
659.         }
661.         $invoke = $this->listenersInvoker->getSubscribedSystems($class, Events::preFlush) & ~ListenersInvoker::INVOKE_MANAGER;
663.         if ($invoke !== ListenersInvoker::INVOKE_NONE) {
664.             $this->listenersInvoker->invoke($class, Events::preFlush, $entity, new PreFlushEventArgs($this->em), $invoke);
665.         }
667.         $actualData = [];
669.         foreach ($class->reflFields as $name => $refProp) {
670.             $value = $refProp->getValue($entity);
672.             if ($class->isCollectionValuedAssociation($name) && $value !== null) {
673.                 if ($value instanceof PersistentCollection) {
674.                     if ($value->getOwner() === $entity) {
675.                         continue;
676.                     }
678.                     $value = new ArrayCollection($value->getValues());
679.                 }
681.                 // If $value is not a Collection then use an ArrayCollection.
682.                 if (! $value instanceof Collection) {
683.                     $value = new ArrayCollection($value);
684.                 }
686.                 $assoc = $class->associationMappings[$name];
688.                 // Inject PersistentCollection
689.                 $value = new PersistentCollection(
690.                     $this->em,
691.                     $this->em->getClassMetadata($assoc['targetEntity']),
692.                     $value
693.                 );
694.                 $value->setOwner($entity, $assoc);
695.                 $value->setDirty(! $value->isEmpty());
697.                 $refProp->setValue($entity, $value);
699.                 $actualData[$name] = $value;
701.                 continue;
702.             }
704.             if (( ! $class->isIdentifier($name) || ! $class->isIdGeneratorIdentity()) && ($name !== $class->versionField)) {
705.                 $actualData[$name] = $value;
706.             }
707.         }
709.         if (! isset($this->originalEntityData[$oid])) {
710.             // Entity is either NEW or MANAGED but not yet fully persisted (only has an id).
711.             // These result in an INSERT.
712.             $this->originalEntityData[$oid] = $actualData;
713.             $changeSet                      = [];
715.             foreach ($actualData as $propName => $actualValue) {
716.                 if (! isset($class->associationMappings[$propName])) {
717.                     $changeSet[$propName] = [null, $actualValue];
719.                     continue;
720.                 }
722.                 $assoc = $class->associationMappings[$propName];
724.                 if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
725.                     $changeSet[$propName] = [null, $actualValue];
726.                 }
727.             }
729.             $this->entityChangeSets[$oid] = $changeSet;
730.         } else {
731.             // Entity is "fully" MANAGED: it was already fully persisted before
732.             // and we have a copy of the original data
733.             $originalData           = $this->originalEntityData[$oid];
734.             $isChangeTrackingNotify = $class->isChangeTrackingNotify();
735.             $changeSet              = $isChangeTrackingNotify && isset($this->entityChangeSets[$oid])
736.                 ? $this->entityChangeSets[$oid]
737.                 : [];
739.             foreach ($actualData as $propName => $actualValue) {
740.                 // skip field, its a partially omitted one!
741.                 if (! (isset($originalData[$propName]) || array_key_exists($propName, $originalData))) {
742.                     continue;
743.                 }
745.                 $orgValue = $originalData[$propName];
747.                 if (! empty($class->fieldMappings[$propName]['enumType'])) {
748.                     if (is_array($orgValue)) {
749.                         foreach ($orgValue as $id => $val) {
750.                             if ($val instanceof BackedEnum) {
751.                                 $orgValue[$id] = $val->value;
752.                             }
753.                         }
754.                     } else {
755.                         if ($orgValue instanceof BackedEnum) {
756.                             $orgValue = $orgValue->value;
757.                         }
758.                     }
759.                 }
761.                 // skip if value haven't changed
762.                 if ($orgValue === $actualValue) {
763.                     continue;
764.                 }
766.                 // if regular field
767.                 if (! isset($class->associationMappings[$propName])) {
768.                     if ($isChangeTrackingNotify) {
769.                         continue;
770.                     }
772.                     $changeSet[$propName] = [$orgValue, $actualValue];
774.                     continue;
775.                 }
777.                 $assoc = $class->associationMappings[$propName];
779.                 // Persistent collection was exchanged with the "originally"
780.                 // created one. This can only mean it was cloned and replaced
781.                 // on another entity.
782.                 if ($actualValue instanceof PersistentCollection) {
783.                     $owner = $actualValue->getOwner();
784.                     if ($owner === null) { // cloned
785.                         $actualValue->setOwner($entity, $assoc);
786.                     } elseif ($owner !== $entity) { // no clone, we have to fix
787.                         if (! $actualValue->isInitialized()) {
788.                             $actualValue->initialize(); // we have to do this otherwise the cols share state
789.                         }
791.                         $newValue = clone $actualValue;
792.                         $newValue->setOwner($entity, $assoc);
793.                         $class->reflFields[$propName]->setValue($entity, $newValue);
794.                     }
795.                 }
797.                 if ($orgValue instanceof PersistentCollection) {
798.                     // A PersistentCollection was de-referenced, so delete it.
799.                     $coid = spl_object_id($orgValue);
801.                     if (isset($this->collectionDeletions[$coid])) {
802.                         continue;
803.                     }
805.                     $this->collectionDeletions[$coid] = $orgValue;
806.                     $changeSet[$propName]             = $orgValue; // Signal changeset, to-many assocs will be ignored.
808.                     continue;
809.                 }
811.                 if ($assoc['type'] & ClassMetadata::TO_ONE) {
812.                     if ($assoc['isOwningSide']) {
813.                         $changeSet[$propName] = [$orgValue, $actualValue];
814.                     }
816.                     if ($orgValue !== null && $assoc['orphanRemoval']) {
817.                         assert(is_object($orgValue));
818.                         $this->scheduleOrphanRemoval($orgValue);
819.                     }
820.                 }
821.             }
823.             if ($changeSet) {
824.                 $this->entityChangeSets[$oid]   = $changeSet;
825.                 $this->originalEntityData[$oid] = $actualData;
826.                 $this->entityUpdates[$oid]      = $entity;
827.             }
828.         }
830.         // Look for changes in associations of the entity
831.         foreach ($class->associationMappings as $field => $assoc) {
832.             $val = $class->reflFields[$field]->getValue($entity);
833.             if ($val === null) {
834.                 continue;
835.             }
837.             $this->computeAssociationChanges($assoc, $val);
839.             if (
840.                 ! isset($this->entityChangeSets[$oid]) &&
841.                 $assoc['isOwningSide'] &&
842.                 $assoc['type'] === ClassMetadata::MANY_TO_MANY &&
843.                 $val instanceof PersistentCollection &&
844.                 $val->isDirty()
845.             ) {
846.                 $this->entityChangeSets[$oid]   = [];
847.                 $this->originalEntityData[$oid] = $actualData;
848.                 $this->entityUpdates[$oid]      = $entity;
849.             }
850.         }
851.     }
853.     /**
854.      * Computes all the changes that have been done to entities and collections
855.      * since the last commit and stores these changes in the _entityChangeSet map
856.      * temporarily for access by the persisters, until the UoW commit is finished.
857.      *
858.      * @return void
859.      */
860.     public function computeChangeSets()
861.     {
862.         // Compute changes for INSERTed entities first. This must always happen.
863.         $this->computeScheduleInsertsChangeSets();
865.         // Compute changes for other MANAGED entities. Change tracking policies take effect here.
866.         foreach ($this->identityMap as $className => $entities) {
867.             $class = $this->em->getClassMetadata($className);
869.             // Skip class if instances are read-only
870.             if ($class->isReadOnly) {
871.                 continue;
872.             }
874.             // If change tracking is explicit or happens through notification, then only compute
875.             // changes on entities of that type that are explicitly marked for synchronization.
876.             switch (true) {
877.                 case $class->isChangeTrackingDeferredImplicit():
878.                     $entitiesToProcess = $entities;
879.                     break;
881.                 case isset($this->scheduledForSynchronization[$className]):
882.                     $entitiesToProcess = $this->scheduledForSynchronization[$className];
883.                     break;
885.                 default:
886.                     $entitiesToProcess = [];
887.             }
889.             foreach ($entitiesToProcess as $entity) {
890.                 // Ignore uninitialized proxy objects
891.                 if ($entity instanceof Proxy && ! $entity->__isInitialized()) {
892.                     continue;
893.                 }
895.                 // Only MANAGED entities that are NOT SCHEDULED FOR INSERTION OR DELETION are processed here.
896.                 $oid = spl_object_id($entity);
898.                 if (! isset($this->entityInsertions[$oid]) && ! isset($this->entityDeletions[$oid]) && isset($this->entityStates[$oid])) {
899.                     $this->computeChangeSet($class, $entity);
900.                 }
901.             }
902.         }
903.     }
905.     /**
906.      * Computes the changes of an association.
907.      *
908.      * @param mixed $value The value of the association.
909.      * @psalm-param array<string, mixed> $assoc The association mapping.
910.      *
911.      * @throws ORMInvalidArgumentException
912.      * @throws ORMException
913.      */
914.     private function computeAssociationChanges(array $assoc, $value): void
915.     {
916.         if ($value instanceof Proxy && ! $value->__isInitialized()) {
917.             return;
918.         }
920.         if ($value instanceof PersistentCollection && $value->isDirty()) {
921.             $coid = spl_object_id($value);
923.             $this->collectionUpdates[$coid]  = $value;
924.             $this->visitedCollections[$coid] = $value;
925.         }
927.         // Look through the entities, and in any of their associations,
928.         // for transient (new) entities, recursively. ("Persistence by reachability")
929.         // Unwrap. Uninitialized collections will simply be empty.
930.         $unwrappedValue = $assoc['type'] & ClassMetadata::TO_ONE ? [$value] : $value->unwrap();
931.         $targetClass    = $this->em->getClassMetadata($assoc['targetEntity']);
933.         foreach ($unwrappedValue as $key => $entry) {
934.             if (! ($entry instanceof $targetClass->name)) {
935.                 throw ORMInvalidArgumentException::invalidAssociation($targetClass, $assoc, $entry);
936.             }
938.             $state = $this->getEntityState($entry, self::STATE_NEW);
940.             if (! ($entry instanceof $assoc['targetEntity'])) {
941.                 throw UnexpectedAssociationValue::create(
942.                     $assoc['sourceEntity'],
943.                     $assoc['fieldName'],
944.                     get_debug_type($entry),
945.                     $assoc['targetEntity']
946.                 );
947.             }
949.             switch ($state) {
950.                 case self::STATE_NEW:
951.                     if (! $assoc['isCascadePersist']) {
952.                         /*
953.                          * For now just record the details, because this may
954.                          * not be an issue if we later discover another pathway
955.                          * through the object-graph where cascade-persistence
956.                          * is enabled for this object.
957.                          */
958.                         $this->nonCascadedNewDetectedEntities[spl_object_id($entry)] = [$assoc, $entry];
960.                         break;
961.                     }
963.                     $this->persistNew($targetClass, $entry);
964.                     $this->computeChangeSet($targetClass, $entry);
966.                     break;
968.                 case self::STATE_REMOVED:
969.                     // Consume the $value as array (it's either an array or an ArrayAccess)
970.                     // and remove the element from Collection.
971.                     if ($assoc['type'] & ClassMetadata::TO_MANY) {
972.                         unset($value[$key]);
973.                     }
975.                     break;
977.                 case self::STATE_DETACHED:
978.                     // Can actually not happen right now as we assume STATE_NEW,
979.                     // so the exception will be raised from the DBAL layer (constraint violation).
980.                     throw ORMInvalidArgumentException::detachedEntityFoundThroughRelationship($assoc, $entry);
982.                 default:
983.                     // MANAGED associated entities are already taken into account
984.                     // during changeset calculation anyway, since they are in the identity map.
985.             }
986.         }
987.     }
989.     /**
990.      * @param object $entity
991.      * @psalm-param ClassMetadata<T> $class
992.      * @psalm-param T $entity
993.      *
994.      * @template T of object
995.      */
996.     private function persistNew(ClassMetadata $class, $entity): void
997.     {
998.         $oid    = spl_object_id($entity);
999.         $invoke = $this->listenersInvoker->getSubscribedSystems($class, Events::prePersist);
1001.         if ($invoke !== ListenersInvoker::INVOKE_NONE) {
1002.             $this->listenersInvoker->invoke($class, Events::prePersist, $entity, new PrePersistEventArgs($entity, $this->em), $invoke);
1003.         }
1005.         $idGen = $class->idGenerator;
1007.         if (! $idGen->isPostInsertGenerator()) {
1008.             $idValue = $idGen->generateId($this->em, $entity);
1010.             if (! $idGen instanceof AssignedGenerator) {
1011.                 $idValue = [$class->getSingleIdentifierFieldName() => $this->convertSingleFieldIdentifierToPHPValue($class, $idValue)];
1013.                 $class->setIdentifierValues($entity, $idValue);
1014.             }
1016.             // Some identifiers may be foreign keys to new entities.
1017.             // In this case, we don't have the value yet and should treat it as if we have a post-insert generator
1018.             if (! $this->hasMissingIdsWhichAreForeignKeys($class, $idValue)) {
1019.                 $this->entityIdentifiers[$oid] = $idValue;
1020.             }
1021.         }
1023.         $this->entityStates[$oid] = self::STATE_MANAGED;
1025.         $this->scheduleForInsert($entity);
1026.     }
1028.     /** @param mixed[] $idValue */
1029.     private function hasMissingIdsWhichAreForeignKeys(ClassMetadata $class, array $idValue): bool
1030.     {
1031.         foreach ($idValue as $idField => $idFieldValue) {
1032.             if ($idFieldValue === null && isset($class->associationMappings[$idField])) {
1033.                 return true;
1034.             }
1035.         }
1037.         return false;
1038.     }
1040.     /**
1041.      * INTERNAL:
1042.      * Computes the changeset of an individual entity, independently of the
1043.      * computeChangeSets() routine that is used at the beginning of a UnitOfWork#commit().
1044.      *
1045.      * The passed entity must be a managed entity. If the entity already has a change set
1046.      * because this method is invoked during a commit cycle then the change sets are added.
1047.      * whereby changes detected in this method prevail.
1048.      *
1049.      * @param ClassMetadata $class  The class descriptor of the entity.
1050.      * @param object        $entity The entity for which to (re)calculate the change set.
1051.      * @psalm-param ClassMetadata<T> $class
1052.      * @psalm-param T $entity
1053.      *
1054.      * @return void
1055.      *
1056.      * @throws ORMInvalidArgumentException If the passed entity is not MANAGED.
1057.      *
1058.      * @template T of object
1059.      * @ignore
1060.      */
1061.     public function recomputeSingleEntityChangeSet(ClassMetadata $class, $entity)
1062.     {
1063.         $oid = spl_object_id($entity);
1065.         if (! isset($this->entityStates[$oid]) || $this->entityStates[$oid] !== self::STATE_MANAGED) {
1066.             throw ORMInvalidArgumentException::entityNotManaged($entity);
1067.         }
1069.         // skip if change tracking is "NOTIFY"
1070.         if ($class->isChangeTrackingNotify()) {
1071.             return;
1072.         }
1074.         if (! $class->isInheritanceTypeNone()) {
1075.             $class = $this->em->getClassMetadata(get_class($entity));
1076.         }
1078.         $actualData = [];
1080.         foreach ($class->reflFields as $name => $refProp) {
1081.             if (
1082.                 ( ! $class->isIdentifier($name) || ! $class->isIdGeneratorIdentity())
1083.                 && ($name !== $class->versionField)
1084.                 && ! $class->isCollectionValuedAssociation($name)
1085.             ) {
1086.                 $actualData[$name] = $refProp->getValue($entity);
1087.             }
1088.         }
1090.         if (! isset($this->originalEntityData[$oid])) {
1091.             throw new RuntimeException('Cannot call recomputeSingleEntityChangeSet before computeChangeSet on an entity.');
1092.         }
1094.         $originalData = $this->originalEntityData[$oid];
1095.         $changeSet    = [];
1097.         foreach ($actualData as $propName => $actualValue) {
1098.             $orgValue = $originalData[$propName] ?? null;
1100.             if ($orgValue !== $actualValue) {
1101.                 $changeSet[$propName] = [$orgValue, $actualValue];
1102.             }
1103.         }
1105.         if ($changeSet) {
1106.             if (isset($this->entityChangeSets[$oid])) {
1107.                 $this->entityChangeSets[$oid] = array_merge($this->entityChangeSets[$oid], $changeSet);
1108.             } elseif (! isset($this->entityInsertions[$oid])) {
1109.                 $this->entityChangeSets[$oid] = $changeSet;
1110.                 $this->entityUpdates[$oid]    = $entity;
1111.             }
1113.             $this->originalEntityData[$oid] = $actualData;
1114.         }
1115.     }
1117.     /**
1118.      * Executes all entity insertions for entities of the specified type.
1119.      */
1120.     private function executeInserts(ClassMetadata $class): void
1121.     {
1122.         $entities  = [];
1123.         $className = $class->name;
1124.         $persister = $this->getEntityPersister($className);
1125.         $invoke    = $this->listenersInvoker->getSubscribedSystems($class, Events::postPersist);
1127.         $insertionsForClass = [];
1129.         foreach ($this->entityInsertions as $oid => $entity) {
1130.             if ($this->em->getClassMetadata(get_class($entity))->name !== $className) {
1131.                 continue;
1132.             }
1134.             $insertionsForClass[$oid] = $entity;
1136.             $persister->addInsert($entity);
1138.             unset($this->entityInsertions[$oid]);
1140.             if ($invoke !== ListenersInvoker::INVOKE_NONE) {
1141.                 $entities[] = $entity;
1142.             }
1143.         }
1145.         $postInsertIds = $persister->executeInserts();
1147.         if ($postInsertIds) {
1148.             // Persister returned post-insert IDs
1149.             foreach ($postInsertIds as $postInsertId) {
1150.                 $idField = $class->getSingleIdentifierFieldName();
1151.                 $idValue = $this->convertSingleFieldIdentifierToPHPValue($class, $postInsertId['generatedId']);
1153.                 $entity = $postInsertId['entity'];
1154.                 $oid    = spl_object_id($entity);
1156.                 $class->reflFields[$idField]->setValue($entity, $idValue);
1158.                 $this->entityIdentifiers[$oid]            = [$idField => $idValue];
1159.                 $this->entityStates[$oid]                 = self::STATE_MANAGED;
1160.                 $this->originalEntityData[$oid][$idField] = $idValue;
1162.                 $this->addToIdentityMap($entity);
1163.             }
1164.         } else {
1165.             foreach ($insertionsForClass as $oid => $entity) {
1166.                 if (! isset($this->entityIdentifiers[$oid])) {
1167.                     //entity was not added to identity map because some identifiers are foreign keys to new entities.
1168.                     //add it now
1169.                     $this->addToEntityIdentifiersAndEntityMap($class, $oid, $entity);
1170.                 }
1171.             }
1172.         }
1174.         foreach ($entities as $entity) {
1175.             $this->listenersInvoker->invoke($class, Events::postPersist, $entity, new PostPersistEventArgs($entity, $this->em), $invoke);
1176.         }
1177.     }
1179.     /**
1180.      * @param object $entity
1181.      * @psalm-param ClassMetadata<T> $class
1182.      * @psalm-param T $entity
1183.      *
1184.      * @template T of object
1185.      */
1186.     private function addToEntityIdentifiersAndEntityMap(
1187.         ClassMetadata $class,
1188.         int $oid,
1189.         $entity
1190.     ): void {
1191.         $identifier = [];
1193.         foreach ($class->getIdentifierFieldNames() as $idField) {
1194.             $origValue = $class->getFieldValue($entity, $idField);
1196.             $value = null;
1197.             if (isset($class->associationMappings[$idField])) {
1198.                 // NOTE: Single Columns as associated identifiers only allowed - this constraint it is enforced.
1199.                 $value = $this->getSingleIdentifierValue($origValue);
1200.             }
1202.             $identifier[$idField]                     = $value ?? $origValue;
1203.             $this->originalEntityData[$oid][$idField] = $origValue;
1204.         }
1206.         $this->entityStates[$oid]      = self::STATE_MANAGED;
1207.         $this->entityIdentifiers[$oid] = $identifier;
1209.         $this->addToIdentityMap($entity);
1210.     }
1212.     /**
1213.      * Executes all entity updates for entities of the specified type.
1214.      */
1215.     private function executeUpdates(ClassMetadata $class): void
1216.     {
1217.         $className        = $class->name;
1218.         $persister        = $this->getEntityPersister($className);
1219.         $preUpdateInvoke  = $this->listenersInvoker->getSubscribedSystems($class, Events::preUpdate);
1220.         $postUpdateInvoke = $this->listenersInvoker->getSubscribedSystems($class, Events::postUpdate);
1222.         foreach ($this->entityUpdates as $oid => $entity) {
1223.             if ($this->em->getClassMetadata(get_class($entity))->name !== $className) {
1224.                 continue;
1225.             }
1227.             if ($preUpdateInvoke !== ListenersInvoker::INVOKE_NONE) {
1228.                 $this->listenersInvoker->invoke($class, Events::preUpdate, $entity, new PreUpdateEventArgs($entity, $this->em, $this->getEntityChangeSet($entity)), $preUpdateInvoke);
1230.                 $this->recomputeSingleEntityChangeSet($class, $entity);
1231.             }
1233.             if (! empty($this->entityChangeSets[$oid])) {
1234.                 $persister->update($entity);
1235.             }
1237.             unset($this->entityUpdates[$oid]);
1239.             if ($postUpdateInvoke !== ListenersInvoker::INVOKE_NONE) {
1240.                 $this->listenersInvoker->invoke($class, Events::postUpdate, $entity, new PostUpdateEventArgs($entity, $this->em), $postUpdateInvoke);
1241.             }
1242.         }
1243.     }
1245.     /**
1246.      * Executes all entity deletions for entities of the specified type.
1247.      */
1248.     private function executeDeletions(ClassMetadata $class): void
1249.     {
1250.         $className = $class->name;
1251.         $persister = $this->getEntityPersister($className);
1252.         $invoke    = $this->listenersInvoker->getSubscribedSystems($class, Events::postRemove);
1254.         foreach ($this->entityDeletions as $oid => $entity) {
1255.             if ($this->em->getClassMetadata(get_class($entity))->name !== $className) {
1256.                 continue;
1257.             }
1259.             $persister->delete($entity);
1261.             unset(
1262.                 $this->entityDeletions[$oid],
1263.                 $this->entityIdentifiers[$oid],
1264.                 $this->originalEntityData[$oid],
1265.                 $this->entityStates[$oid]
1266.             );
1268.             // Entity with this $oid after deletion treated as NEW, even if the $oid
1269.             // is obtained by a new entity because the old one went out of scope.
1270.             //$this->entityStates[$oid] = self::STATE_NEW;
1271.             if (! $class->isIdentifierNatural()) {
1272.                 $class->reflFields[$class->identifier[0]]->setValue($entity, null);
1273.             }
1275.             if ($invoke !== ListenersInvoker::INVOKE_NONE) {
1276.                 $this->listenersInvoker->invoke($class, Events::postRemove, $entity, new PostRemoveEventArgs($entity, $this->em), $invoke);
1277.             }
1278.         }
1279.     }
1281.     /**
1282.      * Gets the commit order.
1283.      *
1284.      * @return list<ClassMetadata>
1285.      */
1286.     private function getCommitOrder(): array
1287.     {
1288.         $calc = $this->getCommitOrderCalculator();
1290.         // See if there are any new classes in the changeset, that are not in the
1291.         // commit order graph yet (don't have a node).
1292.         // We have to inspect changeSet to be able to correctly build dependencies.
1293.         // It is not possible to use IdentityMap here because post inserted ids
1294.         // are not yet available.
1295.         $newNodes = [];
1297.         foreach (array_merge($this->entityInsertions, $this->entityUpdates, $this->entityDeletions) as $entity) {
1298.             $class = $this->em->getClassMetadata(get_class($entity));
1300.             if ($calc->hasNode($class->name)) {
1301.                 continue;
1302.             }
1304.             $calc->addNode($class->name, $class);
1306.             $newNodes[] = $class;
1307.         }
1309.         // Calculate dependencies for new nodes
1310.         while ($class = array_pop($newNodes)) {
1311.             foreach ($class->associationMappings as $assoc) {
1312.                 if (! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)) {
1313.                     continue;
1314.                 }
1316.                 $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
1318.                 if (! $calc->hasNode($targetClass->name)) {
1319.                     $calc->addNode($targetClass->name, $targetClass);
1321.                     $newNodes[] = $targetClass;
1322.                 }
1324.                 $joinColumns = reset($assoc['joinColumns']);
1326.                 $calc->addDependency($targetClass->name, $class->name, (int) empty($joinColumns['nullable']));
1328.                 // If the target class has mapped subclasses, these share the same dependency.
1329.                 if (! $targetClass->subClasses) {
1330.                     continue;
1331.                 }
1333.                 foreach ($targetClass->subClasses as $subClassName) {
1334.                     $targetSubClass = $this->em->getClassMetadata($subClassName);
1336.                     if (! $calc->hasNode($subClassName)) {
1337.                         $calc->addNode($targetSubClass->name, $targetSubClass);
1339.                         $newNodes[] = $targetSubClass;
1340.                     }
1342.                     $calc->addDependency($targetSubClass->name, $class->name, 1);
1343.                 }
1344.             }
1345.         }
1347.         return $calc->sort();
1348.     }
1350.     /**
1351.      * Schedules an entity for insertion into the database.
1352.      * If the entity already has an identifier, it will be added to the identity map.
1353.      *
1354.      * @param object $entity The entity to schedule for insertion.
1355.      *
1356.      * @return void
1357.      *
1358.      * @throws ORMInvalidArgumentException
1359.      * @throws InvalidArgumentException
1360.      */
1361.     public function scheduleForInsert($entity)
1362.     {
1363.         $oid = spl_object_id($entity);
1365.         if (isset($this->entityUpdates[$oid])) {
1366.             throw new InvalidArgumentException('Dirty entity can not be scheduled for insertion.');
1367.         }
1369.         if (isset($this->entityDeletions[$oid])) {
1370.             throw ORMInvalidArgumentException::scheduleInsertForRemovedEntity($entity);
1371.         }
1373.         if (isset($this->originalEntityData[$oid]) && ! isset($this->entityInsertions[$oid])) {
1374.             throw ORMInvalidArgumentException::scheduleInsertForManagedEntity($entity);
1375.         }
1377.         if (isset($this->entityInsertions[$oid])) {
1378.             throw ORMInvalidArgumentException::scheduleInsertTwice($entity);
1379.         }
1381.         $this->entityInsertions[$oid] = $entity;
1383.         if (isset($this->entityIdentifiers[$oid])) {
1384.             $this->addToIdentityMap($entity);
1385.         }
1387.         if ($entity instanceof NotifyPropertyChanged) {
1388.             $entity->addPropertyChangedListener($this);
1389.         }
1390.     }
1392.     /**
1393.      * Checks whether an entity is scheduled for insertion.
1394.      *
1395.      * @param object $entity
1396.      *
1397.      * @return bool
1398.      */
1399.     public function isScheduledForInsert($entity)
1400.     {
1401.         return isset($this->entityInsertions[spl_object_id($entity)]);
1402.     }
1404.     /**
1405.      * Schedules an entity for being updated.
1406.      *
1407.      * @param object $entity The entity to schedule for being updated.
1408.      *
1409.      * @return void
1410.      *
1411.      * @throws ORMInvalidArgumentException
1412.      */
1413.     public function scheduleForUpdate($entity)
1414.     {
1415.         $oid = spl_object_id($entity);
1417.         if (! isset($this->entityIdentifiers[$oid])) {
1418.             throw ORMInvalidArgumentException::entityHasNoIdentity($entity, 'scheduling for update');
1419.         }
1421.         if (isset($this->entityDeletions[$oid])) {
1422.             throw ORMInvalidArgumentException::entityIsRemoved($entity, 'schedule for update');
1423.         }
1425.         if (! isset($this->entityUpdates[$oid]) && ! isset($this->entityInsertions[$oid])) {
1426.             $this->entityUpdates[$oid] = $entity;
1427.         }
1428.     }
1430.     /**
1431.      * INTERNAL:
1432.      * Schedules an extra update that will be executed immediately after the
1433.      * regular entity updates within the currently running commit cycle.
1434.      *
1435.      * Extra updates for entities are stored as (entity, changeset) tuples.
1436.      *
1437.      * @param object $entity The entity for which to schedule an extra update.
1438.      * @psalm-param array<string, array{mixed, mixed}>  $changeset The changeset of the entity (what to update).
1439.      *
1440.      * @return void
1441.      *
1442.      * @ignore
1443.      */
1444.     public function scheduleExtraUpdate($entity, array $changeset)
1445.     {
1446.         $oid         = spl_object_id($entity);
1447.         $extraUpdate = [$entity, $changeset];
1449.         if (isset($this->extraUpdates[$oid])) {
1450.             [, $changeset2] = $this->extraUpdates[$oid];
1452.             $extraUpdate = [$entity, $changeset + $changeset2];
1453.         }
1455.         $this->extraUpdates[$oid] = $extraUpdate;
1456.     }
1458.     /**
1459.      * Checks whether an entity is registered as dirty in the unit of work.
1460.      * Note: Is not very useful currently as dirty entities are only registered
1461.      * at commit time.
1462.      *
1463.      * @param object $entity
1464.      *
1465.      * @return bool
1466.      */
1467.     public function isScheduledForUpdate($entity)
1468.     {
1469.         return isset($this->entityUpdates[spl_object_id($entity)]);
1470.     }
1472.     /**
1473.      * Checks whether an entity is registered to be checked in the unit of work.
1474.      *
1475.      * @param object $entity
1476.      *
1477.      * @return bool
1478.      */
1479.     public function isScheduledForDirtyCheck($entity)
1480.     {
1481.         $rootEntityName = $this->em->getClassMetadata(get_class($entity))->rootEntityName;
1483.         return isset($this->scheduledForSynchronization[$rootEntityName][spl_object_id($entity)]);
1484.     }
1486.     /**
1487.      * INTERNAL:
1488.      * Schedules an entity for deletion.
1489.      *
1490.      * @param object $entity
1491.      *
1492.      * @return void
1493.      */
1494.     public function scheduleForDelete($entity)
1495.     {
1496.         $oid = spl_object_id($entity);
1498.         if (isset($this->entityInsertions[$oid])) {
1499.             if ($this->isInIdentityMap($entity)) {
1500.                 $this->removeFromIdentityMap($entity);
1501.             }
1503.             unset($this->entityInsertions[$oid], $this->entityStates[$oid]);
1505.             return; // entity has not been persisted yet, so nothing more to do.
1506.         }
1508.         if (! $this->isInIdentityMap($entity)) {
1509.             return;
1510.         }
1512.         $this->removeFromIdentityMap($entity);
1514.         unset($this->entityUpdates[$oid]);
1516.         if (! isset($this->entityDeletions[$oid])) {
1517.             $this->entityDeletions[$oid] = $entity;
1518.             $this->entityStates[$oid]    = self::STATE_REMOVED;
1519.         }
1520.     }
1522.     /**
1523.      * Checks whether an entity is registered as removed/deleted with the unit
1524.      * of work.
1525.      *
1526.      * @param object $entity
1527.      *
1528.      * @return bool
1529.      */
1530.     public function isScheduledForDelete($entity)
1531.     {
1532.         return isset($this->entityDeletions[spl_object_id($entity)]);
1533.     }
1535.     /**
1536.      * Checks whether an entity is scheduled for insertion, update or deletion.
1537.      *
1538.      * @param object $entity
1539.      *
1540.      * @return bool
1541.      */
1542.     public function isEntityScheduled($entity)
1543.     {
1544.         $oid = spl_object_id($entity);
1546.         return isset($this->entityInsertions[$oid])
1547.             || isset($this->entityUpdates[$oid])
1548.             || isset($this->entityDeletions[$oid]);
1549.     }
1551.     /**
1552.      * INTERNAL:
1553.      * Registers an entity in the identity map.
1554.      * Note that entities in a hierarchy are registered with the class name of
1555.      * the root entity.
1556.      *
1557.      * @param object $entity The entity to register.
1558.      *
1559.      * @return bool TRUE if the registration was successful, FALSE if the identity of
1560.      * the entity in question is already managed.
1561.      *
1562.      * @throws ORMInvalidArgumentException
1563.      *
1564.      * @ignore
1565.      */
1566.     public function addToIdentityMap($entity)
1567.     {
1568.         $classMetadata = $this->em->getClassMetadata(get_class($entity));
1569.         $identifier    = $this->entityIdentifiers[spl_object_id($entity)];
1571.         if (empty($identifier) || in_array(null, $identifier, true)) {
1572.             throw ORMInvalidArgumentException::entityWithoutIdentity($classMetadata->name, $entity);
1573.         }
1575.         $idHash    = implode(' ', $identifier);
1576.         $className = $classMetadata->rootEntityName;
1578.         if (isset($this->identityMap[$className][$idHash])) {
1579.             return false;
1580.         }
1582.         $this->identityMap[$className][$idHash] = $entity;
1584.         return true;
1585.     }
1587.     /**
1588.      * Gets the state of an entity with regard to the current unit of work.
1589.      *
1590.      * @param object   $entity
1591.      * @param int|null $assume The state to assume if the state is not yet known (not MANAGED or REMOVED).
1592.      *                         This parameter can be set to improve performance of entity state detection
1593.      *                         by potentially avoiding a database lookup if the distinction between NEW and DETACHED
1594.      *                         is either known or does not matter for the caller of the method.
1595.      * @psalm-param self::STATE_*|null $assume
1596.      *
1597.      * @return int The entity state.
1598.      * @psalm-return self::STATE_*
1599.      */
1600.     public function getEntityState($entity, $assume = null)
1601.     {
1602.         $oid = spl_object_id($entity);
1604.         if (isset($this->entityStates[$oid])) {
1605.             return $this->entityStates[$oid];
1606.         }
1608.         if ($assume !== null) {
1609.             return $assume;
1610.         }
1612.         // State can only be NEW or DETACHED, because MANAGED/REMOVED states are known.
1613.         // Note that you can not remember the NEW or DETACHED state in _entityStates since
1614.         // the UoW does not hold references to such objects and the object hash can be reused.
1615.         // More generally because the state may "change" between NEW/DETACHED without the UoW being aware of it.
1616.         $class = $this->em->getClassMetadata(get_class($entity));
1617.         $id    = $class->getIdentifierValues($entity);
1619.         if (! $id) {
1620.             return self::STATE_NEW;
1621.         }
1623.         if ($class->containsForeignIdentifier || $class->containsEnumIdentifier) {
1624.             $id = $this->identifierFlattener->flattenIdentifier($class, $id);
1625.         }
1627.         switch (true) {
1628.             case $class->isIdentifierNatural():
1629.                 // Check for a version field, if available, to avoid a db lookup.
1630.                 if ($class->isVersioned) {
1631.                     assert($class->versionField !== null);
1633.                     return $class->getFieldValue($entity, $class->versionField)
1634.                         ? self::STATE_DETACHED
1635.                         : self::STATE_NEW;
1636.                 }
1638.                 // Last try before db lookup: check the identity map.
1639.                 if ($this->tryGetById($id, $class->rootEntityName)) {
1640.                     return self::STATE_DETACHED;
1641.                 }
1643.                 // db lookup
1644.                 if ($this->getEntityPersister($class->name)->exists($entity)) {
1645.                     return self::STATE_DETACHED;
1646.                 }
1648.                 return self::STATE_NEW;
1650.             case ! $class->idGenerator->isPostInsertGenerator():
1651.                 // if we have a pre insert generator we can't be sure that having an id
1652.                 // really means that the entity exists. We have to verify this through
1653.                 // the last resort: a db lookup
1655.                 // Last try before db lookup: check the identity map.
1656.                 if ($this->tryGetById($id, $class->rootEntityName)) {
1657.                     return self::STATE_DETACHED;
1658.                 }
1660.                 // db lookup
1661.                 if ($this->getEntityPersister($class->name)->exists($entity)) {
1662.                     return self::STATE_DETACHED;
1663.                 }
1665.                 return self::STATE_NEW;
1667.             default:
1668.                 return self::STATE_DETACHED;
1669.         }
1670.     }
1672.     /**
1673.      * INTERNAL:
1674.      * Removes an entity from the identity map. This effectively detaches the
1675.      * entity from the persistence management of Doctrine.
1676.      *
1677.      * @param object $entity
1678.      *
1679.      * @return bool
1680.      *
1681.      * @throws ORMInvalidArgumentException
1682.      *
1683.      * @ignore
1684.      */
1685.     public function removeFromIdentityMap($entity)
1686.     {
1687.         $oid           = spl_object_id($entity);
1688.         $classMetadata = $this->em->getClassMetadata(get_class($entity));
1689.         $idHash        = implode(' ', $this->entityIdentifiers[$oid]);
1691.         if ($idHash === '') {
1692.             throw ORMInvalidArgumentException::entityHasNoIdentity($entity, 'remove from identity map');
1693.         }
1695.         $className = $classMetadata->rootEntityName;
1697.         if (isset($this->identityMap[$className][$idHash])) {
1698.             unset($this->identityMap[$className][$idHash], $this->readOnlyObjects[$oid]);
1700.             //$this->entityStates[$oid] = self::STATE_DETACHED;
1702.             return true;
1703.         }
1705.         return false;
1706.     }
1708.     /**
1709.      * INTERNAL:
1710.      * Gets an entity in the identity map by its identifier hash.
1711.      *
1712.      * @param string $idHash
1713.      * @param string $rootClassName
1714.      *
1715.      * @return object
1716.      *
1717.      * @ignore
1718.      */
1719.     public function getByIdHash($idHash, $rootClassName)
1720.     {
1721.         return $this->identityMap[$rootClassName][$idHash];
1722.     }
1724.     /**
1725.      * INTERNAL:
1726.      * Tries to get an entity by its identifier hash. If no entity is found for
1727.      * the given hash, FALSE is returned.
1728.      *
1729.      * @param mixed  $idHash        (must be possible to cast it to string)
1730.      * @param string $rootClassName
1731.      *
1732.      * @return false|object The found entity or FALSE.
1733.      *
1734.      * @ignore
1735.      */
1736.     public function tryGetByIdHash($idHash, $rootClassName)
1737.     {
1738.         $stringIdHash = (string) $idHash;
1740.         return $this->identityMap[$rootClassName][$stringIdHash] ?? false;
1741.     }
1743.     /**
1744.      * Checks whether an entity is registered in the identity map of this UnitOfWork.
1745.      *
1746.      * @param object $entity
1747.      *
1748.      * @return bool
1749.      */
1750.     public function isInIdentityMap($entity)
1751.     {
1752.         $oid = spl_object_id($entity);
1754.         if (empty($this->entityIdentifiers[$oid])) {
1755.             return false;
1756.         }
1758.         $classMetadata = $this->em->getClassMetadata(get_class($entity));
1759.         $idHash        = implode(' ', $this->entityIdentifiers[$oid]);
1761.         return isset($this->identityMap[$classMetadata->rootEntityName][$idHash]);
1762.     }
1764.     /**
1765.      * INTERNAL:
1766.      * Checks whether an identifier hash exists in the identity map.
1767.      *
1768.      * @param string $idHash
1769.      * @param string $rootClassName
1770.      *
1771.      * @return bool
1772.      *
1773.      * @ignore
1774.      */
1775.     public function containsIdHash($idHash, $rootClassName)
1776.     {
1777.         return isset($this->identityMap[$rootClassName][$idHash]);
1778.     }
1780.     /**
1781.      * Persists an entity as part of the current unit of work.
1782.      *
1783.      * @param object $entity The entity to persist.
1784.      *
1785.      * @return void
1786.      */
1787.     public function persist($entity)
1788.     {
1789.         $visited = [];
1791.         $this->doPersist($entity, $visited);
1792.     }
1794.     /**
1795.      * Persists an entity as part of the current unit of work.
1796.      *
1797.      * This method is internally called during persist() cascades as it tracks
1798.      * the already visited entities to prevent infinite recursions.
1799.      *
1800.      * @param object $entity The entity to persist.
1801.      * @psalm-param array<int, object> $visited The already visited entities.
1802.      *
1803.      * @throws ORMInvalidArgumentException
1804.      * @throws UnexpectedValueException
1805.      */
1806.     private function doPersist($entity, array &$visited): void
1807.     {
1808.         $oid = spl_object_id($entity);
1810.         if (isset($visited[$oid])) {
1811.             return; // Prevent infinite recursion
1812.         }
1814.         $visited[$oid] = $entity; // Mark visited
1816.         $class = $this->em->getClassMetadata(get_class($entity));
1818.         // We assume NEW, so DETACHED entities result in an exception on flush (constraint violation).
1819.         // If we would detect DETACHED here we would throw an exception anyway with the same
1820.         // consequences (not recoverable/programming error), so just assuming NEW here
1821.         // lets us avoid some database lookups for entities with natural identifiers.
1822.         $entityState = $this->getEntityState($entity, self::STATE_NEW);
1824.         switch ($entityState) {
1825.             case self::STATE_MANAGED:
1826.                 // Nothing to do, except if policy is "deferred explicit"
1827.                 if ($class->isChangeTrackingDeferredExplicit()) {
1828.                     $this->scheduleForDirtyCheck($entity);
1829.                 }
1831.                 break;
1833.             case self::STATE_NEW:
1834.                 $this->persistNew($class, $entity);
1835.                 break;
1837.             case self::STATE_REMOVED:
1838.                 // Entity becomes managed again
1839.                 unset($this->entityDeletions[$oid]);
1840.                 $this->addToIdentityMap($entity);
1842.                 $this->entityStates[$oid] = self::STATE_MANAGED;
1844.                 if ($class->isChangeTrackingDeferredExplicit()) {
1845.                     $this->scheduleForDirtyCheck($entity);
1846.                 }
1848.                 break;
1850.             case self::STATE_DETACHED:
1851.                 // Can actually not happen right now since we assume STATE_NEW.
1852.                 throw ORMInvalidArgumentException::detachedEntityCannot($entity, 'persisted');
1854.             default:
1855.                 throw new UnexpectedValueException(sprintf(
1856.                     'Unexpected entity state: %s. %s',
1857.                     $entityState,
1858.                     self::objToStr($entity)
1859.                 ));
1860.         }
1862.         $this->cascadePersist($entity, $visited);
1863.     }
1865.     /**
1866.      * Deletes an entity as part of the current unit of work.
1867.      *
1868.      * @param object $entity The entity to remove.
1869.      *
1870.      * @return void
1871.      */
1872.     public function remove($entity)
1873.     {
1874.         $visited = [];
1876.         $this->doRemove($entity, $visited);
1877.     }
1879.     /**
1880.      * Deletes an entity as part of the current unit of work.
1881.      *
1882.      * This method is internally called during delete() cascades as it tracks
1883.      * the already visited entities to prevent infinite recursions.
1884.      *
1885.      * @param object $entity The entity to delete.
1886.      * @psalm-param array<int, object> $visited The map of the already visited entities.
1887.      *
1888.      * @throws ORMInvalidArgumentException If the instance is a detached entity.
1889.      * @throws UnexpectedValueException
1890.      */
1891.     private function doRemove($entity, array &$visited): void
1892.     {
1893.         $oid = spl_object_id($entity);
1895.         if (isset($visited[$oid])) {
1896.             return; // Prevent infinite recursion
1897.         }
1899.         $visited[$oid] = $entity; // mark visited
1901.         // Cascade first, because scheduleForDelete() removes the entity from the identity map, which
1902.         // can cause problems when a lazy proxy has to be initialized for the cascade operation.
1903.         $this->cascadeRemove($entity, $visited);
1905.         $class       = $this->em->getClassMetadata(get_class($entity));
1906.         $entityState = $this->getEntityState($entity);
1908.         switch ($entityState) {
1909.             case self::STATE_NEW:
1910.             case self::STATE_REMOVED:
1911.                 // nothing to do
1912.                 break;
1914.             case self::STATE_MANAGED:
1915.                 $invoke = $this->listenersInvoker->getSubscribedSystems($class, Events::preRemove);
1917.                 if ($invoke !== ListenersInvoker::INVOKE_NONE) {
1918.                     $this->listenersInvoker->invoke($class, Events::preRemove, $entity, new PreRemoveEventArgs($entity, $this->em), $invoke);
1919.                 }
1921.                 $this->scheduleForDelete($entity);
1922.                 break;
1924.             case self::STATE_DETACHED:
1925.                 throw ORMInvalidArgumentException::detachedEntityCannot($entity, 'removed');
1927.             default:
1928.                 throw new UnexpectedValueException(sprintf(
1929.                     'Unexpected entity state: %s. %s',
1930.                     $entityState,
1931.                     self::objToStr($entity)
1932.                 ));
1933.         }
1934.     }
1936.     /**
1937.      * Merges the state of the given detached entity into this UnitOfWork.
1938.      *
1939.      * @deprecated 2.7 This method is being removed from the ORM and won't have any replacement
1940.      *
1941.      * @param object $entity
1942.      *
1943.      * @return object The managed copy of the entity.
1944.      *
1945.      * @throws OptimisticLockException If the entity uses optimistic locking through a version
1946.      *         attribute and the version check against the managed copy fails.
1947.      */
1948.     public function merge($entity)
1949.     {
1950.         $visited = [];
1952.         return $this->doMerge($entity, $visited);
1953.     }
1955.     /**
1956.      * Executes a merge operation on an entity.
1957.      *
1958.      * @param object $entity
1959.      * @psalm-param AssociationMapping|null $assoc
1960.      * @psalm-param array<int, object> $visited
1961.      *
1962.      * @return object The managed copy of the entity.
1963.      *
1964.      * @throws OptimisticLockException If the entity uses optimistic locking through a version
1965.      *         attribute and the version check against the managed copy fails.
1966.      * @throws ORMInvalidArgumentException If the entity instance is NEW.
1967.      * @throws EntityNotFoundException if an assigned identifier is used in the entity, but none is provided.
1968.      */
1969.     private function doMerge(
1970.         $entity,
1971.         array &$visited,
1972.         $prevManagedCopy = null,
1973.         ?array $assoc = null
1974.     ) {
1975.         $oid = spl_object_id($entity);
1977.         if (isset($visited[$oid])) {
1978.             $managedCopy = $visited[$oid];
1980.             if ($prevManagedCopy !== null) {
1981.                 $this->updateAssociationWithMergedEntity($entity, $assoc, $prevManagedCopy, $managedCopy);
1982.             }
1984.             return $managedCopy;
1985.         }
1987.         $class = $this->em->getClassMetadata(get_class($entity));
1989.         // First we assume DETACHED, although it can still be NEW but we can avoid
1990.         // an extra db-roundtrip this way. If it is not MANAGED but has an identity,
1991.         // we need to fetch it from the db anyway in order to merge.
1992.         // MANAGED entities are ignored by the merge operation.
1993.         $managedCopy = $entity;
1995.         if ($this->getEntityState($entity, self::STATE_DETACHED) !== self::STATE_MANAGED) {
1996.             // Try to look the entity up in the identity map.
1997.             $id = $class->getIdentifierValues($entity);
1999.             // If there is no ID, it is actually NEW.
2000.             if (! $id) {
2001.                 $managedCopy = $this->newInstance($class);
2003.                 $this->mergeEntityStateIntoManagedCopy($entity, $managedCopy);
2004.                 $this->persistNew($class, $managedCopy);
2005.             } else {
2006.                 $flatId = $class->containsForeignIdentifier || $class->containsEnumIdentifier
2007.                     ? $this->identifierFlattener->flattenIdentifier($class, $id)
2008.                     : $id;
2010.                 $managedCopy = $this->tryGetById($flatId, $class->rootEntityName);
2012.                 if ($managedCopy) {
2013.                     // We have the entity in-memory already, just make sure its not removed.
2014.                     if ($this->getEntityState($managedCopy) === self::STATE_REMOVED) {
2015.                         throw ORMInvalidArgumentException::entityIsRemoved($managedCopy, 'merge');
2016.                     }
2017.                 } else {
2018.                     // We need to fetch the managed copy in order to merge.
2019.                     $managedCopy = $this->em->find($class->name, $flatId);
2020.                 }
2022.                 if ($managedCopy === null) {
2023.                     // If the identifier is ASSIGNED, it is NEW, otherwise an error
2024.                     // since the managed entity was not found.
2025.                     if (! $class->isIdentifierNatural()) {
2026.                         throw EntityNotFoundException::fromClassNameAndIdentifier(
2027.                             $class->getName(),
2028.                             $this->identifierFlattener->flattenIdentifier($class, $id)
2029.                         );
2030.                     }
2032.                     $managedCopy = $this->newInstance($class);
2033.                     $class->setIdentifierValues($managedCopy, $id);
2035.                     $this->mergeEntityStateIntoManagedCopy($entity, $managedCopy);
2036.                     $this->persistNew($class, $managedCopy);
2037.                 } else {
2038.                     $this->ensureVersionMatch($class, $entity, $managedCopy);
2039.                     $this->mergeEntityStateIntoManagedCopy($entity, $managedCopy);
2040.                 }
2041.             }
2043.             $visited[$oid] = $managedCopy; // mark visited
2045.             if ($class->isChangeTrackingDeferredExplicit()) {
2046.                 $this->scheduleForDirtyCheck($entity);
2047.             }
2048.         }
2050.         if ($prevManagedCopy !== null) {
2051.             $this->updateAssociationWithMergedEntity($entity, $assoc, $prevManagedCopy, $managedCopy);
2052.         }
2054.         // Mark the managed copy visited as well
2055.         $visited[spl_object_id($managedCopy)] = $managedCopy;
2057.         $this->cascadeMerge($entity, $managedCopy, $visited);
2059.         return $managedCopy;
2060.     }
2062.     /**
2063.      * @param object $entity
2064.      * @param object $managedCopy
2065.      * @psalm-param ClassMetadata<T> $class
2066.      * @psalm-param T $entity
2067.      * @psalm-param T $managedCopy
2068.      *
2069.      * @throws OptimisticLockException
2070.      *
2071.      * @template T of object
2072.      */
2073.     private function ensureVersionMatch(
2074.         ClassMetadata $class,
2075.         $entity,
2076.         $managedCopy
2077.     ): void {
2078.         if (! ($class->isVersioned && $this->isLoaded($managedCopy) && $this->isLoaded($entity))) {
2079.             return;
2080.         }
2082.         assert($class->versionField !== null);
2083.         $reflField          = $class->reflFields[$class->versionField];
2084.         $managedCopyVersion = $reflField->getValue($managedCopy);
2085.         $entityVersion      = $reflField->getValue($entity);
2087.         // Throw exception if versions don't match.
2088.         // phpcs:ignore SlevomatCodingStandard.Operators.DisallowEqualOperators.DisallowedEqualOperator
2089.         if ($managedCopyVersion == $entityVersion) {
2090.             return;
2091.         }
2093.         throw OptimisticLockException::lockFailedVersionMismatch($entity, $entityVersion, $managedCopyVersion);
2094.     }
2096.     /**
2097.      * Tests if an entity is loaded - must either be a loaded proxy or not a proxy
2098.      *
2099.      * @param object $entity
2100.      */
2101.     private function isLoaded($entity): bool
2102.     {
2103.         return ! ($entity instanceof Proxy) || $entity->__isInitialized();
2104.     }
2106.     /**
2107.      * Sets/adds associated managed copies into the previous entity's association field
2108.      *
2109.      * @param object $entity
2110.      * @psalm-param AssociationMapping $association
2111.      */
2112.     private function updateAssociationWithMergedEntity(
2113.         $entity,
2114.         array $association,
2115.         $previousManagedCopy,
2116.         $managedCopy
2117.     ): void {
2118.         $assocField = $association['fieldName'];
2119.         $prevClass  = $this->em->getClassMetadata(get_class($previousManagedCopy));
2121.         if ($association['type'] & ClassMetadata::TO_ONE) {
2122.             $prevClass->reflFields[$assocField]->setValue($previousManagedCopy, $managedCopy);
2124.             return;
2125.         }
2127.         $value   = $prevClass->reflFields[$assocField]->getValue($previousManagedCopy);
2128.         $value[] = $managedCopy;
2130.         if ($association['type'] === ClassMetadata::ONE_TO_MANY) {
2131.             $class = $this->em->getClassMetadata(get_class($entity));
2133.             $class->reflFields[$association['mappedBy']]->setValue($managedCopy, $previousManagedCopy);
2134.         }
2135.     }
2137.     /**
2138.      * Detaches an entity from the persistence management. It's persistence will
2139.      * no longer be managed by Doctrine.
2140.      *
2141.      * @param object $entity The entity to detach.
2142.      *
2143.      * @return void
2144.      */
2145.     public function detach($entity)
2146.     {
2147.         $visited = [];
2149.         $this->doDetach($entity, $visited);
2150.     }
2152.     /**
2153.      * Executes a detach operation on the given entity.
2154.      *
2155.      * @param object  $entity
2156.      * @param mixed[] $visited
2157.      * @param bool    $noCascade if true, don't cascade detach operation.
2158.      */
2159.     private function doDetach(
2160.         $entity,
2161.         array &$visited,
2162.         bool $noCascade = false
2163.     ): void {
2164.         $oid = spl_object_id($entity);
2166.         if (isset($visited[$oid])) {
2167.             return; // Prevent infinite recursion
2168.         }
2170.         $visited[$oid] = $entity; // mark visited
2172.         switch ($this->getEntityState($entity, self::STATE_DETACHED)) {
2173.             case self::STATE_MANAGED:
2174.                 if ($this->isInIdentityMap($entity)) {
2175.                     $this->removeFromIdentityMap($entity);
2176.                 }
2178.                 unset(
2179.                     $this->entityInsertions[$oid],
2180.                     $this->entityUpdates[$oid],
2181.                     $this->entityDeletions[$oid],
2182.                     $this->entityIdentifiers[$oid],
2183.                     $this->entityStates[$oid],
2184.                     $this->originalEntityData[$oid]
2185.                 );
2186.                 break;
2187.             case self::STATE_NEW:
2188.             case self::STATE_DETACHED:
2189.                 return;
2190.         }
2192.         if (! $noCascade) {
2193.             $this->cascadeDetach($entity, $visited);
2194.         }
2195.     }
2197.     /**
2198.      * Refreshes the state of the given entity from the database, overwriting
2199.      * any local, unpersisted changes.
2200.      *
2201.      * @param object $entity The entity to refresh
2202.      *
2203.      * @return void
2204.      *
2205.      * @throws InvalidArgumentException If the entity is not MANAGED.
2206.      * @throws TransactionRequiredException
2207.      */
2208.     public function refresh($entity)
2209.     {
2210.         $visited = [];
2212.         $lockMode = null;
2214.         if (func_num_args() > 1) {
2215.             $lockMode = func_get_arg(1);
2216.         }
2218.         $this->doRefresh($entity, $visited, $lockMode);
2219.     }
2221.     /**
2222.      * Executes a refresh operation on an entity.
2223.      *
2224.      * @param object $entity The entity to refresh.
2225.      * @psalm-param array<int, object>  $visited The already visited entities during cascades.
2226.      * @psalm-param LockMode::*|null $lockMode
2227.      *
2228.      * @throws ORMInvalidArgumentException If the entity is not MANAGED.
2229.      * @throws TransactionRequiredException
2230.      */
2231.     private function doRefresh($entity, array &$visited, ?int $lockMode = null): void
2232.     {
2233.         switch (true) {
2234.             case $lockMode === LockMode::PESSIMISTIC_READ:
2235.             case $lockMode === LockMode::PESSIMISTIC_WRITE:
2236.                 if (! $this->em->getConnection()->isTransactionActive()) {
2237.                     throw TransactionRequiredException::transactionRequired();
2238.                 }
2239.         }
2241.         $oid = spl_object_id($entity);
2243.         if (isset($visited[$oid])) {
2244.             return; // Prevent infinite recursion
2245.         }
2247.         $visited[$oid] = $entity; // mark visited
2249.         $class = $this->em->getClassMetadata(get_class($entity));
2251.         if ($this->getEntityState($entity) !== self::STATE_MANAGED) {
2252.             throw ORMInvalidArgumentException::entityNotManaged($entity);
2253.         }
2255.         $this->getEntityPersister($class->name)->refresh(
2256.             array_combine($class->getIdentifierFieldNames(), $this->entityIdentifiers[$oid]),
2257.             $entity,
2258.             $lockMode
2259.         );
2261.         $this->cascadeRefresh($entity, $visited, $lockMode);
2262.     }
2264.     /**
2265.      * Cascades a refresh operation to associated entities.
2266.      *
2267.      * @param object $entity
2268.      * @psalm-param array<int, object> $visited
2269.      * @psalm-param LockMode::*|null $lockMode
2270.      */
2271.     private function cascadeRefresh($entity, array &$visited, ?int $lockMode = null): void
2272.     {
2273.         $class = $this->em->getClassMetadata(get_class($entity));
2275.         $associationMappings = array_filter(
2276.             $class->associationMappings,
2277.             static function ($assoc) {
2278.                 return $assoc['isCascadeRefresh'];
2279.             }
2280.         );
2282.         foreach ($associationMappings as $assoc) {
2283.             $relatedEntities = $class->reflFields[$assoc['fieldName']]->getValue($entity);
2285.             switch (true) {
2286.                 case $relatedEntities instanceof PersistentCollection:
2287.                     // Unwrap so that foreach() does not initialize
2288.                     $relatedEntities = $relatedEntities->unwrap();
2289.                     // break; is commented intentionally!
2291.                 case $relatedEntities instanceof Collection:
2292.                 case is_array($relatedEntities):
2293.                     foreach ($relatedEntities as $relatedEntity) {
2294.                         $this->doRefresh($relatedEntity, $visited, $lockMode);
2295.                     }
2297.                     break;
2299.                 case $relatedEntities !== null:
2300.                     $this->doRefresh($relatedEntities, $visited, $lockMode);
2301.                     break;
2303.                 default:
2304.                     // Do nothing
2305.             }
2306.         }
2307.     }
2309.     /**
2310.      * Cascades a detach operation to associated entities.
2311.      *
2312.      * @param object             $entity
2313.      * @param array<int, object> $visited
2314.      */
2315.     private function cascadeDetach($entity, array &$visited): void
2316.     {
2317.         $class = $this->em->getClassMetadata(get_class($entity));
2319.         $associationMappings = array_filter(
2320.             $class->associationMappings,
2321.             static function ($assoc) {
2322.                 return $assoc['isCascadeDetach'];
2323.             }
2324.         );
2326.         foreach ($associationMappings as $assoc) {
2327.             $relatedEntities = $class->reflFields[$assoc['fieldName']]->getValue($entity);
2329.             switch (true) {
2330.                 case $relatedEntities instanceof PersistentCollection:
2331.                     // Unwrap so that foreach() does not initialize
2332.                     $relatedEntities = $relatedEntities->unwrap();
2333.                     // break; is commented intentionally!
2335.                 case $relatedEntities instanceof Collection:
2336.                 case is_array($relatedEntities):
2337.                     foreach ($relatedEntities as $relatedEntity) {
2338.                         $this->doDetach($relatedEntity, $visited);
2339.                     }
2341.                     break;
2343.                 case $relatedEntities !== null:
2344.                     $this->doDetach($relatedEntities, $visited);
2345.                     break;
2347.                 default:
2348.                     // Do nothing
2349.             }
2350.         }
2351.     }
2353.     /**
2354.      * Cascades a merge operation to associated entities.
2355.      *
2356.      * @param object $entity
2357.      * @param object $managedCopy
2358.      * @psalm-param array<int, object> $visited
2359.      */
2360.     private function cascadeMerge($entity, $managedCopy, array &$visited): void
2361.     {
2362.         $class = $this->em->getClassMetadata(get_class($entity));
2364.         $associationMappings = array_filter(
2365.             $class->associationMappings,
2366.             static function ($assoc) {
2367.                 return $assoc['isCascadeMerge'];
2368.             }
2369.         );
2371.         foreach ($associationMappings as $assoc) {
2372.             $relatedEntities = $class->reflFields[$assoc['fieldName']]->getValue($entity);
2374.             if ($relatedEntities instanceof Collection) {
2375.                 if ($relatedEntities === $class->reflFields[$assoc['fieldName']]->getValue($managedCopy)) {
2376.                     continue;
2377.                 }
2379.                 if ($relatedEntities instanceof PersistentCollection) {
2380.                     // Unwrap so that foreach() does not initialize
2381.                     $relatedEntities = $relatedEntities->unwrap();
2382.                 }
2384.                 foreach ($relatedEntities as $relatedEntity) {
2385.                     $this->doMerge($relatedEntity, $visited, $managedCopy, $assoc);
2386.                 }
2387.             } elseif ($relatedEntities !== null) {
2388.                 $this->doMerge($relatedEntities, $visited, $managedCopy, $assoc);
2389.             }
2390.         }
2391.     }
2393.     /**
2394.      * Cascades the save operation to associated entities.
2395.      *
2396.      * @param object $entity
2397.      * @psalm-param array<int, object> $visited
2398.      */
2399.     private function cascadePersist($entity, array &$visited): void
2400.     {
2401.         if ($entity instanceof Proxy && ! $entity->__isInitialized()) {
2402.             // nothing to do - proxy is not initialized, therefore we don't do anything with it
2403.             return;
2404.         }
2406.         $class = $this->em->getClassMetadata(get_class($entity));
2408.         $associationMappings = array_filter(
2409.             $class->associationMappings,
2410.             static function ($assoc) {
2411.                 return $assoc['isCascadePersist'];
2412.             }
2413.         );
2415.         foreach ($associationMappings as $assoc) {
2416.             $relatedEntities = $class->reflFields[$assoc['fieldName']]->getValue($entity);
2418.             switch (true) {
2419.                 case $relatedEntities instanceof PersistentCollection:
2420.                     // Unwrap so that foreach() does not initialize
2421.                     $relatedEntities = $relatedEntities->unwrap();
2422.                     // break; is commented intentionally!
2424.                 case $relatedEntities instanceof Collection:
2425.                 case is_array($relatedEntities):
2426.                     if (($assoc['type'] & ClassMetadata::TO_MANY) <= 0) {
2427.                         throw ORMInvalidArgumentException::invalidAssociation(
2428.                             $this->em->getClassMetadata($assoc['targetEntity']),
2429.                             $assoc,
2430.                             $relatedEntities
2431.                         );
2432.                     }
2434.                     foreach ($relatedEntities as $relatedEntity) {
2435.                         $this->doPersist($relatedEntity, $visited);
2436.                     }
2438.                     break;
2440.                 case $relatedEntities !== null:
2441.                     if (! $relatedEntities instanceof $assoc['targetEntity']) {
2442.                         throw ORMInvalidArgumentException::invalidAssociation(
2443.                             $this->em->getClassMetadata($assoc['targetEntity']),
2444.                             $assoc,
2445.                             $relatedEntities
2446.                         );
2447.                     }
2449.                     $this->doPersist($relatedEntities, $visited);
2450.                     break;
2452.                 default:
2453.                     // Do nothing
2454.             }
2455.         }
2456.     }
2458.     /**
2459.      * Cascades the delete operation to associated entities.
2460.      *
2461.      * @param object $entity
2462.      * @psalm-param array<int, object> $visited
2463.      */
2464.     private function cascadeRemove($entity, array &$visited): void
2465.     {
2466.         $class = $this->em->getClassMetadata(get_class($entity));
2468.         $associationMappings = array_filter(
2469.             $class->associationMappings,
2470.             static function ($assoc) {
2471.                 return $assoc['isCascadeRemove'];
2472.             }
2473.         );
2475.         $entitiesToCascade = [];
2477.         foreach ($associationMappings as $assoc) {
2478.             if ($entity instanceof Proxy && ! $entity->__isInitialized()) {
2479.                 $entity->__load();
2480.             }
2482.             $relatedEntities = $class->reflFields[$assoc['fieldName']]->getValue($entity);
2484.             switch (true) {
2485.                 case $relatedEntities instanceof Collection:
2486.                 case is_array($relatedEntities):
2487.                     // If its a PersistentCollection initialization is intended! No unwrap!
2488.                     foreach ($relatedEntities as $relatedEntity) {
2489.                         $entitiesToCascade[] = $relatedEntity;
2490.                     }
2492.                     break;
2494.                 case $relatedEntities !== null:
2495.                     $entitiesToCascade[] = $relatedEntities;
2496.                     break;
2498.                 default:
2499.                     // Do nothing
2500.             }
2501.         }
2503.         foreach ($entitiesToCascade as $relatedEntity) {
2504.             $this->doRemove($relatedEntity, $visited);
2505.         }
2506.     }
2508.     /**
2509.      * Acquire a lock on the given entity.
2510.      *
2511.      * @param object                     $entity
2512.      * @param int|DateTimeInterface|null $lockVersion
2513.      * @psalm-param LockMode::* $lockMode
2514.      *
2515.      * @throws ORMInvalidArgumentException
2516.      * @throws TransactionRequiredException
2517.      * @throws OptimisticLockException
2518.      */
2519.     public function lock($entity, int $lockMode, $lockVersion = null): void
2520.     {
2521.         if ($this->getEntityState($entity, self::STATE_DETACHED) !== self::STATE_MANAGED) {
2522.             throw ORMInvalidArgumentException::entityNotManaged($entity);
2523.         }
2525.         $class = $this->em->getClassMetadata(get_class($entity));
2527.         switch (true) {
2528.             case $lockMode === LockMode::OPTIMISTIC:
2529.                 if (! $class->isVersioned) {
2530.                     throw OptimisticLockException::notVersioned($class->name);
2531.                 }
2533.                 if ($lockVersion === null) {
2534.                     return;
2535.                 }
2537.                 if ($entity instanceof Proxy && ! $entity->__isInitialized()) {
2538.                     $entity->__load();
2539.                 }
2541.                 assert($class->versionField !== null);
2542.                 $entityVersion = $class->reflFields[$class->versionField]->getValue($entity);
2544.                 // phpcs:ignore SlevomatCodingStandard.Operators.DisallowEqualOperators.DisallowedNotEqualOperator
2545.                 if ($entityVersion != $lockVersion) {
2546.                     throw OptimisticLockException::lockFailedVersionMismatch($entity, $lockVersion, $entityVersion);
2547.                 }
2549.                 break;
2551.             case $lockMode === LockMode::NONE:
2552.             case $lockMode === LockMode::PESSIMISTIC_READ:
2553.             case $lockMode === LockMode::PESSIMISTIC_WRITE:
2554.                 if (! $this->em->getConnection()->isTransactionActive()) {
2555.                     throw TransactionRequiredException::transactionRequired();
2556.                 }
2558.                 $oid = spl_object_id($entity);
2560.                 $this->getEntityPersister($class->name)->lock(
2561.                     array_combine($class->getIdentifierFieldNames(), $this->entityIdentifiers[$oid]),
2562.                     $lockMode
2563.                 );
2564.                 break;
2566.             default:
2567.                 // Do nothing
2568.         }
2569.     }
2571.     /**
2572.      * Gets the CommitOrderCalculator used by the UnitOfWork to order commits.
2573.      *
2574.      * @return CommitOrderCalculator
2575.      */
2576.     public function getCommitOrderCalculator()
2577.     {
2578.         return new Internal\CommitOrderCalculator();
2579.     }
2581.     /**
2582.      * Clears the UnitOfWork.
2583.      *
2584.      * @param string|null $entityName if given, only entities of this type will get detached.
2585.      *
2586.      * @return void
2587.      *
2588.      * @throws ORMInvalidArgumentException if an invalid entity name is given.
2589.      */
2590.     public function clear($entityName = null)
2591.     {
2592.         if ($entityName === null) {
2593.             $this->identityMap                    =
2594.             $this->entityIdentifiers              =
2595.             $this->originalEntityData             =
2596.             $this->entityChangeSets               =
2597.             $this->entityStates                   =
2598.             $this->scheduledForSynchronization    =
2599.             $this->entityInsertions               =
2600.             $this->entityUpdates                  =
2601.             $this->entityDeletions                =
2602.             $this->nonCascadedNewDetectedEntities =
2603.             $this->collectionDeletions            =
2604.             $this->collectionUpdates              =
2605.             $this->extraUpdates                   =
2606.             $this->readOnlyObjects                =
2607.             $this->visitedCollections             =
2608.             $this->eagerLoadingEntities           =
2609.             $this->orphanRemovals                 = [];
2610.         } else {
2611.             Deprecation::triggerIfCalledFromOutside(
2612.                 'doctrine/orm',
2613.                 'https://github.com/doctrine/orm/issues/8460',
2614.                 'Calling %s() with any arguments to clear specific entities is deprecated and will not be supported in Doctrine ORM 3.0.',
2615.                 __METHOD__
2616.             );
2618.             $this->clearIdentityMapForEntityName($entityName);
2619.             $this->clearEntityInsertionsForEntityName($entityName);
2620.         }
2622.         if ($this->evm->hasListeners(Events::onClear)) {
2623.             $this->evm->dispatchEvent(Events::onClear, new Event\OnClearEventArgs($this->em, $entityName));
2624.         }
2625.     }
2627.     /**
2628.      * INTERNAL:
2629.      * Schedules an orphaned entity for removal. The remove() operation will be
2630.      * invoked on that entity at the beginning of the next commit of this
2631.      * UnitOfWork.
2632.      *
2633.      * @param object $entity
2634.      *
2635.      * @return void
2636.      *
2637.      * @ignore
2638.      */
2639.     public function scheduleOrphanRemoval($entity)
2640.     {
2641.         $this->orphanRemovals[spl_object_id($entity)] = $entity;
2642.     }
2644.     /**
2645.      * INTERNAL:
2646.      * Cancels a previously scheduled orphan removal.
2647.      *
2648.      * @param object $entity
2649.      *
2650.      * @return void
2651.      *
2652.      * @ignore
2653.      */
2654.     public function cancelOrphanRemoval($entity)
2655.     {
2656.         unset($this->orphanRemovals[spl_object_id($entity)]);
2657.     }
2659.     /**
2660.      * INTERNAL:
2661.      * Schedules a complete collection for removal when this UnitOfWork commits.
2662.      *
2663.      * @return void
2664.      */
2665.     public function scheduleCollectionDeletion(PersistentCollection $coll)
2666.     {
2667.         $coid = spl_object_id($coll);
2669.         // TODO: if $coll is already scheduled for recreation ... what to do?
2670.         // Just remove $coll from the scheduled recreations?
2671.         unset($this->collectionUpdates[$coid]);
2673.         $this->collectionDeletions[$coid] = $coll;
2674.     }
2676.     /** @return bool */
2677.     public function isCollectionScheduledForDeletion(PersistentCollection $coll)
2678.     {
2679.         return isset($this->collectionDeletions[spl_object_id($coll)]);
2680.     }
2682.     /** @return object */
2683.     private function newInstance(ClassMetadata $class)
2684.     {
2685.         $entity = $class->newInstance();
2687.         if ($entity instanceof ObjectManagerAware) {
2688.             $entity->injectObjectManager($this->em, $class);
2689.         }
2691.         return $entity;
2692.     }
2694.     /**
2695.      * INTERNAL:
2696.      * Creates an entity. Used for reconstitution of persistent entities.
2697.      *
2698.      * Internal note: Highly performance-sensitive method.
2699.      *
2700.      * @param string  $className The name of the entity class.
2701.      * @param mixed[] $data      The data for the entity.
2702.      * @param mixed[] $hints     Any hints to account for during reconstitution/lookup of the entity.
2703.      * @psalm-param class-string $className
2704.      * @psalm-param array<string, mixed> $hints
2705.      *
2706.      * @return object The managed entity instance.
2707.      *
2708.      * @ignore
2709.      * @todo Rename: getOrCreateEntity
2710.      */
2711.     public function createEntity($className, array $data, &$hints = [])
2712.     {
2713.         $class = $this->em->getClassMetadata($className);
2715.         $id     = $this->identifierFlattener->flattenIdentifier($class, $data);
2716.         $idHash = implode(' ', $id);
2718.         if (isset($this->identityMap[$class->rootEntityName][$idHash])) {
2719.             $entity = $this->identityMap[$class->rootEntityName][$idHash];
2720.             $oid    = spl_object_id($entity);
2722.             if (
2723.                 isset($hints[Query::HINT_REFRESH], $hints[Query::HINT_REFRESH_ENTITY])
2724.             ) {
2725.                 $unmanagedProxy = $hints[Query::HINT_REFRESH_ENTITY];
2726.                 if (
2727.                     $unmanagedProxy !== $entity
2728.                     && $unmanagedProxy instanceof Proxy
2729.                     && $this->isIdentifierEquals($unmanagedProxy, $entity)
2730.                 ) {
2731.                     // We will hydrate the given un-managed proxy anyway:
2732.                     // continue work, but consider it the entity from now on
2733.                     $entity = $unmanagedProxy;
2734.                 }
2735.             }
2737.             if ($entity instanceof Proxy && ! $entity->__isInitialized()) {
2738.                 $entity->__setInitialized(true);
2739.             } else {
2740.                 if (
2741.                     ! isset($hints[Query::HINT_REFRESH])
2742.                     || (isset($hints[Query::HINT_REFRESH_ENTITY]) && $hints[Query::HINT_REFRESH_ENTITY] !== $entity)
2743.                 ) {
2744.                     return $entity;
2745.                 }
2746.             }
2748.             // inject ObjectManager upon refresh.
2749.             if ($entity instanceof ObjectManagerAware) {
2750.                 $entity->injectObjectManager($this->em, $class);
2751.             }
2753.             $this->originalEntityData[$oid] = $data;
2754.         } else {
2755.             $entity = $this->newInstance($class);
2756.             $oid    = spl_object_id($entity);
2758.             $this->entityIdentifiers[$oid]  = $id;
2759.             $this->entityStates[$oid]       = self::STATE_MANAGED;
2760.             $this->originalEntityData[$oid] = $data;
2762.             $this->identityMap[$class->rootEntityName][$idHash] = $entity;
2764.             if (isset($hints[Query::HINT_READ_ONLY])) {
2765.                 $this->readOnlyObjects[$oid] = true;
2766.             }
2767.         }
2769.         if ($entity instanceof NotifyPropertyChanged) {
2770.             $entity->addPropertyChangedListener($this);
2771.         }
2773.         foreach ($data as $field => $value) {
2774.             if (isset($class->fieldMappings[$field])) {
2775.                 $class->reflFields[$field]->setValue($entity, $value);
2776.             }
2777.         }
2779.         // Loading the entity right here, if its in the eager loading map get rid of it there.
2780.         unset($this->eagerLoadingEntities[$class->rootEntityName][$idHash]);
2782.         if (isset($this->eagerLoadingEntities[$class->rootEntityName]) && ! $this->eagerLoadingEntities[$class->rootEntityName]) {
2783.             unset($this->eagerLoadingEntities[$class->rootEntityName]);
2784.         }
2786.         // Properly initialize any unfetched associations, if partial objects are not allowed.
2787.         if (isset($hints[Query::HINT_FORCE_PARTIAL_LOAD])) {
2788.             Deprecation::trigger(
2789.                 'doctrine/orm',
2790.                 'https://github.com/doctrine/orm/issues/8471',
2791.                 'Partial Objects are deprecated (here entity %s)',
2792.                 $className
2793.             );
2795.             return $entity;
2796.         }
2798.         foreach ($class->associationMappings as $field => $assoc) {
2799.             // Check if the association is not among the fetch-joined associations already.
2800.             if (isset($hints['fetchAlias'], $hints['fetched'][$hints['fetchAlias']][$field])) {
2801.                 continue;
2802.             }
2804.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
2806.             switch (true) {
2807.                 case $assoc['type'] & ClassMetadata::TO_ONE:
2808.                     if (! $assoc['isOwningSide']) {
2809.                         // use the given entity association
2810.                         if (isset($data[$field]) && is_object($data[$field]) && isset($this->entityStates[spl_object_id($data[$field])])) {
2811.                             $this->originalEntityData[$oid][$field] = $data[$field];
2813.                             $class->reflFields[$field]->setValue($entity, $data[$field]);
2814.                             $targetClass->reflFields[$assoc['mappedBy']]->setValue($data[$field], $entity);
2816.                             continue 2;
2817.                         }
2819.                         // Inverse side of x-to-one can never be lazy
2820.                         $class->reflFields[$field]->setValue($entity, $this->getEntityPersister($assoc['targetEntity'])->loadOneToOneEntity($assoc, $entity));
2822.                         continue 2;
2823.                     }
2825.                     // use the entity association
2826.                     if (isset($data[$field]) && is_object($data[$field]) && isset($this->entityStates[spl_object_id($data[$field])])) {
2827.                         $class->reflFields[$field]->setValue($entity, $data[$field]);
2828.                         $this->originalEntityData[$oid][$field] = $data[$field];
2830.                         break;
2831.                     }
2833.                     $associatedId = [];
2835.                     // TODO: Is this even computed right in all cases of composite keys?
2836.                     foreach ($assoc['targetToSourceKeyColumns'] as $targetColumn => $srcColumn) {
2837.                         $joinColumnValue = $data[$srcColumn] ?? null;
2839.                         if ($joinColumnValue !== null) {
2840.                             if ($joinColumnValue instanceof BackedEnum) {
2841.                                 $joinColumnValue = $joinColumnValue->value;
2842.                             }
2844.                             if ($targetClass->containsForeignIdentifier) {
2845.                                 $associatedId[$targetClass->getFieldForColumn($targetColumn)] = $joinColumnValue;
2846.                             } else {
2847.                                 $associatedId[$targetClass->fieldNames[$targetColumn]] = $joinColumnValue;
2848.                             }
2849.                         } elseif (
2850.                             $targetClass->containsForeignIdentifier
2851.                             && in_array($targetClass->getFieldForColumn($targetColumn), $targetClass->identifier, true)
2852.                         ) {
2853.                             // the missing key is part of target's entity primary key
2854.                             $associatedId = [];
2855.                             break;
2856.                         }
2857.                     }
2859.                     if (! $associatedId) {
2860.                         // Foreign key is NULL
2861.                         $class->reflFields[$field]->setValue($entity, null);
2862.                         $this->originalEntityData[$oid][$field] = null;
2864.                         break;
2865.                     }
2867.                     if (! isset($hints['fetchMode'][$class->name][$field])) {
2868.                         $hints['fetchMode'][$class->name][$field] = $assoc['fetch'];
2869.                     }
2871.                     // Foreign key is set
2872.                     // Check identity map first
2873.                     // FIXME: Can break easily with composite keys if join column values are in
2874.                     //        wrong order. The correct order is the one in ClassMetadata#identifier.
2875.                     $relatedIdHash = implode(' ', $associatedId);
2877.                     switch (true) {
2878.                         case isset($this->identityMap[$targetClass->rootEntityName][$relatedIdHash]):
2879.                             $newValue = $this->identityMap[$targetClass->rootEntityName][$relatedIdHash];
2881.                             // If this is an uninitialized proxy, we are deferring eager loads,
2882.                             // this association is marked as eager fetch, and its an uninitialized proxy (wtf!)
2883.                             // then we can append this entity for eager loading!
2884.                             if (
2885.                                 $hints['fetchMode'][$class->name][$field] === ClassMetadata::FETCH_EAGER &&
2886.                                 isset($hints[self::HINT_DEFEREAGERLOAD]) &&
2887.                                 ! $targetClass->isIdentifierComposite &&
2888.                                 $newValue instanceof Proxy &&
2889.                                 $newValue->__isInitialized() === false
2890.                             ) {
2891.                                 $this->eagerLoadingEntities[$targetClass->rootEntityName][$relatedIdHash] = current($associatedId);
2892.                             }
2894.                             break;
2896.                         case $targetClass->subClasses:
2897.                             // If it might be a subtype, it can not be lazy. There isn't even
2898.                             // a way to solve this with deferred eager loading, which means putting
2899.                             // an entity with subclasses at a *-to-one location is really bad! (performance-wise)
2900.                             $newValue = $this->getEntityPersister($assoc['targetEntity'])->loadOneToOneEntity($assoc, $entity, $associatedId);
2901.                             break;
2903.                         default:
2904.                             $normalizedAssociatedId = $this->normalizeIdentifier($targetClass, $associatedId);
2906.                             switch (true) {
2907.                                 // We are negating the condition here. Other cases will assume it is valid!
2908.                                 case $hints['fetchMode'][$class->name][$field] !== ClassMetadata::FETCH_EAGER:
2909.                                     $newValue = $this->em->getProxyFactory()->getProxy($assoc['targetEntity'], $normalizedAssociatedId);
2910.                                     break;
2912.                                 // Deferred eager load only works for single identifier classes
2913.                                 case isset($hints[self::HINT_DEFEREAGERLOAD]) && ! $targetClass->isIdentifierComposite:
2914.                                     // TODO: Is there a faster approach?
2915.                                     $this->eagerLoadingEntities[$targetClass->rootEntityName][$relatedIdHash] = current($normalizedAssociatedId);
2917.                                     $newValue = $this->em->getProxyFactory()->getProxy($assoc['targetEntity'], $normalizedAssociatedId);
2918.                                     break;
2920.                                 default:
2921.                                     // TODO: This is very imperformant, ignore it?
2922.                                     $newValue = $this->em->find($assoc['targetEntity'], $normalizedAssociatedId);
2923.                                     break;
2924.                             }
2926.                             if ($newValue === null) {
2927.                                 break;
2928.                             }
2930.                             // PERF: Inlined & optimized code from UnitOfWork#registerManaged()
2931.                             $newValueOid                                                     = spl_object_id($newValue);
2932.                             $this->entityIdentifiers[$newValueOid]                           = $associatedId;
2933.                             $this->identityMap[$targetClass->rootEntityName][$relatedIdHash] = $newValue;
2935.                             if (
2936.                                 $newValue instanceof NotifyPropertyChanged &&
2937.                                 ( ! $newValue instanceof Proxy || $newValue->__isInitialized())
2938.                             ) {
2939.                                 $newValue->addPropertyChangedListener($this);
2940.                             }
2942.                             $this->entityStates[$newValueOid] = self::STATE_MANAGED;
2943.                             // make sure that when an proxy is then finally loaded, $this->originalEntityData is set also!
2944.                             break;
2945.                     }
2947.                     $this->originalEntityData[$oid][$field] = $newValue;
2948.                     $class->reflFields[$field]->setValue($entity, $newValue);
2950.                     if ($assoc['inversedBy'] && $assoc['type'] & ClassMetadata::ONE_TO_ONE && $newValue !== null) {
2951.                         $inverseAssoc = $targetClass->associationMappings[$assoc['inversedBy']];
2952.                         $targetClass->reflFields[$inverseAssoc['fieldName']]->setValue($newValue, $entity);
2953.                     }
2955.                     break;
2957.                 default:
2958.                     // Ignore if its a cached collection
2959.                     if (isset($hints[Query::HINT_CACHE_ENABLED]) && $class->getFieldValue($entity, $field) instanceof PersistentCollection) {
2960.                         break;
2961.                     }
2963.                     // use the given collection
2964.                     if (isset($data[$field]) && $data[$field] instanceof PersistentCollection) {
2965.                         $data[$field]->setOwner($entity, $assoc);
2967.                         $class->reflFields[$field]->setValue($entity, $data[$field]);
2968.                         $this->originalEntityData[$oid][$field] = $data[$field];
2970.                         break;
2971.                     }
2973.                     // Inject collection
2974.                     $pColl = new PersistentCollection($this->em, $targetClass, new ArrayCollection());
2975.                     $pColl->setOwner($entity, $assoc);
2976.                     $pColl->setInitialized(false);
2978.                     $reflField = $class->reflFields[$field];
2979.                     $reflField->setValue($entity, $pColl);
2981.                     if ($assoc['fetch'] === ClassMetadata::FETCH_EAGER) {
2982.                         $this->loadCollection($pColl);
2983.                         $pColl->takeSnapshot();
2984.                     }
2986.                     $this->originalEntityData[$oid][$field] = $pColl;
2987.                     break;
2988.             }
2989.         }
2991.         // defer invoking of postLoad event to hydration complete step
2992.         $this->hydrationCompleteHandler->deferPostLoadInvoking($class, $entity);
2994.         return $entity;
2995.     }
2997.     /** @return void */
2998.     public function triggerEagerLoads()
2999.     {
3000.         if (! $this->eagerLoadingEntities) {
3001.             return;
3002.         }
3004.         // avoid infinite recursion
3005.         $eagerLoadingEntities       = $this->eagerLoadingEntities;
3006.         $this->eagerLoadingEntities = [];
3008.         foreach ($eagerLoadingEntities as $entityName => $ids) {
3009.             if (! $ids) {
3010.                 continue;
3011.             }
3013.             $class = $this->em->getClassMetadata($entityName);
3015.             $this->getEntityPersister($entityName)->loadAll(
3016.                 array_combine($class->identifier, [array_values($ids)])
3017.             );
3018.         }
3019.     }
3021.     /**
3022.      * Initializes (loads) an uninitialized persistent collection of an entity.
3023.      *
3024.      * @param PersistentCollection $collection The collection to initialize.
3025.      *
3026.      * @return void
3027.      *
3028.      * @todo Maybe later move to EntityManager#initialize($proxyOrCollection). See DDC-733.
3029.      */
3030.     public function loadCollection(PersistentCollection $collection)
3031.     {
3032.         $assoc     = $collection->getMapping();
3033.         $persister = $this->getEntityPersister($assoc['targetEntity']);
3035.         switch ($assoc['type']) {
3036.             case ClassMetadata::ONE_TO_MANY:
3037.                 $persister->loadOneToManyCollection($assoc, $collection->getOwner(), $collection);
3038.                 break;
3040.             case ClassMetadata::MANY_TO_MANY:
3041.                 $persister->loadManyToManyCollection($assoc, $collection->getOwner(), $collection);
3042.                 break;
3043.         }
3045.         $collection->setInitialized(true);
3046.     }
3048.     /**
3049.      * Gets the identity map of the UnitOfWork.
3050.      *
3051.      * @psalm-return array<class-string, array<string, object|null>>
3052.      */
3053.     public function getIdentityMap()
3054.     {
3055.         return $this->identityMap;
3056.     }
3058.     /**
3059.      * Gets the original data of an entity. The original data is the data that was
3060.      * present at the time the entity was reconstituted from the database.
3061.      *
3062.      * @param object $entity
3063.      *
3064.      * @return mixed[]
3065.      * @psalm-return array<string, mixed>
3066.      */
3067.     public function getOriginalEntityData($entity)
3068.     {
3069.         $oid = spl_object_id($entity);
3071.         return $this->originalEntityData[$oid] ?? [];
3072.     }
3074.     /**
3075.      * @param object  $entity
3076.      * @param mixed[] $data
3077.      *
3078.      * @return void
3079.      *
3080.      * @ignore
3081.      */
3082.     public function setOriginalEntityData($entity, array $data)
3083.     {
3084.         $this->originalEntityData[spl_object_id($entity)] = $data;
3085.     }
3087.     /**
3088.      * INTERNAL:
3089.      * Sets a property value of the original data array of an entity.
3090.      *
3091.      * @param int    $oid
3092.      * @param string $property
3093.      * @param mixed  $value
3094.      *
3095.      * @return void
3096.      *
3097.      * @ignore
3098.      */
3099.     public function setOriginalEntityProperty($oid, $property, $value)
3100.     {
3101.         $this->originalEntityData[$oid][$property] = $value;
3102.     }
3104.     /**
3105.      * Gets the identifier of an entity.
3106.      * The returned value is always an array of identifier values. If the entity
3107.      * has a composite identifier then the identifier values are in the same
3108.      * order as the identifier field names as returned by ClassMetadata#getIdentifierFieldNames().
3109.      *
3110.      * @param object $entity
3111.      *
3112.      * @return mixed[] The identifier values.
3113.      */
3114.     public function getEntityIdentifier($entity)
3115.     {
3116.         if (! isset($this->entityIdentifiers[spl_object_id($entity)])) {
3117.             throw EntityNotFoundException::noIdentifierFound(get_debug_type($entity));
3118.         }
3120.         return $this->entityIdentifiers[spl_object_id($entity)];
3121.     }
3123.     /**
3124.      * Processes an entity instance to extract their identifier values.
3125.      *
3126.      * @param object $entity The entity instance.
3127.      *
3128.      * @return mixed A scalar value.
3129.      *
3130.      * @throws ORMInvalidArgumentException
3131.      */
3132.     public function getSingleIdentifierValue($entity)
3133.     {
3134.         $class = $this->em->getClassMetadata(get_class($entity));
3136.         if ($class->isIdentifierComposite) {
3137.             throw ORMInvalidArgumentException::invalidCompositeIdentifier();
3138.         }
3140.         $values = $this->isInIdentityMap($entity)
3141.             ? $this->getEntityIdentifier($entity)
3142.             : $class->getIdentifierValues($entity);
3144.         return $values[$class->identifier[0]] ?? null;
3145.     }
3147.     /**
3148.      * Tries to find an entity with the given identifier in the identity map of
3149.      * this UnitOfWork.
3150.      *
3151.      * @param mixed  $id            The entity identifier to look for.
3152.      * @param string $rootClassName The name of the root class of the mapped entity hierarchy.
3153.      * @psalm-param class-string $rootClassName
3154.      *
3155.      * @return object|false Returns the entity with the specified identifier if it exists in
3156.      *                      this UnitOfWork, FALSE otherwise.
3157.      */
3158.     public function tryGetById($id, $rootClassName)
3159.     {
3160.         $idHash = implode(' ', (array) $id);
3162.         return $this->identityMap[$rootClassName][$idHash] ?? false;
3163.     }
3165.     /**
3166.      * Schedules an entity for dirty-checking at commit-time.
3167.      *
3168.      * @param object $entity The entity to schedule for dirty-checking.
3169.      *
3170.      * @return void
3171.      *
3172.      * @todo Rename: scheduleForSynchronization
3173.      */
3174.     public function scheduleForDirtyCheck($entity)
3175.     {
3176.         $rootClassName = $this->em->getClassMetadata(get_class($entity))->rootEntityName;
3178.         $this->scheduledForSynchronization[$rootClassName][spl_object_id($entity)] = $entity;
3179.     }
3181.     /**
3182.      * Checks whether the UnitOfWork has any pending insertions.
3183.      *
3184.      * @return bool TRUE if this UnitOfWork has pending insertions, FALSE otherwise.
3185.      */
3186.     public function hasPendingInsertions()
3187.     {
3188.         return ! empty($this->entityInsertions);
3189.     }
3191.     /**
3192.      * Calculates the size of the UnitOfWork. The size of the UnitOfWork is the
3193.      * number of entities in the identity map.
3194.      *
3195.      * @return int
3196.      */
3197.     public function size()
3198.     {
3199.         return array_sum(array_map('count', $this->identityMap));
3200.     }
3202.     /**
3203.      * Gets the EntityPersister for an Entity.
3204.      *
3205.      * @param string $entityName The name of the Entity.
3206.      * @psalm-param class-string $entityName
3207.      *
3208.      * @return EntityPersister
3209.      */
3210.     public function getEntityPersister($entityName)
3211.     {
3212.         if (isset($this->persisters[$entityName])) {
3213.             return $this->persisters[$entityName];
3214.         }
3216.         $class = $this->em->getClassMetadata($entityName);
3218.         switch (true) {
3219.             case $class->isInheritanceTypeNone():
3220.                 $persister = new BasicEntityPersister($this->em, $class);
3221.                 break;
3223.             case $class->isInheritanceTypeSingleTable():
3224.                 $persister = new SingleTablePersister($this->em, $class);
3225.                 break;
3227.             case $class->isInheritanceTypeJoined():
3228.                 $persister = new JoinedSubclassPersister($this->em, $class);
3229.                 break;
3231.             default:
3232.                 throw new RuntimeException('No persister found for entity.');
3233.         }
3235.         if ($this->hasCache && $class->cache !== null) {
3236.             $persister = $this->em->getConfiguration()
3237.                 ->getSecondLevelCacheConfiguration()
3238.                 ->getCacheFactory()
3239.                 ->buildCachedEntityPersister($this->em, $persister, $class);
3240.         }
3242.         $this->persisters[$entityName] = $persister;
3244.         return $this->persisters[$entityName];
3245.     }
3247.     /**
3248.      * Gets a collection persister for a collection-valued association.
3249.      *
3250.      * @psalm-param array<string, mixed> $association
3251.      *
3252.      * @return CollectionPersister
3253.      */
3254.     public function getCollectionPersister(array $association)
3255.     {
3256.         $role = isset($association['cache'])
3257.             ? $association['sourceEntity'] . '::' . $association['fieldName']
3258.             : $association['type'];
3260.         if (isset($this->collectionPersisters[$role])) {
3261.             return $this->collectionPersisters[$role];
3262.         }
3264.         $persister = $association['type'] === ClassMetadata::ONE_TO_MANY
3265.             ? new OneToManyPersister($this->em)
3266.             : new ManyToManyPersister($this->em);
3268.         if ($this->hasCache && isset($association['cache'])) {
3269.             $persister = $this->em->getConfiguration()
3270.                 ->getSecondLevelCacheConfiguration()
3271.                 ->getCacheFactory()
3272.                 ->buildCachedCollectionPersister($this->em, $persister, $association);
3273.         }
3275.         $this->collectionPersisters[$role] = $persister;
3277.         return $this->collectionPersisters[$role];
3278.     }
3280.     /**
3281.      * INTERNAL:
3282.      * Registers an entity as managed.
3283.      *
3284.      * @param object  $entity The entity.
3285.      * @param mixed[] $id     The identifier values.
3286.      * @param mixed[] $data   The original entity data.
3287.      *
3288.      * @return void
3289.      */
3290.     public function registerManaged($entity, array $id, array $data)
3291.     {
3292.         $oid = spl_object_id($entity);
3294.         $this->entityIdentifiers[$oid]  = $id;
3295.         $this->entityStates[$oid]       = self::STATE_MANAGED;
3296.         $this->originalEntityData[$oid] = $data;
3298.         $this->addToIdentityMap($entity);
3300.         if ($entity instanceof NotifyPropertyChanged && ( ! $entity instanceof Proxy || $entity->__isInitialized())) {
3301.             $entity->addPropertyChangedListener($this);
3302.         }
3303.     }
3305.     /**
3306.      * INTERNAL:
3307.      * Clears the property changeset of the entity with the given OID.
3308.      *
3309.      * @param int $oid The entity's OID.
3310.      *
3311.      * @return void
3312.      */
3313.     public function clearEntityChangeSet($oid)
3314.     {
3315.         unset($this->entityChangeSets[$oid]);
3316.     }
3318.     /* PropertyChangedListener implementation */
3320.     /**
3321.      * Notifies this UnitOfWork of a property change in an entity.
3322.      *
3323.      * @param object $sender       The entity that owns the property.
3324.      * @param string $propertyName The name of the property that changed.
3325.      * @param mixed  $oldValue     The old value of the property.
3326.      * @param mixed  $newValue     The new value of the property.
3327.      *
3328.      * @return void
3329.      */
3330.     public function propertyChanged($sender, $propertyName, $oldValue, $newValue)
3331.     {
3332.         $oid   = spl_object_id($sender);
3333.         $class = $this->em->getClassMetadata(get_class($sender));
3335.         $isAssocField = isset($class->associationMappings[$propertyName]);
3337.         if (! $isAssocField && ! isset($class->fieldMappings[$propertyName])) {
3338.             return; // ignore non-persistent fields
3339.         }
3341.         // Update changeset and mark entity for synchronization
3342.         $this->entityChangeSets[$oid][$propertyName] = [$oldValue, $newValue];
3344.         if (! isset($this->scheduledForSynchronization[$class->rootEntityName][$oid])) {
3345.             $this->scheduleForDirtyCheck($sender);
3346.         }
3347.     }
3349.     /**
3350.      * Gets the currently scheduled entity insertions in this UnitOfWork.
3351.      *
3352.      * @psalm-return array<int, object>
3353.      */
3354.     public function getScheduledEntityInsertions()
3355.     {
3356.         return $this->entityInsertions;
3357.     }
3359.     /**
3360.      * Gets the currently scheduled entity updates in this UnitOfWork.
3361.      *
3362.      * @psalm-return array<int, object>
3363.      */
3364.     public function getScheduledEntityUpdates()
3365.     {
3366.         return $this->entityUpdates;
3367.     }
3369.     /**
3370.      * Gets the currently scheduled entity deletions in this UnitOfWork.
3371.      *
3372.      * @psalm-return array<int, object>
3373.      */
3374.     public function getScheduledEntityDeletions()
3375.     {
3376.         return $this->entityDeletions;
3377.     }
3379.     /**
3380.      * Gets the currently scheduled complete collection deletions
3381.      *
3382.      * @psalm-return array<int, PersistentCollection<array-key, object>>
3383.      */
3384.     public function getScheduledCollectionDeletions()
3385.     {
3386.         return $this->collectionDeletions;
3387.     }
3389.     /**
3390.      * Gets the currently scheduled collection inserts, updates and deletes.
3391.      *
3392.      * @psalm-return array<int, PersistentCollection<array-key, object>>
3393.      */
3394.     public function getScheduledCollectionUpdates()
3395.     {
3396.         return $this->collectionUpdates;
3397.     }
3399.     /**
3400.      * Helper method to initialize a lazy loading proxy or persistent collection.
3401.      *
3402.      * @param object $obj
3403.      *
3404.      * @return void
3405.      */
3406.     public function initializeObject($obj)
3407.     {
3408.         if ($obj instanceof Proxy) {
3409.             $obj->__load();
3411.             return;
3412.         }
3414.         if ($obj instanceof PersistentCollection) {
3415.             $obj->initialize();
3416.         }
3417.     }
3419.     /**
3420.      * Helper method to show an object as string.
3421.      *
3422.      * @param object $obj
3423.      */
3424.     private static function objToStr($obj): string
3425.     {
3426.         return method_exists($obj, '__toString') ? (string) $obj : get_debug_type($obj) . '@' . spl_object_id($obj);
3427.     }
3429.     /**
3430.      * Marks an entity as read-only so that it will not be considered for updates during UnitOfWork#commit().
3431.      *
3432.      * This operation cannot be undone as some parts of the UnitOfWork now keep gathering information
3433.      * on this object that might be necessary to perform a correct update.
3434.      *
3435.      * @param object $object
3436.      *
3437.      * @return void
3438.      *
3439.      * @throws ORMInvalidArgumentException
3440.      */
3441.     public function markReadOnly($object)
3442.     {
3443.         if (! is_object($object) || ! $this->isInIdentityMap($object)) {
3444.             throw ORMInvalidArgumentException::readOnlyRequiresManagedEntity($object);
3445.         }
3447.         $this->readOnlyObjects[spl_object_id($object)] = true;
3448.     }
3450.     /**
3451.      * Is this entity read only?
3452.      *
3453.      * @param object $object
3454.      *
3455.      * @return bool
3456.      *
3457.      * @throws ORMInvalidArgumentException
3458.      */
3459.     public function isReadOnly($object)
3460.     {
3461.         if (! is_object($object)) {
3462.             throw ORMInvalidArgumentException::readOnlyRequiresManagedEntity($object);
3463.         }
3465.         return isset($this->readOnlyObjects[spl_object_id($object)]);
3466.     }
3468.     /**
3469.      * Perform whatever processing is encapsulated here after completion of the transaction.
3470.      */
3471.     private function afterTransactionComplete(): void
3472.     {
3473.         $this->performCallbackOnCachedPersister(static function (CachedPersister $persister) {
3474.             $persister->afterTransactionComplete();
3475.         });
3476.     }
3478.     /**
3479.      * Perform whatever processing is encapsulated here after completion of the rolled-back.
3480.      */
3481.     private function afterTransactionRolledBack(): void
3482.     {
3483.         $this->performCallbackOnCachedPersister(static function (CachedPersister $persister) {
3484.             $persister->afterTransactionRolledBack();
3485.         });
3486.     }
3488.     /**
3489.      * Performs an action after the transaction.
3490.      */
3491.     private function performCallbackOnCachedPersister(callable $callback): void
3492.     {
3493.         if (! $this->hasCache) {
3494.             return;
3495.         }
3497.         foreach (array_merge($this->persisters, $this->collectionPersisters) as $persister) {
3498.             if ($persister instanceof CachedPersister) {
3499.                 $callback($persister);
3500.             }
3501.         }
3502.     }
3504.     private function dispatchOnFlushEvent(): void
3505.     {
3506.         if ($this->evm->hasListeners(Events::onFlush)) {
3507.             $this->evm->dispatchEvent(Events::onFlush, new OnFlushEventArgs($this->em));
3508.         }
3509.     }
3511.     private function dispatchPostFlushEvent(): void
3512.     {
3513.         if ($this->evm->hasListeners(Events::postFlush)) {
3514.             $this->evm->dispatchEvent(Events::postFlush, new PostFlushEventArgs($this->em));
3515.         }
3516.     }
3518.     /**
3519.      * Verifies if two given entities actually are the same based on identifier comparison
3520.      *
3521.      * @param object $entity1
3522.      * @param object $entity2
3523.      */
3524.     private function isIdentifierEquals($entity1, $entity2): bool
3525.     {
3526.         if ($entity1 === $entity2) {
3527.             return true;
3528.         }
3530.         $class = $this->em->getClassMetadata(get_class($entity1));
3532.         if ($class !== $this->em->getClassMetadata(get_class($entity2))) {
3533.             return false;
3534.         }
3536.         $oid1 = spl_object_id($entity1);
3537.         $oid2 = spl_object_id($entity2);
3539.         $id1 = $this->entityIdentifiers[$oid1] ?? $this->identifierFlattener->flattenIdentifier($class, $class->getIdentifierValues($entity1));
3540.         $id2 = $this->entityIdentifiers[$oid2] ?? $this->identifierFlattener->flattenIdentifier($class, $class->getIdentifierValues($entity2));
3542.         return $id1 === $id2 || implode(' ', $id1) === implode(' ', $id2);
3543.     }
3545.     /** @throws ORMInvalidArgumentException */
3546.     private function assertThatThereAreNoUnintentionallyNonPersistedAssociations(): void
3547.     {
3548.         $entitiesNeedingCascadePersist = array_diff_key($this->nonCascadedNewDetectedEntities, $this->entityInsertions);
3550.         $this->nonCascadedNewDetectedEntities = [];
3552.         if ($entitiesNeedingCascadePersist) {
3553.             throw ORMInvalidArgumentException::newEntitiesFoundThroughRelationships(
3554.                 array_values($entitiesNeedingCascadePersist)
3555.             );
3556.         }
3557.     }
3559.     /**
3560.      * @param object $entity
3561.      * @param object $managedCopy
3562.      *
3563.      * @throws ORMException
3564.      * @throws OptimisticLockException
3565.      * @throws TransactionRequiredException
3566.      */
3567.     private function mergeEntityStateIntoManagedCopy($entity, $managedCopy): void
3568.     {
3569.         if (! $this->isLoaded($entity)) {
3570.             return;
3571.         }
3573.         if (! $this->isLoaded($managedCopy)) {
3574.             $managedCopy->__load();
3575.         }
3577.         $class = $this->em->getClassMetadata(get_class($entity));
3579.         foreach ($this->reflectionPropertiesGetter->getProperties($class->name) as $prop) {
3580.             $name = $prop->name;
3582.             $prop->setAccessible(true);
3584.             if (! isset($class->associationMappings[$name])) {
3585.                 if (! $class->isIdentifier($name)) {
3586.                     $prop->setValue($managedCopy, $prop->getValue($entity));
3587.                 }
3588.             } else {
3589.                 $assoc2 = $class->associationMappings[$name];
3591.                 if ($assoc2['type'] & ClassMetadata::TO_ONE) {
3592.                     $other = $prop->getValue($entity);
3593.                     if ($other === null) {
3594.                         $prop->setValue($managedCopy, null);
3595.                     } else {
3596.                         if ($other instanceof Proxy && ! $other->__isInitialized()) {
3597.                             // do not merge fields marked lazy that have not been fetched.
3598.                             continue;
3599.                         }
3601.                         if (! $assoc2['isCascadeMerge']) {
3602.                             if ($this->getEntityState($other) === self::STATE_DETACHED) {
3603.                                 $targetClass = $this->em->getClassMetadata($assoc2['targetEntity']);
3604.                                 $relatedId   = $targetClass->getIdentifierValues($other);
3606.                                 if ($targetClass->subClasses) {
3607.                                     $other = $this->em->find($targetClass->name, $relatedId);
3608.                                 } else {
3609.                                     $other = $this->em->getProxyFactory()->getProxy(
3610.                                         $assoc2['targetEntity'],
3611.                                         $relatedId
3612.                                     );
3613.                                     $this->registerManaged($other, $relatedId, []);
3614.                                 }
3615.                             }
3617.                             $prop->setValue($managedCopy, $other);
3618.                         }
3619.                     }
3620.                 } else {
3621.                     $mergeCol = $prop->getValue($entity);
3623.                     if ($mergeCol instanceof PersistentCollection && ! $mergeCol->isInitialized()) {
3624.                         // do not merge fields marked lazy that have not been fetched.
3625.                         // keep the lazy persistent collection of the managed copy.
3626.                         continue;
3627.                     }
3629.                     $managedCol = $prop->getValue($managedCopy);
3631.                     if (! $managedCol) {
3632.                         $managedCol = new PersistentCollection(
3633.                             $this->em,
3634.                             $this->em->getClassMetadata($assoc2['targetEntity']),
3635.                             new ArrayCollection()
3636.                         );
3637.                         $managedCol->setOwner($managedCopy, $assoc2);
3638.                         $prop->setValue($managedCopy, $managedCol);
3639.                     }
3641.                     if ($assoc2['isCascadeMerge']) {
3642.                         $managedCol->initialize();
3644.                         // clear and set dirty a managed collection if its not also the same collection to merge from.
3645.                         if (! $managedCol->isEmpty() && $managedCol !== $mergeCol) {
3646.                             $managedCol->unwrap()->clear();
3647.                             $managedCol->setDirty(true);
3649.                             if (
3650.                                 $assoc2['isOwningSide']
3651.                                 && $assoc2['type'] === ClassMetadata::MANY_TO_MANY
3652.                                 && $class->isChangeTrackingNotify()
3653.                             ) {
3654.                                 $this->scheduleForDirtyCheck($managedCopy);
3655.                             }
3656.                         }
3657.                     }
3658.                 }
3659.             }
3661.             if ($class->isChangeTrackingNotify()) {
3662.                 // Just treat all properties as changed, there is no other choice.
3663.                 $this->propertyChanged($managedCopy, $name, null, $prop->getValue($managedCopy));
3664.             }
3665.         }
3666.     }
3668.     /**
3669.      * This method called by hydrators, and indicates that hydrator totally completed current hydration cycle.
3670.      * Unit of work able to fire deferred events, related to loading events here.
3671.      *
3672.      * @internal should be called internally from object hydrators
3673.      *
3674.      * @return void
3675.      */
3676.     public function hydrationComplete()
3677.     {
3678.         $this->hydrationCompleteHandler->hydrationComplete();
3679.     }
3681.     private function clearIdentityMapForEntityName(string $entityName): void
3682.     {
3683.         if (! isset($this->identityMap[$entityName])) {
3684.             return;
3685.         }
3687.         $visited = [];
3689.         foreach ($this->identityMap[$entityName] as $entity) {
3690.             $this->doDetach($entity, $visited, false);
3691.         }
3692.     }
3694.     private function clearEntityInsertionsForEntityName(string $entityName): void
3695.     {
3696.         foreach ($this->entityInsertions as $hash => $entity) {
3697.             // note: performance optimization - `instanceof` is much faster than a function call
3698.             if ($entity instanceof $entityName && get_class($entity) === $entityName) {
3699.                 unset($this->entityInsertions[$hash]);
3700.             }
3701.         }
3702.     }
3704.     /**
3705.      * @param mixed $identifierValue
3706.      *
3707.      * @return mixed the identifier after type conversion
3708.      *
3709.      * @throws MappingException if the entity has more than a single identifier.
3710.      */
3711.     private function convertSingleFieldIdentifierToPHPValue(ClassMetadata $class, $identifierValue)
3712.     {
3713.         return $this->em->getConnection()->convertToPHPValue(
3714.             $identifierValue,
3715.             $class->getTypeOfField($class->getSingleIdentifierFieldName())
3716.         );
3717.     }
3719.     /**
3720.      * Given a flat identifier, this method will produce another flat identifier, but with all
3721.      * association fields that are mapped as identifiers replaced by entity references, recursively.
3722.      *
3723.      * @param mixed[] $flatIdentifier
3724.      *
3725.      * @return array<string, mixed>
3726.      */
3727.     private function normalizeIdentifier(ClassMetadata $targetClass, array $flatIdentifier): array
3728.     {
3729.         $normalizedAssociatedId = [];
3731.         foreach ($targetClass->getIdentifierFieldNames() as $name) {
3732.             if (! array_key_exists($name, $flatIdentifier)) {
3733.                 continue;
3734.             }
3736.             if (! $targetClass->isSingleValuedAssociation($name)) {
3737.                 $normalizedAssociatedId[$name] = $flatIdentifier[$name];
3738.                 continue;
3739.             }
3741.             $targetIdMetadata = $this->em->getClassMetadata($targetClass->getAssociationTargetClass($name));
3743.             // Note: the ORM prevents using an entity with a composite identifier as an identifier association
3744.             //       therefore, reset($targetIdMetadata->identifier) is always correct
3745.             $normalizedAssociatedId[$name] = $this->em->getReference(
3746.                 $targetIdMetadata->getName(),
3747.                 $this->normalizeIdentifier(
3748.                     $targetIdMetadata,
3749.                     [(string) reset($targetIdMetadata->identifier) => $flatIdentifier[$name]]
3750.                 )
3751.             );
3752.         }
3754.         return $normalizedAssociatedId;
3755.     }
3756. }