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\MappingException;
33. use Doctrine\ORM\Mapping\Reflection\ReflectionPropertiesGetter;
34. use Doctrine\ORM\Persisters\Collection\CollectionPersister;
35. use Doctrine\ORM\Persisters\Collection\ManyToManyPersister;
36. use Doctrine\ORM\Persisters\Collection\OneToManyPersister;
37. use Doctrine\ORM\Persisters\Entity\BasicEntityPersister;
38. use Doctrine\ORM\Persisters\Entity\EntityPersister;
39. use Doctrine\ORM\Persisters\Entity\JoinedSubclassPersister;
40. use Doctrine\ORM\Persisters\Entity\SingleTablePersister;
41. use Doctrine\ORM\Utility\IdentifierFlattener;
42. use Doctrine\Persistence\Mapping\RuntimeReflectionService;
43. use Doctrine\Persistence\NotifyPropertyChanged;
44. use Doctrine\Persistence\ObjectManagerAware;
45. use Doctrine\Persistence\PropertyChangedListener;
46. use Doctrine\Persistence\Proxy;
47. use Exception;
48. use InvalidArgumentException;
49. use RuntimeException;
50. use Throwable;
51. use UnexpectedValueException;
53. use function array_combine;
54. use function array_diff_key;
55. use function array_filter;
56. use function array_key_exists;
57. use function array_map;
58. use function array_merge;
59. use function array_pop;
60. use function array_sum;
61. use function array_values;
62. use function assert;
63. use function count;
64. use function current;
65. use function func_get_arg;
66. use function func_num_args;
67. use function get_class;
68. use function get_debug_type;
69. use function implode;
70. use function in_array;
71. use function is_array;
72. use function is_object;
73. use function method_exists;
74. use function reset;
75. use function spl_object_id;
76. use function sprintf;
78. /**
79.  * The UnitOfWork is responsible for tracking changes to objects during an
80.  * "object-level" transaction and for writing out changes to the database
81.  * in the correct order.
82.  *
83.  * Internal note: This class contains highly performance-sensitive code.
84.  *
85.  * @psalm-import-type AssociationMapping from ClassMetadata
86.  */
87. class UnitOfWork implements PropertyChangedListener
88. {
89.     /**
90.      * An entity is in MANAGED state when its persistence is managed by an EntityManager.
91.      */
92.     public const STATE_MANAGED = 1;
94.     /**
95.      * An entity is new if it has just been instantiated (i.e. using the "new" operator)
96.      * and is not (yet) managed by an EntityManager.
97.      */
98.     public const STATE_NEW = 2;
100.     /**
101.      * A detached entity is an instance with persistent state and identity that is not
102.      * (or no longer) associated with an EntityManager (and a UnitOfWork).
103.      */
104.     public const STATE_DETACHED = 3;
106.     /**
107.      * A removed entity instance is an instance with a persistent identity,
108.      * associated with an EntityManager, whose persistent state will be deleted
109.      * on commit.
110.      */
111.     public const STATE_REMOVED = 4;
113.     /**
114.      * Hint used to collect all primary keys of associated entities during hydration
115.      * and execute it in a dedicated query afterwards
116.      *
117.      * @see https://www.doctrine-project.org/projects/doctrine-orm/en/stable/reference/dql-doctrine-query-language.html#temporarily-change-fetch-mode-in-dql
118.      */
119.     public const HINT_DEFEREAGERLOAD = 'deferEagerLoad';
121.     /**
122.      * The identity map that holds references to all managed entities that have
123.      * an identity. The entities are grouped by their class name.
124.      * Since all classes in a hierarchy must share the same identifier set,
125.      * we always take the root class name of the hierarchy.
126.      *
127.      * @var mixed[]
128.      * @psalm-var array<class-string, array<string, object>>
129.      */
130.     private $identityMap = [];
132.     /**
133.      * Map of all identifiers of managed entities.
134.      * Keys are object ids (spl_object_id).
135.      *
136.      * @var mixed[]
137.      * @psalm-var array<int, array<string, mixed>>
138.      */
139.     private $entityIdentifiers = [];
141.     /**
142.      * Map of the original entity data of managed entities.
143.      * Keys are object ids (spl_object_id). This is used for calculating changesets
144.      * at commit time.
145.      *
146.      * Internal note: Note that PHPs "copy-on-write" behavior helps a lot with memory usage.
147.      *                A value will only really be copied if the value in the entity is modified
148.      *                by the user.
149.      *
150.      * @psalm-var array<int, array<string, mixed>>
151.      */
152.     private $originalEntityData = [];
154.     /**
155.      * Map of entity changes. Keys are object ids (spl_object_id).
156.      * Filled at the beginning of a commit of the UnitOfWork and cleaned at the end.
157.      *
158.      * @psalm-var array<int, array<string, array{mixed, mixed}>>
159.      */
160.     private $entityChangeSets = [];
162.     /**
163.      * The (cached) states of any known entities.
164.      * Keys are object ids (spl_object_id).
165.      *
166.      * @psalm-var array<int, self::STATE_*>
167.      */
168.     private $entityStates = [];
170.     /**
171.      * Map of entities that are scheduled for dirty checking at commit time.
172.      * This is only used for entities with a change tracking policy of DEFERRED_EXPLICIT.
173.      * Keys are object ids (spl_object_id).
174.      *
175.      * @psalm-var array<class-string, array<int, mixed>>
176.      */
177.     private $scheduledForSynchronization = [];
179.     /**
180.      * A list of all pending entity insertions.
181.      *
182.      * @psalm-var array<int, object>
183.      */
184.     private $entityInsertions = [];
186.     /**
187.      * A list of all pending entity updates.
188.      *
189.      * @psalm-var array<int, object>
190.      */
191.     private $entityUpdates = [];
193.     /**
194.      * Any pending extra updates that have been scheduled by persisters.
195.      *
196.      * @psalm-var array<int, array{object, array<string, array{mixed, mixed}>}>
197.      */
198.     private $extraUpdates = [];
200.     /**
201.      * A list of all pending entity deletions.
202.      *
203.      * @psalm-var array<int, object>
204.      */
205.     private $entityDeletions = [];
207.     /**
208.      * New entities that were discovered through relationships that were not
209.      * marked as cascade-persist. During flush, this array is populated and
210.      * then pruned of any entities that were discovered through a valid
211.      * cascade-persist path. (Leftovers cause an error.)
212.      *
213.      * Keys are OIDs, payload is a two-item array describing the association
214.      * and the entity.
215.      *
216.      * @var array<int, array{AssociationMapping, object}> indexed by respective object spl_object_id()
217.      */
218.     private $nonCascadedNewDetectedEntities = [];
220.     /**
221.      * All pending collection deletions.
222.      *
223.      * @psalm-var array<int, PersistentCollection<array-key, object>>
224.      */
225.     private $collectionDeletions = [];
227.     /**
228.      * All pending collection updates.
229.      *
230.      * @psalm-var array<int, PersistentCollection<array-key, object>>
231.      */
232.     private $collectionUpdates = [];
234.     /**
235.      * List of collections visited during changeset calculation on a commit-phase of a UnitOfWork.
236.      * At the end of the UnitOfWork all these collections will make new snapshots
237.      * of their data.
238.      *
239.      * @psalm-var array<int, PersistentCollection<array-key, object>>
240.      */
241.     private $visitedCollections = [];
243.     /**
244.      * List of collections visited during the changeset calculation that contain to-be-removed
245.      * entities and need to have keys removed post commit.
246.      *
247.      * Indexed by Collection object ID, which also serves as the key in self::$visitedCollections;
248.      * values are the key names that need to be removed.
249.      *
250.      * @psalm-var array<int, array<array-key, true>>
251.      */
252.     private $pendingCollectionElementRemovals = [];
254.     /**
255.      * The EntityManager that "owns" this UnitOfWork instance.
256.      *
257.      * @var EntityManagerInterface
258.      */
259.     private $em;
261.     /**
262.      * The entity persister instances used to persist entity instances.
263.      *
264.      * @psalm-var array<string, EntityPersister>
265.      */
266.     private $persisters = [];
268.     /**
269.      * The collection persister instances used to persist collections.
270.      *
271.      * @psalm-var array<array-key, CollectionPersister>
272.      */
273.     private $collectionPersisters = [];
275.     /**
276.      * The EventManager used for dispatching events.
277.      *
278.      * @var EventManager
279.      */
280.     private $evm;
282.     /**
283.      * The ListenersInvoker used for dispatching events.
284.      *
285.      * @var ListenersInvoker
286.      */
287.     private $listenersInvoker;
289.     /**
290.      * The IdentifierFlattener used for manipulating identifiers
291.      *
292.      * @var IdentifierFlattener
293.      */
294.     private $identifierFlattener;
296.     /**
297.      * Orphaned entities that are scheduled for removal.
298.      *
299.      * @psalm-var array<int, object>
300.      */
301.     private $orphanRemovals = [];
303.     /**
304.      * Read-Only objects are never evaluated
305.      *
306.      * @var array<int, true>
307.      */
308.     private $readOnlyObjects = [];
310.     /**
311.      * Map of Entity Class-Names and corresponding IDs that should eager loaded when requested.
312.      *
313.      * @psalm-var array<class-string, array<string, mixed>>
314.      */
315.     private $eagerLoadingEntities = [];
317.     /** @var bool */
318.     protected $hasCache = false;
320.     /**
321.      * Helper for handling completion of hydration
322.      *
323.      * @var HydrationCompleteHandler
324.      */
325.     private $hydrationCompleteHandler;
327.     /** @var ReflectionPropertiesGetter */
328.     private $reflectionPropertiesGetter;
330.     /**
331.      * Initializes a new UnitOfWork instance, bound to the given EntityManager.
332.      */
333.     public function __construct(EntityManagerInterface $em)
334.     {
335.         $this->em                         = $em;
336.         $this->evm                        = $em->getEventManager();
337.         $this->listenersInvoker           = new ListenersInvoker($em);
338.         $this->hasCache                   = $em->getConfiguration()->isSecondLevelCacheEnabled();
339.         $this->identifierFlattener        = new IdentifierFlattener($this, $em->getMetadataFactory());
340.         $this->hydrationCompleteHandler   = new HydrationCompleteHandler($this->listenersInvoker, $em);
341.         $this->reflectionPropertiesGetter = new ReflectionPropertiesGetter(new RuntimeReflectionService());
342.     }
344.     /**
345.      * Commits the UnitOfWork, executing all operations that have been postponed
346.      * up to this point. The state of all managed entities will be synchronized with
347.      * the database.
348.      *
349.      * The operations are executed in the following order:
350.      *
351.      * 1) All entity insertions
352.      * 2) All entity updates
353.      * 3) All collection deletions
354.      * 4) All collection updates
355.      * 5) All entity deletions
356.      *
357.      * @param object|mixed[]|null $entity
358.      *
359.      * @return void
360.      *
361.      * @throws Exception
362.      */
363.     public function commit($entity = null)
364.     {
365.         if ($entity !== null) {
366.             Deprecation::triggerIfCalledFromOutside(
367.                 'doctrine/orm',
368.                 'https://github.com/doctrine/orm/issues/8459',
369.                 'Calling %s() with any arguments to commit specific entities is deprecated and will not be supported in Doctrine ORM 3.0.',
370.                 __METHOD__
371.             );
372.         }
374.         $connection = $this->em->getConnection();
376.         if ($connection instanceof PrimaryReadReplicaConnection) {
377.             $connection->ensureConnectedToPrimary();
378.         }
380.         // Raise preFlush
381.         if ($this->evm->hasListeners(Events::preFlush)) {
382.             $this->evm->dispatchEvent(Events::preFlush, new PreFlushEventArgs($this->em));
383.         }
385.         // Compute changes done since last commit.
386.         if ($entity === null) {
387.             $this->computeChangeSets();
388.         } elseif (is_object($entity)) {
389.             $this->computeSingleEntityChangeSet($entity);
390.         } elseif (is_array($entity)) {
391.             foreach ($entity as $object) {
392.                 $this->computeSingleEntityChangeSet($object);
393.             }
394.         }
396.         if (
397.             ! ($this->entityInsertions ||
398.                 $this->entityDeletions ||
399.                 $this->entityUpdates ||
400.                 $this->collectionUpdates ||
401.                 $this->collectionDeletions ||
402.                 $this->orphanRemovals)
403.         ) {
404.             $this->dispatchOnFlushEvent();
405.             $this->dispatchPostFlushEvent();
407.             $this->postCommitCleanup($entity);
409.             return; // Nothing to do.
410.         }
412.         $this->assertThatThereAreNoUnintentionallyNonPersistedAssociations();
414.         if ($this->orphanRemovals) {
415.             foreach ($this->orphanRemovals as $orphan) {
416.                 $this->remove($orphan);
417.             }
418.         }
420.         $this->dispatchOnFlushEvent();
422.         // Now we need a commit order to maintain referential integrity
423.         $commitOrder = $this->getCommitOrder();
425.         $conn = $this->em->getConnection();
426.         $conn->beginTransaction();
428.         try {
429.             // Collection deletions (deletions of complete collections)
430.             foreach ($this->collectionDeletions as $collectionToDelete) {
431.                 // Deferred explicit tracked collections can be removed only when owning relation was persisted
432.                 $owner = $collectionToDelete->getOwner();
434.                 if ($this->em->getClassMetadata(get_class($owner))->isChangeTrackingDeferredImplicit() || $this->isScheduledForDirtyCheck($owner)) {
435.                     $this->getCollectionPersister($collectionToDelete->getMapping())->delete($collectionToDelete);
436.                 }
437.             }
439.             if ($this->entityInsertions) {
440.                 foreach ($commitOrder as $class) {
441.                     $this->executeInserts($class);
442.                 }
443.             }
445.             if ($this->entityUpdates) {
446.                 foreach ($commitOrder as $class) {
447.                     $this->executeUpdates($class);
448.                 }
449.             }
451.             // Extra updates that were requested by persisters.
452.             if ($this->extraUpdates) {
453.                 $this->executeExtraUpdates();
454.             }
456.             // Collection updates (deleteRows, updateRows, insertRows)
457.             foreach ($this->collectionUpdates as $collectionToUpdate) {
458.                 $this->getCollectionPersister($collectionToUpdate->getMapping())->update($collectionToUpdate);
459.             }
461.             // Entity deletions come last and need to be in reverse commit order
462.             if ($this->entityDeletions) {
463.                 for ($count = count($commitOrder), $i = $count - 1; $i >= 0 && $this->entityDeletions; --$i) {
464.                     $this->executeDeletions($commitOrder[$i]);
465.                 }
466.             }
468.             // Commit failed silently
469.             if ($conn->commit() === false) {
470.                 $object = is_object($entity) ? $entity : null;
472.                 throw new OptimisticLockException('Commit failed', $object);
473.             }
474.         } catch (Throwable $e) {
475.             $this->em->close();
477.             if ($conn->isTransactionActive()) {
478.                 $conn->rollBack();
479.             }
481.             $this->afterTransactionRolledBack();
483.             throw $e;
484.         }
486.         $this->afterTransactionComplete();
488.         // Unset removed entities from collections, and take new snapshots from
489.         // all visited collections.
490.         foreach ($this->visitedCollections as $coid => $coll) {
491.             if (isset($this->pendingCollectionElementRemovals[$coid])) {
492.                 foreach ($this->pendingCollectionElementRemovals[$coid] as $key => $valueIgnored) {
493.                     unset($coll[$key]);
494.                 }
495.             }
497.             $coll->takeSnapshot();
498.         }
500.         $this->dispatchPostFlushEvent();
502.         $this->postCommitCleanup($entity);
503.     }
505.     /** @param object|object[]|null $entity */
506.     private function postCommitCleanup($entity): void
507.     {
508.         $this->entityInsertions                 =
509.         $this->entityUpdates                    =
510.         $this->entityDeletions                  =
511.         $this->extraUpdates                     =
512.         $this->collectionUpdates                =
513.         $this->nonCascadedNewDetectedEntities   =
514.         $this->collectionDeletions              =
515.         $this->pendingCollectionElementRemovals =
516.         $this->visitedCollections               =
517.         $this->orphanRemovals                   = [];
519.         if ($entity === null) {
520.             $this->entityChangeSets = $this->scheduledForSynchronization = [];
522.             return;
523.         }
525.         $entities = is_object($entity)
526.             ? [$entity]
527.             : $entity;
529.         foreach ($entities as $object) {
530.             $oid = spl_object_id($object);
532.             $this->clearEntityChangeSet($oid);
534.             unset($this->scheduledForSynchronization[$this->em->getClassMetadata(get_class($object))->rootEntityName][$oid]);
535.         }
536.     }
538.     /**
539.      * Computes the changesets of all entities scheduled for insertion.
540.      */
541.     private function computeScheduleInsertsChangeSets(): void
542.     {
543.         foreach ($this->entityInsertions as $entity) {
544.             $class = $this->em->getClassMetadata(get_class($entity));
546.             $this->computeChangeSet($class, $entity);
547.         }
548.     }
550.     /**
551.      * Only flushes the given entity according to a ruleset that keeps the UoW consistent.
552.      *
553.      * 1. All entities scheduled for insertion, (orphan) removals and changes in collections are processed as well!
554.      * 2. Read Only entities are skipped.
555.      * 3. Proxies are skipped.
556.      * 4. Only if entity is properly managed.
557.      *
558.      * @param object $entity
559.      *
560.      * @throws InvalidArgumentException
561.      */
562.     private function computeSingleEntityChangeSet($entity): void
563.     {
564.         $state = $this->getEntityState($entity);
566.         if ($state !== self::STATE_MANAGED && $state !== self::STATE_REMOVED) {
567.             throw new InvalidArgumentException('Entity has to be managed or scheduled for removal for single computation ' . self::objToStr($entity));
568.         }
570.         $class = $this->em->getClassMetadata(get_class($entity));
572.         if ($state === self::STATE_MANAGED && $class->isChangeTrackingDeferredImplicit()) {
573.             $this->persist($entity);
574.         }
576.         // Compute changes for INSERTed entities first. This must always happen even in this case.
577.         $this->computeScheduleInsertsChangeSets();
579.         if ($class->isReadOnly) {
580.             return;
581.         }
583.         // Ignore uninitialized proxy objects
584.         if ($entity instanceof Proxy && ! $entity->__isInitialized()) {
585.             return;
586.         }
588.         // Only MANAGED entities that are NOT SCHEDULED FOR INSERTION OR DELETION are processed here.
589.         $oid = spl_object_id($entity);
591.         if (! isset($this->entityInsertions[$oid]) && ! isset($this->entityDeletions[$oid]) && isset($this->entityStates[$oid])) {
592.             $this->computeChangeSet($class, $entity);
593.         }
594.     }
596.     /**
597.      * Executes any extra updates that have been scheduled.
598.      */
599.     private function executeExtraUpdates(): void
600.     {
601.         foreach ($this->extraUpdates as $oid => $update) {
602.             [$entity, $changeset] = $update;
604.             $this->entityChangeSets[$oid] = $changeset;
605.             $this->getEntityPersister(get_class($entity))->update($entity);
606.         }
608.         $this->extraUpdates = [];
609.     }
611.     /**
612.      * Gets the changeset for an entity.
613.      *
614.      * @param object $entity
615.      *
616.      * @return mixed[][]
617.      * @psalm-return array<string, array{mixed, mixed}|PersistentCollection>
618.      */
619.     public function & getEntityChangeSet($entity)
620.     {
621.         $oid  = spl_object_id($entity);
622.         $data = [];
624.         if (! isset($this->entityChangeSets[$oid])) {
625.             return $data;
626.         }
628.         return $this->entityChangeSets[$oid];
629.     }
631.     /**
632.      * Computes the changes that happened to a single entity.
633.      *
634.      * Modifies/populates the following properties:
635.      *
636.      * {@link _originalEntityData}
637.      * If the entity is NEW or MANAGED but not yet fully persisted (only has an id)
638.      * then it was not fetched from the database and therefore we have no original
639.      * entity data yet. All of the current entity data is stored as the original entity data.
640.      *
641.      * {@link _entityChangeSets}
642.      * The changes detected on all properties of the entity are stored there.
643.      * A change is a tuple array where the first entry is the old value and the second
644.      * entry is the new value of the property. Changesets are used by persisters
645.      * to INSERT/UPDATE the persistent entity state.
646.      *
647.      * {@link _entityUpdates}
648.      * If the entity is already fully MANAGED (has been fetched from the database before)
649.      * and any changes to its properties are detected, then a reference to the entity is stored
650.      * there to mark it for an update.
651.      *
652.      * {@link _collectionDeletions}
653.      * If a PersistentCollection has been de-referenced in a fully MANAGED entity,
654.      * then this collection is marked for deletion.
655.      *
656.      * @param ClassMetadata $class  The class descriptor of the entity.
657.      * @param object        $entity The entity for which to compute the changes.
658.      * @psalm-param ClassMetadata<T> $class
659.      * @psalm-param T $entity
660.      *
661.      * @return void
662.      *
663.      * @template T of object
664.      *
665.      * @ignore
666.      */
667.     public function computeChangeSet(ClassMetadata $class, $entity)
668.     {
669.         $oid = spl_object_id($entity);
671.         if (isset($this->readOnlyObjects[$oid])) {
672.             return;
673.         }
675.         if (! $class->isInheritanceTypeNone()) {
676.             $class = $this->em->getClassMetadata(get_class($entity));
677.         }
679.         $invoke = $this->listenersInvoker->getSubscribedSystems($class, Events::preFlush) & ~ListenersInvoker::INVOKE_MANAGER;
681.         if ($invoke !== ListenersInvoker::INVOKE_NONE) {
682.             $this->listenersInvoker->invoke($class, Events::preFlush, $entity, new PreFlushEventArgs($this->em), $invoke);
683.         }
685.         $actualData = [];
687.         foreach ($class->reflFields as $name => $refProp) {
688.             $value = $refProp->getValue($entity);
690.             if ($class->isCollectionValuedAssociation($name) && $value !== null) {
691.                 if ($value instanceof PersistentCollection) {
692.                     if ($value->getOwner() === $entity) {
693.                         continue;
694.                     }
696.                     $value = new ArrayCollection($value->getValues());
697.                 }
699.                 // If $value is not a Collection then use an ArrayCollection.
700.                 if (! $value instanceof Collection) {
701.                     $value = new ArrayCollection($value);
702.                 }
704.                 $assoc = $class->associationMappings[$name];
706.                 // Inject PersistentCollection
707.                 $value = new PersistentCollection(
708.                     $this->em,
709.                     $this->em->getClassMetadata($assoc['targetEntity']),
710.                     $value
711.                 );
712.                 $value->setOwner($entity, $assoc);
713.                 $value->setDirty(! $value->isEmpty());
715.                 $refProp->setValue($entity, $value);
717.                 $actualData[$name] = $value;
719.                 continue;
720.             }
722.             if (( ! $class->isIdentifier($name) || ! $class->isIdGeneratorIdentity()) && ($name !== $class->versionField)) {
723.                 $actualData[$name] = $value;
724.             }
725.         }
727.         if (! isset($this->originalEntityData[$oid])) {
728.             // Entity is either NEW or MANAGED but not yet fully persisted (only has an id).
729.             // These result in an INSERT.
730.             $this->originalEntityData[$oid] = $actualData;
731.             $changeSet                      = [];
733.             foreach ($actualData as $propName => $actualValue) {
734.                 if (! isset($class->associationMappings[$propName])) {
735.                     $changeSet[$propName] = [null, $actualValue];
737.                     continue;
738.                 }
740.                 $assoc = $class->associationMappings[$propName];
742.                 if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
743.                     $changeSet[$propName] = [null, $actualValue];
744.                 }
745.             }
747.             $this->entityChangeSets[$oid] = $changeSet;
748.         } else {
749.             // Entity is "fully" MANAGED: it was already fully persisted before
750.             // and we have a copy of the original data
751.             $originalData           = $this->originalEntityData[$oid];
752.             $isChangeTrackingNotify = $class->isChangeTrackingNotify();
753.             $changeSet              = $isChangeTrackingNotify && isset($this->entityChangeSets[$oid])
754.                 ? $this->entityChangeSets[$oid]
755.                 : [];
757.             foreach ($actualData as $propName => $actualValue) {
758.                 // skip field, its a partially omitted one!
759.                 if (! (isset($originalData[$propName]) || array_key_exists($propName, $originalData))) {
760.                     continue;
761.                 }
763.                 $orgValue = $originalData[$propName];
765.                 if (! empty($class->fieldMappings[$propName]['enumType'])) {
766.                     if (is_array($orgValue)) {
767.                         foreach ($orgValue as $id => $val) {
768.                             if ($val instanceof BackedEnum) {
769.                                 $orgValue[$id] = $val->value;
770.                             }
771.                         }
772.                     } else {
773.                         if ($orgValue instanceof BackedEnum) {
774.                             $orgValue = $orgValue->value;
775.                         }
776.                     }
777.                 }
779.                 // skip if value haven't changed
780.                 if ($orgValue === $actualValue) {
781.                     continue;
782.                 }
784.                 // if regular field
785.                 if (! isset($class->associationMappings[$propName])) {
786.                     if ($isChangeTrackingNotify) {
787.                         continue;
788.                     }
790.                     $changeSet[$propName] = [$orgValue, $actualValue];
792.                     continue;
793.                 }
795.                 $assoc = $class->associationMappings[$propName];
797.                 // Persistent collection was exchanged with the "originally"
798.                 // created one. This can only mean it was cloned and replaced
799.                 // on another entity.
800.                 if ($actualValue instanceof PersistentCollection) {
801.                     $owner = $actualValue->getOwner();
802.                     if ($owner === null) { // cloned
803.                         $actualValue->setOwner($entity, $assoc);
804.                     } elseif ($owner !== $entity) { // no clone, we have to fix
805.                         if (! $actualValue->isInitialized()) {
806.                             $actualValue->initialize(); // we have to do this otherwise the cols share state
807.                         }
809.                         $newValue = clone $actualValue;
810.                         $newValue->setOwner($entity, $assoc);
811.                         $class->reflFields[$propName]->setValue($entity, $newValue);
812.                     }
813.                 }
815.                 if ($orgValue instanceof PersistentCollection) {
816.                     // A PersistentCollection was de-referenced, so delete it.
817.                     $coid = spl_object_id($orgValue);
819.                     if (isset($this->collectionDeletions[$coid])) {
820.                         continue;
821.                     }
823.                     $this->collectionDeletions[$coid] = $orgValue;
824.                     $changeSet[$propName]             = $orgValue; // Signal changeset, to-many assocs will be ignored.
826.                     continue;
827.                 }
829.                 if ($assoc['type'] & ClassMetadata::TO_ONE) {
830.                     if ($assoc['isOwningSide']) {
831.                         $changeSet[$propName] = [$orgValue, $actualValue];
832.                     }
834.                     if ($orgValue !== null && $assoc['orphanRemoval']) {
835.                         assert(is_object($orgValue));
836.                         $this->scheduleOrphanRemoval($orgValue);
837.                     }
838.                 }
839.             }
841.             if ($changeSet) {
842.                 $this->entityChangeSets[$oid]   = $changeSet;
843.                 $this->originalEntityData[$oid] = $actualData;
844.                 $this->entityUpdates[$oid]      = $entity;
845.             }
846.         }
848.         // Look for changes in associations of the entity
849.         foreach ($class->associationMappings as $field => $assoc) {
850.             $val = $class->reflFields[$field]->getValue($entity);
851.             if ($val === null) {
852.                 continue;
853.             }
855.             $this->computeAssociationChanges($assoc, $val);
857.             if (
858.                 ! isset($this->entityChangeSets[$oid]) &&
859.                 $assoc['isOwningSide'] &&
860.                 $assoc['type'] === ClassMetadata::MANY_TO_MANY &&
861.                 $val instanceof PersistentCollection &&
862.                 $val->isDirty()
863.             ) {
864.                 $this->entityChangeSets[$oid]   = [];
865.                 $this->originalEntityData[$oid] = $actualData;
866.                 $this->entityUpdates[$oid]      = $entity;
867.             }
868.         }
869.     }
871.     /**
872.      * Computes all the changes that have been done to entities and collections
873.      * since the last commit and stores these changes in the _entityChangeSet map
874.      * temporarily for access by the persisters, until the UoW commit is finished.
875.      *
876.      * @return void
877.      */
878.     public function computeChangeSets()
879.     {
880.         // Compute changes for INSERTed entities first. This must always happen.
881.         $this->computeScheduleInsertsChangeSets();
883.         // Compute changes for other MANAGED entities. Change tracking policies take effect here.
884.         foreach ($this->identityMap as $className => $entities) {
885.             $class = $this->em->getClassMetadata($className);
887.             // Skip class if instances are read-only
888.             if ($class->isReadOnly) {
889.                 continue;
890.             }
892.             // If change tracking is explicit or happens through notification, then only compute
893.             // changes on entities of that type that are explicitly marked for synchronization.
894.             switch (true) {
895.                 case $class->isChangeTrackingDeferredImplicit():
896.                     $entitiesToProcess = $entities;
897.                     break;
899.                 case isset($this->scheduledForSynchronization[$className]):
900.                     $entitiesToProcess = $this->scheduledForSynchronization[$className];
901.                     break;
903.                 default:
904.                     $entitiesToProcess = [];
905.             }
907.             foreach ($entitiesToProcess as $entity) {
908.                 // Ignore uninitialized proxy objects
909.                 if ($entity instanceof Proxy && ! $entity->__isInitialized()) {
910.                     continue;
911.                 }
913.                 // Only MANAGED entities that are NOT SCHEDULED FOR INSERTION OR DELETION are processed here.
914.                 $oid = spl_object_id($entity);
916.                 if (! isset($this->entityInsertions[$oid]) && ! isset($this->entityDeletions[$oid]) && isset($this->entityStates[$oid])) {
917.                     $this->computeChangeSet($class, $entity);
918.                 }
919.             }
920.         }
921.     }
923.     /**
924.      * Computes the changes of an association.
925.      *
926.      * @param mixed $value The value of the association.
927.      * @psalm-param AssociationMapping $assoc The association mapping.
928.      *
929.      * @throws ORMInvalidArgumentException
930.      * @throws ORMException
931.      */
932.     private function computeAssociationChanges(array $assoc, $value): void
933.     {
934.         if ($value instanceof Proxy && ! $value->__isInitialized()) {
935.             return;
936.         }
938.         // If this collection is dirty, schedule it for updates
939.         if ($value instanceof PersistentCollection && $value->isDirty()) {
940.             $coid = spl_object_id($value);
942.             $this->collectionUpdates[$coid]  = $value;
943.             $this->visitedCollections[$coid] = $value;
944.         }
946.         // Look through the entities, and in any of their associations,
947.         // for transient (new) entities, recursively. ("Persistence by reachability")
948.         // Unwrap. Uninitialized collections will simply be empty.
949.         $unwrappedValue = $assoc['type'] & ClassMetadata::TO_ONE ? [$value] : $value->unwrap();
950.         $targetClass    = $this->em->getClassMetadata($assoc['targetEntity']);
952.         foreach ($unwrappedValue as $key => $entry) {
953.             if (! ($entry instanceof $targetClass->name)) {
954.                 throw ORMInvalidArgumentException::invalidAssociation($targetClass, $assoc, $entry);
955.             }
957.             $state = $this->getEntityState($entry, self::STATE_NEW);
959.             if (! ($entry instanceof $assoc['targetEntity'])) {
960.                 throw UnexpectedAssociationValue::create(
961.                     $assoc['sourceEntity'],
962.                     $assoc['fieldName'],
963.                     get_debug_type($entry),
964.                     $assoc['targetEntity']
965.                 );
966.             }
968.             switch ($state) {
969.                 case self::STATE_NEW:
970.                     if (! $assoc['isCascadePersist']) {
971.                         /*
972.                          * For now just record the details, because this may
973.                          * not be an issue if we later discover another pathway
974.                          * through the object-graph where cascade-persistence
975.                          * is enabled for this object.
976.                          */
977.                         $this->nonCascadedNewDetectedEntities[spl_object_id($entry)] = [$assoc, $entry];
979.                         break;
980.                     }
982.                     $this->persistNew($targetClass, $entry);
983.                     $this->computeChangeSet($targetClass, $entry);
985.                     break;
987.                 case self::STATE_REMOVED:
988.                     // Consume the $value as array (it's either an array or an ArrayAccess)
989.                     // and remove the element from Collection.
990.                     if (! ($assoc['type'] & ClassMetadata::TO_MANY)) {
991.                         break;
992.                     }
994.                     $coid                            = spl_object_id($value);
995.                     $this->visitedCollections[$coid] = $value;
997.                     if (! isset($this->pendingCollectionElementRemovals[$coid])) {
998.                         $this->pendingCollectionElementRemovals[$coid] = [];
999.                     }
1001.                     $this->pendingCollectionElementRemovals[$coid][$key] = true;
1002.                     break;
1004.                 case self::STATE_DETACHED:
1005.                     // Can actually not happen right now as we assume STATE_NEW,
1006.                     // so the exception will be raised from the DBAL layer (constraint violation).
1007.                     throw ORMInvalidArgumentException::detachedEntityFoundThroughRelationship($assoc, $entry);
1009.                 default:
1010.                     // MANAGED associated entities are already taken into account
1011.                     // during changeset calculation anyway, since they are in the identity map.
1012.             }
1013.         }
1014.     }
1016.     /**
1017.      * @param object $entity
1018.      * @psalm-param ClassMetadata<T> $class
1019.      * @psalm-param T $entity
1020.      *
1021.      * @template T of object
1022.      */
1023.     private function persistNew(ClassMetadata $class, $entity): void
1024.     {
1025.         $oid    = spl_object_id($entity);
1026.         $invoke = $this->listenersInvoker->getSubscribedSystems($class, Events::prePersist);
1028.         if ($invoke !== ListenersInvoker::INVOKE_NONE) {
1029.             $this->listenersInvoker->invoke($class, Events::prePersist, $entity, new PrePersistEventArgs($entity, $this->em), $invoke);
1030.         }
1032.         $idGen = $class->idGenerator;
1034.         if (! $idGen->isPostInsertGenerator()) {
1035.             $idValue = $idGen->generateId($this->em, $entity);
1037.             if (! $idGen instanceof AssignedGenerator) {
1038.                 $idValue = [$class->getSingleIdentifierFieldName() => $this->convertSingleFieldIdentifierToPHPValue($class, $idValue)];
1040.                 $class->setIdentifierValues($entity, $idValue);
1041.             }
1043.             // Some identifiers may be foreign keys to new entities.
1044.             // In this case, we don't have the value yet and should treat it as if we have a post-insert generator
1045.             if (! $this->hasMissingIdsWhichAreForeignKeys($class, $idValue)) {
1046.                 $this->entityIdentifiers[$oid] = $idValue;
1047.             }
1048.         }
1050.         $this->entityStates[$oid] = self::STATE_MANAGED;
1052.         $this->scheduleForInsert($entity);
1053.     }
1055.     /** @param mixed[] $idValue */
1056.     private function hasMissingIdsWhichAreForeignKeys(ClassMetadata $class, array $idValue): bool
1057.     {
1058.         foreach ($idValue as $idField => $idFieldValue) {
1059.             if ($idFieldValue === null && isset($class->associationMappings[$idField])) {
1060.                 return true;
1061.             }
1062.         }
1064.         return false;
1065.     }
1067.     /**
1068.      * INTERNAL:
1069.      * Computes the changeset of an individual entity, independently of the
1070.      * computeChangeSets() routine that is used at the beginning of a UnitOfWork#commit().
1071.      *
1072.      * The passed entity must be a managed entity. If the entity already has a change set
1073.      * because this method is invoked during a commit cycle then the change sets are added.
1074.      * whereby changes detected in this method prevail.
1075.      *
1076.      * @param ClassMetadata $class  The class descriptor of the entity.
1077.      * @param object        $entity The entity for which to (re)calculate the change set.
1078.      * @psalm-param ClassMetadata<T> $class
1079.      * @psalm-param T $entity
1080.      *
1081.      * @return void
1082.      *
1083.      * @throws ORMInvalidArgumentException If the passed entity is not MANAGED.
1084.      *
1085.      * @template T of object
1086.      * @ignore
1087.      */
1088.     public function recomputeSingleEntityChangeSet(ClassMetadata $class, $entity)
1089.     {
1090.         $oid = spl_object_id($entity);
1092.         if (! isset($this->entityStates[$oid]) || $this->entityStates[$oid] !== self::STATE_MANAGED) {
1093.             throw ORMInvalidArgumentException::entityNotManaged($entity);
1094.         }
1096.         // skip if change tracking is "NOTIFY"
1097.         if ($class->isChangeTrackingNotify()) {
1098.             return;
1099.         }
1101.         if (! $class->isInheritanceTypeNone()) {
1102.             $class = $this->em->getClassMetadata(get_class($entity));
1103.         }
1105.         $actualData = [];
1107.         foreach ($class->reflFields as $name => $refProp) {
1108.             if (
1109.                 ( ! $class->isIdentifier($name) || ! $class->isIdGeneratorIdentity())
1110.                 && ($name !== $class->versionField)
1111.                 && ! $class->isCollectionValuedAssociation($name)
1112.             ) {
1113.                 $actualData[$name] = $refProp->getValue($entity);
1114.             }
1115.         }
1117.         if (! isset($this->originalEntityData[$oid])) {
1118.             throw new RuntimeException('Cannot call recomputeSingleEntityChangeSet before computeChangeSet on an entity.');
1119.         }
1121.         $originalData = $this->originalEntityData[$oid];
1122.         $changeSet    = [];
1124.         foreach ($actualData as $propName => $actualValue) {
1125.             $orgValue = $originalData[$propName] ?? null;
1127.             if ($orgValue !== $actualValue) {
1128.                 $changeSet[$propName] = [$orgValue, $actualValue];
1129.             }
1130.         }
1132.         if ($changeSet) {
1133.             if (isset($this->entityChangeSets[$oid])) {
1134.                 $this->entityChangeSets[$oid] = array_merge($this->entityChangeSets[$oid], $changeSet);
1135.             } elseif (! isset($this->entityInsertions[$oid])) {
1136.                 $this->entityChangeSets[$oid] = $changeSet;
1137.                 $this->entityUpdates[$oid]    = $entity;
1138.             }
1140.             $this->originalEntityData[$oid] = $actualData;
1141.         }
1142.     }
1144.     /**
1145.      * Executes all entity insertions for entities of the specified type.
1146.      */
1147.     private function executeInserts(ClassMetadata $class): void
1148.     {
1149.         $entities  = [];
1150.         $className = $class->name;
1151.         $persister = $this->getEntityPersister($className);
1152.         $invoke    = $this->listenersInvoker->getSubscribedSystems($class, Events::postPersist);
1154.         $insertionsForClass = [];
1156.         foreach ($this->entityInsertions as $oid => $entity) {
1157.             if ($this->em->getClassMetadata(get_class($entity))->name !== $className) {
1158.                 continue;
1159.             }
1161.             $insertionsForClass[$oid] = $entity;
1163.             $persister->addInsert($entity);
1165.             unset($this->entityInsertions[$oid]);
1167.             if ($invoke !== ListenersInvoker::INVOKE_NONE) {
1168.                 $entities[] = $entity;
1169.             }
1170.         }
1172.         $postInsertIds = $persister->executeInserts();
1174.         if ($postInsertIds) {
1175.             // Persister returned post-insert IDs
1176.             foreach ($postInsertIds as $postInsertId) {
1177.                 $idField = $class->getSingleIdentifierFieldName();
1178.                 $idValue = $this->convertSingleFieldIdentifierToPHPValue($class, $postInsertId['generatedId']);
1180.                 $entity = $postInsertId['entity'];
1181.                 $oid    = spl_object_id($entity);
1183.                 $class->reflFields[$idField]->setValue($entity, $idValue);
1185.                 $this->entityIdentifiers[$oid]            = [$idField => $idValue];
1186.                 $this->entityStates[$oid]                 = self::STATE_MANAGED;
1187.                 $this->originalEntityData[$oid][$idField] = $idValue;
1189.                 $this->addToIdentityMap($entity);
1190.             }
1191.         } else {
1192.             foreach ($insertionsForClass as $oid => $entity) {
1193.                 if (! isset($this->entityIdentifiers[$oid])) {
1194.                     //entity was not added to identity map because some identifiers are foreign keys to new entities.
1195.                     //add it now
1196.                     $this->addToEntityIdentifiersAndEntityMap($class, $oid, $entity);
1197.                 }
1198.             }
1199.         }
1201.         foreach ($entities as $entity) {
1202.             $this->listenersInvoker->invoke($class, Events::postPersist, $entity, new PostPersistEventArgs($entity, $this->em), $invoke);
1203.         }
1204.     }
1206.     /**
1207.      * @param object $entity
1208.      * @psalm-param ClassMetadata<T> $class
1209.      * @psalm-param T $entity
1210.      *
1211.      * @template T of object
1212.      */
1213.     private function addToEntityIdentifiersAndEntityMap(
1214.         ClassMetadata $class,
1215.         int $oid,
1216.         $entity
1217.     ): void {
1218.         $identifier = [];
1220.         foreach ($class->getIdentifierFieldNames() as $idField) {
1221.             $origValue = $class->getFieldValue($entity, $idField);
1223.             $value = null;
1224.             if (isset($class->associationMappings[$idField])) {
1225.                 // NOTE: Single Columns as associated identifiers only allowed - this constraint it is enforced.
1226.                 $value = $this->getSingleIdentifierValue($origValue);
1227.             }
1229.             $identifier[$idField]                     = $value ?? $origValue;
1230.             $this->originalEntityData[$oid][$idField] = $origValue;
1231.         }
1233.         $this->entityStates[$oid]      = self::STATE_MANAGED;
1234.         $this->entityIdentifiers[$oid] = $identifier;
1236.         $this->addToIdentityMap($entity);
1237.     }
1239.     /**
1240.      * Executes all entity updates for entities of the specified type.
1241.      */
1242.     private function executeUpdates(ClassMetadata $class): void
1243.     {
1244.         $className        = $class->name;
1245.         $persister        = $this->getEntityPersister($className);
1246.         $preUpdateInvoke  = $this->listenersInvoker->getSubscribedSystems($class, Events::preUpdate);
1247.         $postUpdateInvoke = $this->listenersInvoker->getSubscribedSystems($class, Events::postUpdate);
1249.         foreach ($this->entityUpdates as $oid => $entity) {
1250.             if ($this->em->getClassMetadata(get_class($entity))->name !== $className) {
1251.                 continue;
1252.             }
1254.             if ($preUpdateInvoke !== ListenersInvoker::INVOKE_NONE) {
1255.                 $this->listenersInvoker->invoke($class, Events::preUpdate, $entity, new PreUpdateEventArgs($entity, $this->em, $this->getEntityChangeSet($entity)), $preUpdateInvoke);
1257.                 $this->recomputeSingleEntityChangeSet($class, $entity);
1258.             }
1260.             if (! empty($this->entityChangeSets[$oid])) {
1261.                 $persister->update($entity);
1262.             }
1264.             unset($this->entityUpdates[$oid]);
1266.             if ($postUpdateInvoke !== ListenersInvoker::INVOKE_NONE) {
1267.                 $this->listenersInvoker->invoke($class, Events::postUpdate, $entity, new PostUpdateEventArgs($entity, $this->em), $postUpdateInvoke);
1268.             }
1269.         }
1270.     }
1272.     /**
1273.      * Executes all entity deletions for entities of the specified type.
1274.      */
1275.     private function executeDeletions(ClassMetadata $class): void
1276.     {
1277.         $className = $class->name;
1278.         $persister = $this->getEntityPersister($className);
1279.         $invoke    = $this->listenersInvoker->getSubscribedSystems($class, Events::postRemove);
1281.         foreach ($this->entityDeletions as $oid => $entity) {
1282.             if ($this->em->getClassMetadata(get_class($entity))->name !== $className) {
1283.                 continue;
1284.             }
1286.             $persister->delete($entity);
1288.             unset(
1289.                 $this->entityDeletions[$oid],
1290.                 $this->entityIdentifiers[$oid],
1291.                 $this->originalEntityData[$oid],
1292.                 $this->entityStates[$oid]
1293.             );
1295.             // Entity with this $oid after deletion treated as NEW, even if the $oid
1296.             // is obtained by a new entity because the old one went out of scope.
1297.             //$this->entityStates[$oid] = self::STATE_NEW;
1298.             if (! $class->isIdentifierNatural()) {
1299.                 $class->reflFields[$class->identifier[0]]->setValue($entity, null);
1300.             }
1302.             if ($invoke !== ListenersInvoker::INVOKE_NONE) {
1303.                 $this->listenersInvoker->invoke($class, Events::postRemove, $entity, new PostRemoveEventArgs($entity, $this->em), $invoke);
1304.             }
1305.         }
1306.     }
1308.     /**
1309.      * Gets the commit order.
1310.      *
1311.      * @return list<ClassMetadata>
1312.      */
1313.     private function getCommitOrder(): array
1314.     {
1315.         $calc = $this->getCommitOrderCalculator();
1317.         // See if there are any new classes in the changeset, that are not in the
1318.         // commit order graph yet (don't have a node).
1319.         // We have to inspect changeSet to be able to correctly build dependencies.
1320.         // It is not possible to use IdentityMap here because post inserted ids
1321.         // are not yet available.
1322.         $newNodes = [];
1324.         foreach (array_merge($this->entityInsertions, $this->entityUpdates, $this->entityDeletions) as $entity) {
1325.             $class = $this->em->getClassMetadata(get_class($entity));
1327.             if ($calc->hasNode($class->name)) {
1328.                 continue;
1329.             }
1331.             $calc->addNode($class->name, $class);
1333.             $newNodes[] = $class;
1334.         }
1336.         // Calculate dependencies for new nodes
1337.         while ($class = array_pop($newNodes)) {
1338.             foreach ($class->associationMappings as $assoc) {
1339.                 if (! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)) {
1340.                     continue;
1341.                 }
1343.                 $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
1345.                 if (! $calc->hasNode($targetClass->name)) {
1346.                     $calc->addNode($targetClass->name, $targetClass);
1348.                     $newNodes[] = $targetClass;
1349.                 }
1351.                 $joinColumns = reset($assoc['joinColumns']);
1353.                 $calc->addDependency($targetClass->name, $class->name, (int) empty($joinColumns['nullable']));
1355.                 // If the target class has mapped subclasses, these share the same dependency.
1356.                 if (! $targetClass->subClasses) {
1357.                     continue;
1358.                 }
1360.                 foreach ($targetClass->subClasses as $subClassName) {
1361.                     $targetSubClass = $this->em->getClassMetadata($subClassName);
1363.                     if (! $calc->hasNode($subClassName)) {
1364.                         $calc->addNode($targetSubClass->name, $targetSubClass);
1366.                         $newNodes[] = $targetSubClass;
1367.                     }
1369.                     $calc->addDependency($targetSubClass->name, $class->name, 1);
1370.                 }
1371.             }
1372.         }
1374.         return $calc->sort();
1375.     }
1377.     /**
1378.      * Schedules an entity for insertion into the database.
1379.      * If the entity already has an identifier, it will be added to the identity map.
1380.      *
1381.      * @param object $entity The entity to schedule for insertion.
1382.      *
1383.      * @return void
1384.      *
1385.      * @throws ORMInvalidArgumentException
1386.      * @throws InvalidArgumentException
1387.      */
1388.     public function scheduleForInsert($entity)
1389.     {
1390.         $oid = spl_object_id($entity);
1392.         if (isset($this->entityUpdates[$oid])) {
1393.             throw new InvalidArgumentException('Dirty entity can not be scheduled for insertion.');
1394.         }
1396.         if (isset($this->entityDeletions[$oid])) {
1397.             throw ORMInvalidArgumentException::scheduleInsertForRemovedEntity($entity);
1398.         }
1400.         if (isset($this->originalEntityData[$oid]) && ! isset($this->entityInsertions[$oid])) {
1401.             throw ORMInvalidArgumentException::scheduleInsertForManagedEntity($entity);
1402.         }
1404.         if (isset($this->entityInsertions[$oid])) {
1405.             throw ORMInvalidArgumentException::scheduleInsertTwice($entity);
1406.         }
1408.         $this->entityInsertions[$oid] = $entity;
1410.         if (isset($this->entityIdentifiers[$oid])) {
1411.             $this->addToIdentityMap($entity);
1412.         }
1414.         if ($entity instanceof NotifyPropertyChanged) {
1415.             $entity->addPropertyChangedListener($this);
1416.         }
1417.     }
1419.     /**
1420.      * Checks whether an entity is scheduled for insertion.
1421.      *
1422.      * @param object $entity
1423.      *
1424.      * @return bool
1425.      */
1426.     public function isScheduledForInsert($entity)
1427.     {
1428.         return isset($this->entityInsertions[spl_object_id($entity)]);
1429.     }
1431.     /**
1432.      * Schedules an entity for being updated.
1433.      *
1434.      * @param object $entity The entity to schedule for being updated.
1435.      *
1436.      * @return void
1437.      *
1438.      * @throws ORMInvalidArgumentException
1439.      */
1440.     public function scheduleForUpdate($entity)
1441.     {
1442.         $oid = spl_object_id($entity);
1444.         if (! isset($this->entityIdentifiers[$oid])) {
1445.             throw ORMInvalidArgumentException::entityHasNoIdentity($entity, 'scheduling for update');
1446.         }
1448.         if (isset($this->entityDeletions[$oid])) {
1449.             throw ORMInvalidArgumentException::entityIsRemoved($entity, 'schedule for update');
1450.         }
1452.         if (! isset($this->entityUpdates[$oid]) && ! isset($this->entityInsertions[$oid])) {
1453.             $this->entityUpdates[$oid] = $entity;
1454.         }
1455.     }
1457.     /**
1458.      * INTERNAL:
1459.      * Schedules an extra update that will be executed immediately after the
1460.      * regular entity updates within the currently running commit cycle.
1461.      *
1462.      * Extra updates for entities are stored as (entity, changeset) tuples.
1463.      *
1464.      * @param object $entity The entity for which to schedule an extra update.
1465.      * @psalm-param array<string, array{mixed, mixed}>  $changeset The changeset of the entity (what to update).
1466.      *
1467.      * @return void
1468.      *
1469.      * @ignore
1470.      */
1471.     public function scheduleExtraUpdate($entity, array $changeset)
1472.     {
1473.         $oid         = spl_object_id($entity);
1474.         $extraUpdate = [$entity, $changeset];
1476.         if (isset($this->extraUpdates[$oid])) {
1477.             [, $changeset2] = $this->extraUpdates[$oid];
1479.             $extraUpdate = [$entity, $changeset + $changeset2];
1480.         }
1482.         $this->extraUpdates[$oid] = $extraUpdate;
1483.     }
1485.     /**
1486.      * Checks whether an entity is registered as dirty in the unit of work.
1487.      * Note: Is not very useful currently as dirty entities are only registered
1488.      * at commit time.
1489.      *
1490.      * @param object $entity
1491.      *
1492.      * @return bool
1493.      */
1494.     public function isScheduledForUpdate($entity)
1495.     {
1496.         return isset($this->entityUpdates[spl_object_id($entity)]);
1497.     }
1499.     /**
1500.      * Checks whether an entity is registered to be checked in the unit of work.
1501.      *
1502.      * @param object $entity
1503.      *
1504.      * @return bool
1505.      */
1506.     public function isScheduledForDirtyCheck($entity)
1507.     {
1508.         $rootEntityName = $this->em->getClassMetadata(get_class($entity))->rootEntityName;
1510.         return isset($this->scheduledForSynchronization[$rootEntityName][spl_object_id($entity)]);
1511.     }
1513.     /**
1514.      * INTERNAL:
1515.      * Schedules an entity for deletion.
1516.      *
1517.      * @param object $entity
1518.      *
1519.      * @return void
1520.      */
1521.     public function scheduleForDelete($entity)
1522.     {
1523.         $oid = spl_object_id($entity);
1525.         if (isset($this->entityInsertions[$oid])) {
1526.             if ($this->isInIdentityMap($entity)) {
1527.                 $this->removeFromIdentityMap($entity);
1528.             }
1530.             unset($this->entityInsertions[$oid], $this->entityStates[$oid]);
1532.             return; // entity has not been persisted yet, so nothing more to do.
1533.         }
1535.         if (! $this->isInIdentityMap($entity)) {
1536.             return;
1537.         }
1539.         $this->removeFromIdentityMap($entity);
1541.         unset($this->entityUpdates[$oid]);
1543.         if (! isset($this->entityDeletions[$oid])) {
1544.             $this->entityDeletions[$oid] = $entity;
1545.             $this->entityStates[$oid]    = self::STATE_REMOVED;
1546.         }
1547.     }
1549.     /**
1550.      * Checks whether an entity is registered as removed/deleted with the unit
1551.      * of work.
1552.      *
1553.      * @param object $entity
1554.      *
1555.      * @return bool
1556.      */
1557.     public function isScheduledForDelete($entity)
1558.     {
1559.         return isset($this->entityDeletions[spl_object_id($entity)]);
1560.     }
1562.     /**
1563.      * Checks whether an entity is scheduled for insertion, update or deletion.
1564.      *
1565.      * @param object $entity
1566.      *
1567.      * @return bool
1568.      */
1569.     public function isEntityScheduled($entity)
1570.     {
1571.         $oid = spl_object_id($entity);
1573.         return isset($this->entityInsertions[$oid])
1574.             || isset($this->entityUpdates[$oid])
1575.             || isset($this->entityDeletions[$oid]);
1576.     }
1578.     /**
1579.      * INTERNAL:
1580.      * Registers an entity in the identity map.
1581.      * Note that entities in a hierarchy are registered with the class name of
1582.      * the root entity.
1583.      *
1584.      * @param object $entity The entity to register.
1585.      *
1586.      * @return bool TRUE if the registration was successful, FALSE if the identity of
1587.      * the entity in question is already managed.
1588.      *
1589.      * @throws ORMInvalidArgumentException
1590.      *
1591.      * @ignore
1592.      */
1593.     public function addToIdentityMap($entity)
1594.     {
1595.         $classMetadata = $this->em->getClassMetadata(get_class($entity));
1596.         $idHash        = $this->getIdHashByEntity($entity);
1597.         $className     = $classMetadata->rootEntityName;
1599.         if (isset($this->identityMap[$className][$idHash])) {
1600.             return false;
1601.         }
1603.         $this->identityMap[$className][$idHash] = $entity;
1605.         return true;
1606.     }
1608.     /**
1609.      * Gets the id hash of an entity by its identifier.
1610.      *
1611.      * @param array<string|int, mixed> $identifier The identifier of an entity
1612.      *
1613.      * @return string The entity id hash.
1614.      */
1615.     final public static function getIdHashByIdentifier(array $identifier): string
1616.     {
1617.         return implode(
1618.             ' ',
1619.             array_map(
1620.                 static function ($value) {
1621.                     if ($value instanceof BackedEnum) {
1622.                         return $value->value;
1623.                     }
1625.                     return $value;
1626.                 },
1627.                 $identifier
1628.             )
1629.         );
1630.     }
1632.     /**
1633.      * Gets the id hash of an entity.
1634.      *
1635.      * @param object $entity The entity managed by Unit Of Work
1636.      *
1637.      * @return string The entity id hash.
1638.      */
1639.     public function getIdHashByEntity($entity): string
1640.     {
1641.         $identifier = $this->entityIdentifiers[spl_object_id($entity)];
1643.         if (empty($identifier) || in_array(null, $identifier, true)) {
1644.             $classMetadata = $this->em->getClassMetadata(get_class($entity));
1646.             throw ORMInvalidArgumentException::entityWithoutIdentity($classMetadata->name, $entity);
1647.         }
1649.         return self::getIdHashByIdentifier($identifier);
1650.     }
1652.     /**
1653.      * Gets the state of an entity with regard to the current unit of work.
1654.      *
1655.      * @param object   $entity
1656.      * @param int|null $assume The state to assume if the state is not yet known (not MANAGED or REMOVED).
1657.      *                         This parameter can be set to improve performance of entity state detection
1658.      *                         by potentially avoiding a database lookup if the distinction between NEW and DETACHED
1659.      *                         is either known or does not matter for the caller of the method.
1660.      * @psalm-param self::STATE_*|null $assume
1661.      *
1662.      * @return int The entity state.
1663.      * @psalm-return self::STATE_*
1664.      */
1665.     public function getEntityState($entity, $assume = null)
1666.     {
1667.         $oid = spl_object_id($entity);
1669.         if (isset($this->entityStates[$oid])) {
1670.             return $this->entityStates[$oid];
1671.         }
1673.         if ($assume !== null) {
1674.             return $assume;
1675.         }
1677.         // State can only be NEW or DETACHED, because MANAGED/REMOVED states are known.
1678.         // Note that you can not remember the NEW or DETACHED state in _entityStates since
1679.         // the UoW does not hold references to such objects and the object hash can be reused.
1680.         // More generally because the state may "change" between NEW/DETACHED without the UoW being aware of it.
1681.         $class = $this->em->getClassMetadata(get_class($entity));
1682.         $id    = $class->getIdentifierValues($entity);
1684.         if (! $id) {
1685.             return self::STATE_NEW;
1686.         }
1688.         if ($class->containsForeignIdentifier || $class->containsEnumIdentifier) {
1689.             $id = $this->identifierFlattener->flattenIdentifier($class, $id);
1690.         }
1692.         switch (true) {
1693.             case $class->isIdentifierNatural():
1694.                 // Check for a version field, if available, to avoid a db lookup.
1695.                 if ($class->isVersioned) {
1696.                     assert($class->versionField !== null);
1698.                     return $class->getFieldValue($entity, $class->versionField)
1699.                         ? self::STATE_DETACHED
1700.                         : self::STATE_NEW;
1701.                 }
1703.                 // Last try before db lookup: check the identity map.
1704.                 if ($this->tryGetById($id, $class->rootEntityName)) {
1705.                     return self::STATE_DETACHED;
1706.                 }
1708.                 // db lookup
1709.                 if ($this->getEntityPersister($class->name)->exists($entity)) {
1710.                     return self::STATE_DETACHED;
1711.                 }
1713.                 return self::STATE_NEW;
1715.             case ! $class->idGenerator->isPostInsertGenerator():
1716.                 // if we have a pre insert generator we can't be sure that having an id
1717.                 // really means that the entity exists. We have to verify this through
1718.                 // the last resort: a db lookup
1720.                 // Last try before db lookup: check the identity map.
1721.                 if ($this->tryGetById($id, $class->rootEntityName)) {
1722.                     return self::STATE_DETACHED;
1723.                 }
1725.                 // db lookup
1726.                 if ($this->getEntityPersister($class->name)->exists($entity)) {
1727.                     return self::STATE_DETACHED;
1728.                 }
1730.                 return self::STATE_NEW;
1732.             default:
1733.                 return self::STATE_DETACHED;
1734.         }
1735.     }
1737.     /**
1738.      * INTERNAL:
1739.      * Removes an entity from the identity map. This effectively detaches the
1740.      * entity from the persistence management of Doctrine.
1741.      *
1742.      * @param object $entity
1743.      *
1744.      * @return bool
1745.      *
1746.      * @throws ORMInvalidArgumentException
1747.      *
1748.      * @ignore
1749.      */
1750.     public function removeFromIdentityMap($entity)
1751.     {
1752.         $oid           = spl_object_id($entity);
1753.         $classMetadata = $this->em->getClassMetadata(get_class($entity));
1754.         $idHash        = self::getIdHashByIdentifier($this->entityIdentifiers[$oid]);
1756.         if ($idHash === '') {
1757.             throw ORMInvalidArgumentException::entityHasNoIdentity($entity, 'remove from identity map');
1758.         }
1760.         $className = $classMetadata->rootEntityName;
1762.         if (isset($this->identityMap[$className][$idHash])) {
1763.             unset($this->identityMap[$className][$idHash], $this->readOnlyObjects[$oid]);
1765.             //$this->entityStates[$oid] = self::STATE_DETACHED;
1767.             return true;
1768.         }
1770.         return false;
1771.     }
1773.     /**
1774.      * INTERNAL:
1775.      * Gets an entity in the identity map by its identifier hash.
1776.      *
1777.      * @param string $idHash
1778.      * @param string $rootClassName
1779.      *
1780.      * @return object
1781.      *
1782.      * @ignore
1783.      */
1784.     public function getByIdHash($idHash, $rootClassName)
1785.     {
1786.         return $this->identityMap[$rootClassName][$idHash];
1787.     }
1789.     /**
1790.      * INTERNAL:
1791.      * Tries to get an entity by its identifier hash. If no entity is found for
1792.      * the given hash, FALSE is returned.
1793.      *
1794.      * @param mixed  $idHash        (must be possible to cast it to string)
1795.      * @param string $rootClassName
1796.      *
1797.      * @return false|object The found entity or FALSE.
1798.      *
1799.      * @ignore
1800.      */
1801.     public function tryGetByIdHash($idHash, $rootClassName)
1802.     {
1803.         $stringIdHash = (string) $idHash;
1805.         return $this->identityMap[$rootClassName][$stringIdHash] ?? false;
1806.     }
1808.     /**
1809.      * Checks whether an entity is registered in the identity map of this UnitOfWork.
1810.      *
1811.      * @param object $entity
1812.      *
1813.      * @return bool
1814.      */
1815.     public function isInIdentityMap($entity)
1816.     {
1817.         $oid = spl_object_id($entity);
1819.         if (empty($this->entityIdentifiers[$oid])) {
1820.             return false;
1821.         }
1823.         $classMetadata = $this->em->getClassMetadata(get_class($entity));
1824.         $idHash        = self::getIdHashByIdentifier($this->entityIdentifiers[$oid]);
1826.         return isset($this->identityMap[$classMetadata->rootEntityName][$idHash]);
1827.     }
1829.     /**
1830.      * INTERNAL:
1831.      * Checks whether an identifier hash exists in the identity map.
1832.      *
1833.      * @param string $idHash
1834.      * @param string $rootClassName
1835.      *
1836.      * @return bool
1837.      *
1838.      * @ignore
1839.      */
1840.     public function containsIdHash($idHash, $rootClassName)
1841.     {
1842.         return isset($this->identityMap[$rootClassName][$idHash]);
1843.     }
1845.     /**
1846.      * Persists an entity as part of the current unit of work.
1847.      *
1848.      * @param object $entity The entity to persist.
1849.      *
1850.      * @return void
1851.      */
1852.     public function persist($entity)
1853.     {
1854.         $visited = [];
1856.         $this->doPersist($entity, $visited);
1857.     }
1859.     /**
1860.      * Persists an entity as part of the current unit of work.
1861.      *
1862.      * This method is internally called during persist() cascades as it tracks
1863.      * the already visited entities to prevent infinite recursions.
1864.      *
1865.      * @param object $entity The entity to persist.
1866.      * @psalm-param array<int, object> $visited The already visited entities.
1867.      *
1868.      * @throws ORMInvalidArgumentException
1869.      * @throws UnexpectedValueException
1870.      */
1871.     private function doPersist($entity, array &$visited): void
1872.     {
1873.         $oid = spl_object_id($entity);
1875.         if (isset($visited[$oid])) {
1876.             return; // Prevent infinite recursion
1877.         }
1879.         $visited[$oid] = $entity; // Mark visited
1881.         $class = $this->em->getClassMetadata(get_class($entity));
1883.         // We assume NEW, so DETACHED entities result in an exception on flush (constraint violation).
1884.         // If we would detect DETACHED here we would throw an exception anyway with the same
1885.         // consequences (not recoverable/programming error), so just assuming NEW here
1886.         // lets us avoid some database lookups for entities with natural identifiers.
1887.         $entityState = $this->getEntityState($entity, self::STATE_NEW);
1889.         switch ($entityState) {
1890.             case self::STATE_MANAGED:
1891.                 // Nothing to do, except if policy is "deferred explicit"
1892.                 if ($class->isChangeTrackingDeferredExplicit()) {
1893.                     $this->scheduleForDirtyCheck($entity);
1894.                 }
1896.                 break;
1898.             case self::STATE_NEW:
1899.                 $this->persistNew($class, $entity);
1900.                 break;
1902.             case self::STATE_REMOVED:
1903.                 // Entity becomes managed again
1904.                 unset($this->entityDeletions[$oid]);
1905.                 $this->addToIdentityMap($entity);
1907.                 $this->entityStates[$oid] = self::STATE_MANAGED;
1909.                 if ($class->isChangeTrackingDeferredExplicit()) {
1910.                     $this->scheduleForDirtyCheck($entity);
1911.                 }
1913.                 break;
1915.             case self::STATE_DETACHED:
1916.                 // Can actually not happen right now since we assume STATE_NEW.
1917.                 throw ORMInvalidArgumentException::detachedEntityCannot($entity, 'persisted');
1919.             default:
1920.                 throw new UnexpectedValueException(sprintf(
1921.                     'Unexpected entity state: %s. %s',
1922.                     $entityState,
1923.                     self::objToStr($entity)
1924.                 ));
1925.         }
1927.         $this->cascadePersist($entity, $visited);
1928.     }
1930.     /**
1931.      * Deletes an entity as part of the current unit of work.
1932.      *
1933.      * @param object $entity The entity to remove.
1934.      *
1935.      * @return void
1936.      */
1937.     public function remove($entity)
1938.     {
1939.         $visited = [];
1941.         $this->doRemove($entity, $visited);
1942.     }
1944.     /**
1945.      * Deletes an entity as part of the current unit of work.
1946.      *
1947.      * This method is internally called during delete() cascades as it tracks
1948.      * the already visited entities to prevent infinite recursions.
1949.      *
1950.      * @param object $entity The entity to delete.
1951.      * @psalm-param array<int, object> $visited The map of the already visited entities.
1952.      *
1953.      * @throws ORMInvalidArgumentException If the instance is a detached entity.
1954.      * @throws UnexpectedValueException
1955.      */
1956.     private function doRemove($entity, array &$visited): void
1957.     {
1958.         $oid = spl_object_id($entity);
1960.         if (isset($visited[$oid])) {
1961.             return; // Prevent infinite recursion
1962.         }
1964.         $visited[$oid] = $entity; // mark visited
1966.         // Cascade first, because scheduleForDelete() removes the entity from the identity map, which
1967.         // can cause problems when a lazy proxy has to be initialized for the cascade operation.
1968.         $this->cascadeRemove($entity, $visited);
1970.         $class       = $this->em->getClassMetadata(get_class($entity));
1971.         $entityState = $this->getEntityState($entity);
1973.         switch ($entityState) {
1974.             case self::STATE_NEW:
1975.             case self::STATE_REMOVED:
1976.                 // nothing to do
1977.                 break;
1979.             case self::STATE_MANAGED:
1980.                 $invoke = $this->listenersInvoker->getSubscribedSystems($class, Events::preRemove);
1982.                 if ($invoke !== ListenersInvoker::INVOKE_NONE) {
1983.                     $this->listenersInvoker->invoke($class, Events::preRemove, $entity, new PreRemoveEventArgs($entity, $this->em), $invoke);
1984.                 }
1986.                 $this->scheduleForDelete($entity);
1987.                 break;
1989.             case self::STATE_DETACHED:
1990.                 throw ORMInvalidArgumentException::detachedEntityCannot($entity, 'removed');
1992.             default:
1993.                 throw new UnexpectedValueException(sprintf(
1994.                     'Unexpected entity state: %s. %s',
1995.                     $entityState,
1996.                     self::objToStr($entity)
1997.                 ));
1998.         }
1999.     }
2001.     /**
2002.      * Merges the state of the given detached entity into this UnitOfWork.
2003.      *
2004.      * @deprecated 2.7 This method is being removed from the ORM and won't have any replacement
2005.      *
2006.      * @param object $entity
2007.      *
2008.      * @return object The managed copy of the entity.
2009.      *
2010.      * @throws OptimisticLockException If the entity uses optimistic locking through a version
2011.      *         attribute and the version check against the managed copy fails.
2012.      */
2013.     public function merge($entity)
2014.     {
2015.         $visited = [];
2017.         return $this->doMerge($entity, $visited);
2018.     }
2020.     /**
2021.      * Executes a merge operation on an entity.
2022.      *
2023.      * @param object $entity
2024.      * @psalm-param AssociationMapping|null $assoc
2025.      * @psalm-param array<int, object> $visited
2026.      *
2027.      * @return object The managed copy of the entity.
2028.      *
2029.      * @throws OptimisticLockException If the entity uses optimistic locking through a version
2030.      *         attribute and the version check against the managed copy fails.
2031.      * @throws ORMInvalidArgumentException If the entity instance is NEW.
2032.      * @throws EntityNotFoundException if an assigned identifier is used in the entity, but none is provided.
2033.      */
2034.     private function doMerge(
2035.         $entity,
2036.         array &$visited,
2037.         $prevManagedCopy = null,
2038.         ?array $assoc = null
2039.     ) {
2040.         $oid = spl_object_id($entity);
2042.         if (isset($visited[$oid])) {
2043.             $managedCopy = $visited[$oid];
2045.             if ($prevManagedCopy !== null) {
2046.                 $this->updateAssociationWithMergedEntity($entity, $assoc, $prevManagedCopy, $managedCopy);
2047.             }
2049.             return $managedCopy;
2050.         }
2052.         $class = $this->em->getClassMetadata(get_class($entity));
2054.         // First we assume DETACHED, although it can still be NEW but we can avoid
2055.         // an extra db-roundtrip this way. If it is not MANAGED but has an identity,
2056.         // we need to fetch it from the db anyway in order to merge.
2057.         // MANAGED entities are ignored by the merge operation.
2058.         $managedCopy = $entity;
2060.         if ($this->getEntityState($entity, self::STATE_DETACHED) !== self::STATE_MANAGED) {
2061.             // Try to look the entity up in the identity map.
2062.             $id = $class->getIdentifierValues($entity);
2064.             // If there is no ID, it is actually NEW.
2065.             if (! $id) {
2066.                 $managedCopy = $this->newInstance($class);
2068.                 $this->mergeEntityStateIntoManagedCopy($entity, $managedCopy);
2069.                 $this->persistNew($class, $managedCopy);
2070.             } else {
2071.                 $flatId = $class->containsForeignIdentifier || $class->containsEnumIdentifier
2072.                     ? $this->identifierFlattener->flattenIdentifier($class, $id)
2073.                     : $id;
2075.                 $managedCopy = $this->tryGetById($flatId, $class->rootEntityName);
2077.                 if ($managedCopy) {
2078.                     // We have the entity in-memory already, just make sure its not removed.
2079.                     if ($this->getEntityState($managedCopy) === self::STATE_REMOVED) {
2080.                         throw ORMInvalidArgumentException::entityIsRemoved($managedCopy, 'merge');
2081.                     }
2082.                 } else {
2083.                     // We need to fetch the managed copy in order to merge.
2084.                     $managedCopy = $this->em->find($class->name, $flatId);
2085.                 }
2087.                 if ($managedCopy === null) {
2088.                     // If the identifier is ASSIGNED, it is NEW, otherwise an error
2089.                     // since the managed entity was not found.
2090.                     if (! $class->isIdentifierNatural()) {
2091.                         throw EntityNotFoundException::fromClassNameAndIdentifier(
2092.                             $class->getName(),
2093.                             $this->identifierFlattener->flattenIdentifier($class, $id)
2094.                         );
2095.                     }
2097.                     $managedCopy = $this->newInstance($class);
2098.                     $class->setIdentifierValues($managedCopy, $id);
2100.                     $this->mergeEntityStateIntoManagedCopy($entity, $managedCopy);
2101.                     $this->persistNew($class, $managedCopy);
2102.                 } else {
2103.                     $this->ensureVersionMatch($class, $entity, $managedCopy);
2104.                     $this->mergeEntityStateIntoManagedCopy($entity, $managedCopy);
2105.                 }
2106.             }
2108.             $visited[$oid] = $managedCopy; // mark visited
2110.             if ($class->isChangeTrackingDeferredExplicit()) {
2111.                 $this->scheduleForDirtyCheck($entity);
2112.             }
2113.         }
2115.         if ($prevManagedCopy !== null) {
2116.             $this->updateAssociationWithMergedEntity($entity, $assoc, $prevManagedCopy, $managedCopy);
2117.         }
2119.         // Mark the managed copy visited as well
2120.         $visited[spl_object_id($managedCopy)] = $managedCopy;
2122.         $this->cascadeMerge($entity, $managedCopy, $visited);
2124.         return $managedCopy;
2125.     }
2127.     /**
2128.      * @param object $entity
2129.      * @param object $managedCopy
2130.      * @psalm-param ClassMetadata<T> $class
2131.      * @psalm-param T $entity
2132.      * @psalm-param T $managedCopy
2133.      *
2134.      * @throws OptimisticLockException
2135.      *
2136.      * @template T of object
2137.      */
2138.     private function ensureVersionMatch(
2139.         ClassMetadata $class,
2140.         $entity,
2141.         $managedCopy
2142.     ): void {
2143.         if (! ($class->isVersioned && $this->isLoaded($managedCopy) && $this->isLoaded($entity))) {
2144.             return;
2145.         }
2147.         assert($class->versionField !== null);
2148.         $reflField          = $class->reflFields[$class->versionField];
2149.         $managedCopyVersion = $reflField->getValue($managedCopy);
2150.         $entityVersion      = $reflField->getValue($entity);
2152.         // Throw exception if versions don't match.
2153.         // phpcs:ignore SlevomatCodingStandard.Operators.DisallowEqualOperators.DisallowedEqualOperator
2154.         if ($managedCopyVersion == $entityVersion) {
2155.             return;
2156.         }
2158.         throw OptimisticLockException::lockFailedVersionMismatch($entity, $entityVersion, $managedCopyVersion);
2159.     }
2161.     /**
2162.      * Tests if an entity is loaded - must either be a loaded proxy or not a proxy
2163.      *
2164.      * @param object $entity
2165.      */
2166.     private function isLoaded($entity): bool
2167.     {
2168.         return ! ($entity instanceof Proxy) || $entity->__isInitialized();
2169.     }
2171.     /**
2172.      * Sets/adds associated managed copies into the previous entity's association field
2173.      *
2174.      * @param object $entity
2175.      * @psalm-param AssociationMapping $association
2176.      */
2177.     private function updateAssociationWithMergedEntity(
2178.         $entity,
2179.         array $association,
2180.         $previousManagedCopy,
2181.         $managedCopy
2182.     ): void {
2183.         $assocField = $association['fieldName'];
2184.         $prevClass  = $this->em->getClassMetadata(get_class($previousManagedCopy));
2186.         if ($association['type'] & ClassMetadata::TO_ONE) {
2187.             $prevClass->reflFields[$assocField]->setValue($previousManagedCopy, $managedCopy);
2189.             return;
2190.         }
2192.         $value   = $prevClass->reflFields[$assocField]->getValue($previousManagedCopy);
2193.         $value[] = $managedCopy;
2195.         if ($association['type'] === ClassMetadata::ONE_TO_MANY) {
2196.             $class = $this->em->getClassMetadata(get_class($entity));
2198.             $class->reflFields[$association['mappedBy']]->setValue($managedCopy, $previousManagedCopy);
2199.         }
2200.     }
2202.     /**
2203.      * Detaches an entity from the persistence management. It's persistence will
2204.      * no longer be managed by Doctrine.
2205.      *
2206.      * @param object $entity The entity to detach.
2207.      *
2208.      * @return void
2209.      */
2210.     public function detach($entity)
2211.     {
2212.         $visited = [];
2214.         $this->doDetach($entity, $visited);
2215.     }
2217.     /**
2218.      * Executes a detach operation on the given entity.
2219.      *
2220.      * @param object  $entity
2221.      * @param mixed[] $visited
2222.      * @param bool    $noCascade if true, don't cascade detach operation.
2223.      */
2224.     private function doDetach(
2225.         $entity,
2226.         array &$visited,
2227.         bool $noCascade = false
2228.     ): void {
2229.         $oid = spl_object_id($entity);
2231.         if (isset($visited[$oid])) {
2232.             return; // Prevent infinite recursion
2233.         }
2235.         $visited[$oid] = $entity; // mark visited
2237.         switch ($this->getEntityState($entity, self::STATE_DETACHED)) {
2238.             case self::STATE_MANAGED:
2239.                 if ($this->isInIdentityMap($entity)) {
2240.                     $this->removeFromIdentityMap($entity);
2241.                 }
2243.                 unset(
2244.                     $this->entityInsertions[$oid],
2245.                     $this->entityUpdates[$oid],
2246.                     $this->entityDeletions[$oid],
2247.                     $this->entityIdentifiers[$oid],
2248.                     $this->entityStates[$oid],
2249.                     $this->originalEntityData[$oid]
2250.                 );
2251.                 break;
2252.             case self::STATE_NEW:
2253.             case self::STATE_DETACHED:
2254.                 return;
2255.         }
2257.         if (! $noCascade) {
2258.             $this->cascadeDetach($entity, $visited);
2259.         }
2260.     }
2262.     /**
2263.      * Refreshes the state of the given entity from the database, overwriting
2264.      * any local, unpersisted changes.
2265.      *
2266.      * @param object $entity The entity to refresh
2267.      *
2268.      * @return void
2269.      *
2270.      * @throws InvalidArgumentException If the entity is not MANAGED.
2271.      * @throws TransactionRequiredException
2272.      */
2273.     public function refresh($entity)
2274.     {
2275.         $visited = [];
2277.         $lockMode = null;
2279.         if (func_num_args() > 1) {
2280.             $lockMode = func_get_arg(1);
2281.         }
2283.         $this->doRefresh($entity, $visited, $lockMode);
2284.     }
2286.     /**
2287.      * Executes a refresh operation on an entity.
2288.      *
2289.      * @param object $entity The entity to refresh.
2290.      * @psalm-param array<int, object>  $visited The already visited entities during cascades.
2291.      * @psalm-param LockMode::*|null $lockMode
2292.      *
2293.      * @throws ORMInvalidArgumentException If the entity is not MANAGED.
2294.      * @throws TransactionRequiredException
2295.      */
2296.     private function doRefresh($entity, array &$visited, ?int $lockMode = null): void
2297.     {
2298.         switch (true) {
2299.             case $lockMode === LockMode::PESSIMISTIC_READ:
2300.             case $lockMode === LockMode::PESSIMISTIC_WRITE:
2301.                 if (! $this->em->getConnection()->isTransactionActive()) {
2302.                     throw TransactionRequiredException::transactionRequired();
2303.                 }
2304.         }
2306.         $oid = spl_object_id($entity);
2308.         if (isset($visited[$oid])) {
2309.             return; // Prevent infinite recursion
2310.         }
2312.         $visited[$oid] = $entity; // mark visited
2314.         $class = $this->em->getClassMetadata(get_class($entity));
2316.         if ($this->getEntityState($entity) !== self::STATE_MANAGED) {
2317.             throw ORMInvalidArgumentException::entityNotManaged($entity);
2318.         }
2320.         $this->getEntityPersister($class->name)->refresh(
2321.             array_combine($class->getIdentifierFieldNames(), $this->entityIdentifiers[$oid]),
2322.             $entity,
2323.             $lockMode
2324.         );
2326.         $this->cascadeRefresh($entity, $visited, $lockMode);
2327.     }
2329.     /**
2330.      * Cascades a refresh operation to associated entities.
2331.      *
2332.      * @param object $entity
2333.      * @psalm-param array<int, object> $visited
2334.      * @psalm-param LockMode::*|null $lockMode
2335.      */
2336.     private function cascadeRefresh($entity, array &$visited, ?int $lockMode = null): void
2337.     {
2338.         $class = $this->em->getClassMetadata(get_class($entity));
2340.         $associationMappings = array_filter(
2341.             $class->associationMappings,
2342.             static function ($assoc) {
2343.                 return $assoc['isCascadeRefresh'];
2344.             }
2345.         );
2347.         foreach ($associationMappings as $assoc) {
2348.             $relatedEntities = $class->reflFields[$assoc['fieldName']]->getValue($entity);
2350.             switch (true) {
2351.                 case $relatedEntities instanceof PersistentCollection:
2352.                     // Unwrap so that foreach() does not initialize
2353.                     $relatedEntities = $relatedEntities->unwrap();
2354.                     // break; is commented intentionally!
2356.                 case $relatedEntities instanceof Collection:
2357.                 case is_array($relatedEntities):
2358.                     foreach ($relatedEntities as $relatedEntity) {
2359.                         $this->doRefresh($relatedEntity, $visited, $lockMode);
2360.                     }
2362.                     break;
2364.                 case $relatedEntities !== null:
2365.                     $this->doRefresh($relatedEntities, $visited, $lockMode);
2366.                     break;
2368.                 default:
2369.                     // Do nothing
2370.             }
2371.         }
2372.     }
2374.     /**
2375.      * Cascades a detach operation to associated entities.
2376.      *
2377.      * @param object             $entity
2378.      * @param array<int, object> $visited
2379.      */
2380.     private function cascadeDetach($entity, array &$visited): void
2381.     {
2382.         $class = $this->em->getClassMetadata(get_class($entity));
2384.         $associationMappings = array_filter(
2385.             $class->associationMappings,
2386.             static function ($assoc) {
2387.                 return $assoc['isCascadeDetach'];
2388.             }
2389.         );
2391.         foreach ($associationMappings as $assoc) {
2392.             $relatedEntities = $class->reflFields[$assoc['fieldName']]->getValue($entity);
2394.             switch (true) {
2395.                 case $relatedEntities instanceof PersistentCollection:
2396.                     // Unwrap so that foreach() does not initialize
2397.                     $relatedEntities = $relatedEntities->unwrap();
2398.                     // break; is commented intentionally!
2400.                 case $relatedEntities instanceof Collection:
2401.                 case is_array($relatedEntities):
2402.                     foreach ($relatedEntities as $relatedEntity) {
2403.                         $this->doDetach($relatedEntity, $visited);
2404.                     }
2406.                     break;
2408.                 case $relatedEntities !== null:
2409.                     $this->doDetach($relatedEntities, $visited);
2410.                     break;
2412.                 default:
2413.                     // Do nothing
2414.             }
2415.         }
2416.     }
2418.     /**
2419.      * Cascades a merge operation to associated entities.
2420.      *
2421.      * @param object $entity
2422.      * @param object $managedCopy
2423.      * @psalm-param array<int, object> $visited
2424.      */
2425.     private function cascadeMerge($entity, $managedCopy, array &$visited): void
2426.     {
2427.         $class = $this->em->getClassMetadata(get_class($entity));
2429.         $associationMappings = array_filter(
2430.             $class->associationMappings,
2431.             static function ($assoc) {
2432.                 return $assoc['isCascadeMerge'];
2433.             }
2434.         );
2436.         foreach ($associationMappings as $assoc) {
2437.             $relatedEntities = $class->reflFields[$assoc['fieldName']]->getValue($entity);
2439.             if ($relatedEntities instanceof Collection) {
2440.                 if ($relatedEntities === $class->reflFields[$assoc['fieldName']]->getValue($managedCopy)) {
2441.                     continue;
2442.                 }
2444.                 if ($relatedEntities instanceof PersistentCollection) {
2445.                     // Unwrap so that foreach() does not initialize
2446.                     $relatedEntities = $relatedEntities->unwrap();
2447.                 }
2449.                 foreach ($relatedEntities as $relatedEntity) {
2450.                     $this->doMerge($relatedEntity, $visited, $managedCopy, $assoc);
2451.                 }
2452.             } elseif ($relatedEntities !== null) {
2453.                 $this->doMerge($relatedEntities, $visited, $managedCopy, $assoc);
2454.             }
2455.         }
2456.     }
2458.     /**
2459.      * Cascades the save operation to associated entities.
2460.      *
2461.      * @param object $entity
2462.      * @psalm-param array<int, object> $visited
2463.      */
2464.     private function cascadePersist($entity, array &$visited): void
2465.     {
2466.         if ($entity instanceof Proxy && ! $entity->__isInitialized()) {
2467.             // nothing to do - proxy is not initialized, therefore we don't do anything with it
2468.             return;
2469.         }
2471.         $class = $this->em->getClassMetadata(get_class($entity));
2473.         $associationMappings = array_filter(
2474.             $class->associationMappings,
2475.             static function ($assoc) {
2476.                 return $assoc['isCascadePersist'];
2477.             }
2478.         );
2480.         foreach ($associationMappings as $assoc) {
2481.             $relatedEntities = $class->reflFields[$assoc['fieldName']]->getValue($entity);
2483.             switch (true) {
2484.                 case $relatedEntities instanceof PersistentCollection:
2485.                     // Unwrap so that foreach() does not initialize
2486.                     $relatedEntities = $relatedEntities->unwrap();
2487.                     // break; is commented intentionally!
2489.                 case $relatedEntities instanceof Collection:
2490.                 case is_array($relatedEntities):
2491.                     if (($assoc['type'] & ClassMetadata::TO_MANY) <= 0) {
2492.                         throw ORMInvalidArgumentException::invalidAssociation(
2493.                             $this->em->getClassMetadata($assoc['targetEntity']),
2494.                             $assoc,
2495.                             $relatedEntities
2496.                         );
2497.                     }
2499.                     foreach ($relatedEntities as $relatedEntity) {
2500.                         $this->doPersist($relatedEntity, $visited);
2501.                     }
2503.                     break;
2505.                 case $relatedEntities !== null:
2506.                     if (! $relatedEntities instanceof $assoc['targetEntity']) {
2507.                         throw ORMInvalidArgumentException::invalidAssociation(
2508.                             $this->em->getClassMetadata($assoc['targetEntity']),
2509.                             $assoc,
2510.                             $relatedEntities
2511.                         );
2512.                     }
2514.                     $this->doPersist($relatedEntities, $visited);
2515.                     break;
2517.                 default:
2518.                     // Do nothing
2519.             }
2520.         }
2521.     }
2523.     /**
2524.      * Cascades the delete operation to associated entities.
2525.      *
2526.      * @param object $entity
2527.      * @psalm-param array<int, object> $visited
2528.      */
2529.     private function cascadeRemove($entity, array &$visited): void
2530.     {
2531.         $class = $this->em->getClassMetadata(get_class($entity));
2533.         $associationMappings = array_filter(
2534.             $class->associationMappings,
2535.             static function ($assoc) {
2536.                 return $assoc['isCascadeRemove'];
2537.             }
2538.         );
2540.         $entitiesToCascade = [];
2542.         foreach ($associationMappings as $assoc) {
2543.             if ($entity instanceof Proxy && ! $entity->__isInitialized()) {
2544.                 $entity->__load();
2545.             }
2547.             $relatedEntities = $class->reflFields[$assoc['fieldName']]->getValue($entity);
2549.             switch (true) {
2550.                 case $relatedEntities instanceof Collection:
2551.                 case is_array($relatedEntities):
2552.                     // If its a PersistentCollection initialization is intended! No unwrap!
2553.                     foreach ($relatedEntities as $relatedEntity) {
2554.                         $entitiesToCascade[] = $relatedEntity;
2555.                     }
2557.                     break;
2559.                 case $relatedEntities !== null:
2560.                     $entitiesToCascade[] = $relatedEntities;
2561.                     break;
2563.                 default:
2564.                     // Do nothing
2565.             }
2566.         }
2568.         foreach ($entitiesToCascade as $relatedEntity) {
2569.             $this->doRemove($relatedEntity, $visited);
2570.         }
2571.     }
2573.     /**
2574.      * Acquire a lock on the given entity.
2575.      *
2576.      * @param object                     $entity
2577.      * @param int|DateTimeInterface|null $lockVersion
2578.      * @psalm-param LockMode::* $lockMode
2579.      *
2580.      * @throws ORMInvalidArgumentException
2581.      * @throws TransactionRequiredException
2582.      * @throws OptimisticLockException
2583.      */
2584.     public function lock($entity, int $lockMode, $lockVersion = null): void
2585.     {
2586.         if ($this->getEntityState($entity, self::STATE_DETACHED) !== self::STATE_MANAGED) {
2587.             throw ORMInvalidArgumentException::entityNotManaged($entity);
2588.         }
2590.         $class = $this->em->getClassMetadata(get_class($entity));
2592.         switch (true) {
2593.             case $lockMode === LockMode::OPTIMISTIC:
2594.                 if (! $class->isVersioned) {
2595.                     throw OptimisticLockException::notVersioned($class->name);
2596.                 }
2598.                 if ($lockVersion === null) {
2599.                     return;
2600.                 }
2602.                 if ($entity instanceof Proxy && ! $entity->__isInitialized()) {
2603.                     $entity->__load();
2604.                 }
2606.                 assert($class->versionField !== null);
2607.                 $entityVersion = $class->reflFields[$class->versionField]->getValue($entity);
2609.                 // phpcs:ignore SlevomatCodingStandard.Operators.DisallowEqualOperators.DisallowedNotEqualOperator
2610.                 if ($entityVersion != $lockVersion) {
2611.                     throw OptimisticLockException::lockFailedVersionMismatch($entity, $lockVersion, $entityVersion);
2612.                 }
2614.                 break;
2616.             case $lockMode === LockMode::NONE:
2617.             case $lockMode === LockMode::PESSIMISTIC_READ:
2618.             case $lockMode === LockMode::PESSIMISTIC_WRITE:
2619.                 if (! $this->em->getConnection()->isTransactionActive()) {
2620.                     throw TransactionRequiredException::transactionRequired();
2621.                 }
2623.                 $oid = spl_object_id($entity);
2625.                 $this->getEntityPersister($class->name)->lock(
2626.                     array_combine($class->getIdentifierFieldNames(), $this->entityIdentifiers[$oid]),
2627.                     $lockMode
2628.                 );
2629.                 break;
2631.             default:
2632.                 // Do nothing
2633.         }
2634.     }
2636.     /**
2637.      * Gets the CommitOrderCalculator used by the UnitOfWork to order commits.
2638.      *
2639.      * @return CommitOrderCalculator
2640.      */
2641.     public function getCommitOrderCalculator()
2642.     {
2643.         return new Internal\CommitOrderCalculator();
2644.     }
2646.     /**
2647.      * Clears the UnitOfWork.
2648.      *
2649.      * @param string|null $entityName if given, only entities of this type will get detached.
2650.      *
2651.      * @return void
2652.      *
2653.      * @throws ORMInvalidArgumentException if an invalid entity name is given.
2654.      */
2655.     public function clear($entityName = null)
2656.     {
2657.         if ($entityName === null) {
2658.             $this->identityMap                      =
2659.             $this->entityIdentifiers                =
2660.             $this->originalEntityData               =
2661.             $this->entityChangeSets                 =
2662.             $this->entityStates                     =
2663.             $this->scheduledForSynchronization      =
2664.             $this->entityInsertions                 =
2665.             $this->entityUpdates                    =
2666.             $this->entityDeletions                  =
2667.             $this->nonCascadedNewDetectedEntities   =
2668.             $this->collectionDeletions              =
2669.             $this->collectionUpdates                =
2670.             $this->extraUpdates                     =
2671.             $this->readOnlyObjects                  =
2672.             $this->pendingCollectionElementRemovals =
2673.             $this->visitedCollections               =
2674.             $this->eagerLoadingEntities             =
2675.             $this->orphanRemovals                   = [];
2676.         } else {
2677.             Deprecation::triggerIfCalledFromOutside(
2678.                 'doctrine/orm',
2679.                 'https://github.com/doctrine/orm/issues/8460',
2680.                 'Calling %s() with any arguments to clear specific entities is deprecated and will not be supported in Doctrine ORM 3.0.',
2681.                 __METHOD__
2682.             );
2684.             $this->clearIdentityMapForEntityName($entityName);
2685.             $this->clearEntityInsertionsForEntityName($entityName);
2686.         }
2688.         if ($this->evm->hasListeners(Events::onClear)) {
2689.             $this->evm->dispatchEvent(Events::onClear, new Event\OnClearEventArgs($this->em, $entityName));
2690.         }
2691.     }
2693.     /**
2694.      * INTERNAL:
2695.      * Schedules an orphaned entity for removal. The remove() operation will be
2696.      * invoked on that entity at the beginning of the next commit of this
2697.      * UnitOfWork.
2698.      *
2699.      * @param object $entity
2700.      *
2701.      * @return void
2702.      *
2703.      * @ignore
2704.      */
2705.     public function scheduleOrphanRemoval($entity)
2706.     {
2707.         $this->orphanRemovals[spl_object_id($entity)] = $entity;
2708.     }
2710.     /**
2711.      * INTERNAL:
2712.      * Cancels a previously scheduled orphan removal.
2713.      *
2714.      * @param object $entity
2715.      *
2716.      * @return void
2717.      *
2718.      * @ignore
2719.      */
2720.     public function cancelOrphanRemoval($entity)
2721.     {
2722.         unset($this->orphanRemovals[spl_object_id($entity)]);
2723.     }
2725.     /**
2726.      * INTERNAL:
2727.      * Schedules a complete collection for removal when this UnitOfWork commits.
2728.      *
2729.      * @return void
2730.      */
2731.     public function scheduleCollectionDeletion(PersistentCollection $coll)
2732.     {
2733.         $coid = spl_object_id($coll);
2735.         // TODO: if $coll is already scheduled for recreation ... what to do?
2736.         // Just remove $coll from the scheduled recreations?
2737.         unset($this->collectionUpdates[$coid]);
2739.         $this->collectionDeletions[$coid] = $coll;
2740.     }
2742.     /** @return bool */
2743.     public function isCollectionScheduledForDeletion(PersistentCollection $coll)
2744.     {
2745.         return isset($this->collectionDeletions[spl_object_id($coll)]);
2746.     }
2748.     /** @return object */
2749.     private function newInstance(ClassMetadata $class)
2750.     {
2751.         $entity = $class->newInstance();
2753.         if ($entity instanceof ObjectManagerAware) {
2754.             $entity->injectObjectManager($this->em, $class);
2755.         }
2757.         return $entity;
2758.     }
2760.     /**
2761.      * INTERNAL:
2762.      * Creates an entity. Used for reconstitution of persistent entities.
2763.      *
2764.      * Internal note: Highly performance-sensitive method.
2765.      *
2766.      * @param string  $className The name of the entity class.
2767.      * @param mixed[] $data      The data for the entity.
2768.      * @param mixed[] $hints     Any hints to account for during reconstitution/lookup of the entity.
2769.      * @psalm-param class-string $className
2770.      * @psalm-param array<string, mixed> $hints
2771.      *
2772.      * @return object The managed entity instance.
2773.      *
2774.      * @ignore
2775.      * @todo Rename: getOrCreateEntity
2776.      */
2777.     public function createEntity($className, array $data, &$hints = [])
2778.     {
2779.         $class = $this->em->getClassMetadata($className);
2781.         $id     = $this->identifierFlattener->flattenIdentifier($class, $data);
2782.         $idHash = self::getIdHashByIdentifier($id);
2784.         if (isset($this->identityMap[$class->rootEntityName][$idHash])) {
2785.             $entity = $this->identityMap[$class->rootEntityName][$idHash];
2786.             $oid    = spl_object_id($entity);
2788.             if (
2789.                 isset($hints[Query::HINT_REFRESH], $hints[Query::HINT_REFRESH_ENTITY])
2790.             ) {
2791.                 $unmanagedProxy = $hints[Query::HINT_REFRESH_ENTITY];
2792.                 if (
2793.                     $unmanagedProxy !== $entity
2794.                     && $unmanagedProxy instanceof Proxy
2795.                     && $this->isIdentifierEquals($unmanagedProxy, $entity)
2796.                 ) {
2797.                     // We will hydrate the given un-managed proxy anyway:
2798.                     // continue work, but consider it the entity from now on
2799.                     $entity = $unmanagedProxy;
2800.                 }
2801.             }
2803.             if ($entity instanceof Proxy && ! $entity->__isInitialized()) {
2804.                 $entity->__setInitialized(true);
2805.             } else {
2806.                 if (
2807.                     ! isset($hints[Query::HINT_REFRESH])
2808.                     || (isset($hints[Query::HINT_REFRESH_ENTITY]) && $hints[Query::HINT_REFRESH_ENTITY] !== $entity)
2809.                 ) {
2810.                     return $entity;
2811.                 }
2812.             }
2814.             // inject ObjectManager upon refresh.
2815.             if ($entity instanceof ObjectManagerAware) {
2816.                 $entity->injectObjectManager($this->em, $class);
2817.             }
2819.             $this->originalEntityData[$oid] = $data;
2820.         } else {
2821.             $entity = $this->newInstance($class);
2822.             $oid    = spl_object_id($entity);
2824.             $this->entityIdentifiers[$oid]  = $id;
2825.             $this->entityStates[$oid]       = self::STATE_MANAGED;
2826.             $this->originalEntityData[$oid] = $data;
2828.             $this->identityMap[$class->rootEntityName][$idHash] = $entity;
2830.             if (isset($hints[Query::HINT_READ_ONLY])) {
2831.                 $this->readOnlyObjects[$oid] = true;
2832.             }
2833.         }
2835.         if ($entity instanceof NotifyPropertyChanged) {
2836.             $entity->addPropertyChangedListener($this);
2837.         }
2839.         foreach ($data as $field => $value) {
2840.             if (isset($class->fieldMappings[$field])) {
2841.                 $class->reflFields[$field]->setValue($entity, $value);
2842.             }
2843.         }
2845.         // Loading the entity right here, if its in the eager loading map get rid of it there.
2846.         unset($this->eagerLoadingEntities[$class->rootEntityName][$idHash]);
2848.         if (isset($this->eagerLoadingEntities[$class->rootEntityName]) && ! $this->eagerLoadingEntities[$class->rootEntityName]) {
2849.             unset($this->eagerLoadingEntities[$class->rootEntityName]);
2850.         }
2852.         // Properly initialize any unfetched associations, if partial objects are not allowed.
2853.         if (isset($hints[Query::HINT_FORCE_PARTIAL_LOAD])) {
2854.             Deprecation::trigger(
2855.                 'doctrine/orm',
2856.                 'https://github.com/doctrine/orm/issues/8471',
2857.                 'Partial Objects are deprecated (here entity %s)',
2858.                 $className
2859.             );
2861.             return $entity;
2862.         }
2864.         foreach ($class->associationMappings as $field => $assoc) {
2865.             // Check if the association is not among the fetch-joined associations already.
2866.             if (isset($hints['fetchAlias'], $hints['fetched'][$hints['fetchAlias']][$field])) {
2867.                 continue;
2868.             }
2870.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
2872.             switch (true) {
2873.                 case $assoc['type'] & ClassMetadata::TO_ONE:
2874.                     if (! $assoc['isOwningSide']) {
2875.                         // use the given entity association
2876.                         if (isset($data[$field]) && is_object($data[$field]) && isset($this->entityStates[spl_object_id($data[$field])])) {
2877.                             $this->originalEntityData[$oid][$field] = $data[$field];
2879.                             $class->reflFields[$field]->setValue($entity, $data[$field]);
2880.                             $targetClass->reflFields[$assoc['mappedBy']]->setValue($data[$field], $entity);
2882.                             continue 2;
2883.                         }
2885.                         // Inverse side of x-to-one can never be lazy
2886.                         $class->reflFields[$field]->setValue($entity, $this->getEntityPersister($assoc['targetEntity'])->loadOneToOneEntity($assoc, $entity));
2888.                         continue 2;
2889.                     }
2891.                     // use the entity association
2892.                     if (isset($data[$field]) && is_object($data[$field]) && isset($this->entityStates[spl_object_id($data[$field])])) {
2893.                         $class->reflFields[$field]->setValue($entity, $data[$field]);
2894.                         $this->originalEntityData[$oid][$field] = $data[$field];
2896.                         break;
2897.                     }
2899.                     $associatedId = [];
2901.                     // TODO: Is this even computed right in all cases of composite keys?
2902.                     foreach ($assoc['targetToSourceKeyColumns'] as $targetColumn => $srcColumn) {
2903.                         $joinColumnValue = $data[$srcColumn] ?? null;
2905.                         if ($joinColumnValue !== null) {
2906.                             if ($joinColumnValue instanceof BackedEnum) {
2907.                                 $joinColumnValue = $joinColumnValue->value;
2908.                             }
2910.                             if ($targetClass->containsForeignIdentifier) {
2911.                                 $associatedId[$targetClass->getFieldForColumn($targetColumn)] = $joinColumnValue;
2912.                             } else {
2913.                                 $associatedId[$targetClass->fieldNames[$targetColumn]] = $joinColumnValue;
2914.                             }
2915.                         } elseif (
2916.                             $targetClass->containsForeignIdentifier
2917.                             && in_array($targetClass->getFieldForColumn($targetColumn), $targetClass->identifier, true)
2918.                         ) {
2919.                             // the missing key is part of target's entity primary key
2920.                             $associatedId = [];
2921.                             break;
2922.                         }
2923.                     }
2925.                     if (! $associatedId) {
2926.                         // Foreign key is NULL
2927.                         $class->reflFields[$field]->setValue($entity, null);
2928.                         $this->originalEntityData[$oid][$field] = null;
2930.                         break;
2931.                     }
2933.                     if (! isset($hints['fetchMode'][$class->name][$field])) {
2934.                         $hints['fetchMode'][$class->name][$field] = $assoc['fetch'];
2935.                     }
2937.                     // Foreign key is set
2938.                     // Check identity map first
2939.                     // FIXME: Can break easily with composite keys if join column values are in
2940.                     //        wrong order. The correct order is the one in ClassMetadata#identifier.
2941.                     $relatedIdHash = self::getIdHashByIdentifier($associatedId);
2943.                     switch (true) {
2944.                         case isset($this->identityMap[$targetClass->rootEntityName][$relatedIdHash]):
2945.                             $newValue = $this->identityMap[$targetClass->rootEntityName][$relatedIdHash];
2947.                             // If this is an uninitialized proxy, we are deferring eager loads,
2948.                             // this association is marked as eager fetch, and its an uninitialized proxy (wtf!)
2949.                             // then we can append this entity for eager loading!
2950.                             if (
2951.                                 $hints['fetchMode'][$class->name][$field] === ClassMetadata::FETCH_EAGER &&
2952.                                 isset($hints[self::HINT_DEFEREAGERLOAD]) &&
2953.                                 ! $targetClass->isIdentifierComposite &&
2954.                                 $newValue instanceof Proxy &&
2955.                                 $newValue->__isInitialized() === false
2956.                             ) {
2957.                                 $this->eagerLoadingEntities[$targetClass->rootEntityName][$relatedIdHash] = current($associatedId);
2958.                             }
2960.                             break;
2962.                         case $targetClass->subClasses:
2963.                             // If it might be a subtype, it can not be lazy. There isn't even
2964.                             // a way to solve this with deferred eager loading, which means putting
2965.                             // an entity with subclasses at a *-to-one location is really bad! (performance-wise)
2966.                             $newValue = $this->getEntityPersister($assoc['targetEntity'])->loadOneToOneEntity($assoc, $entity, $associatedId);
2967.                             break;
2969.                         default:
2970.                             $normalizedAssociatedId = $this->normalizeIdentifier($targetClass, $associatedId);
2972.                             switch (true) {
2973.                                 // We are negating the condition here. Other cases will assume it is valid!
2974.                                 case $hints['fetchMode'][$class->name][$field] !== ClassMetadata::FETCH_EAGER:
2975.                                     $newValue = $this->em->getProxyFactory()->getProxy($assoc['targetEntity'], $normalizedAssociatedId);
2976.                                     break;
2978.                                 // Deferred eager load only works for single identifier classes
2979.                                 case isset($hints[self::HINT_DEFEREAGERLOAD]) && ! $targetClass->isIdentifierComposite:
2980.                                     // TODO: Is there a faster approach?
2981.                                     $this->eagerLoadingEntities[$targetClass->rootEntityName][$relatedIdHash] = current($normalizedAssociatedId);
2983.                                     $newValue = $this->em->getProxyFactory()->getProxy($assoc['targetEntity'], $normalizedAssociatedId);
2984.                                     break;
2986.                                 default:
2987.                                     // TODO: This is very imperformant, ignore it?
2988.                                     $newValue = $this->em->find($assoc['targetEntity'], $normalizedAssociatedId);
2989.                                     break;
2990.                             }
2992.                             if ($newValue === null) {
2993.                                 break;
2994.                             }
2996.                             // PERF: Inlined & optimized code from UnitOfWork#registerManaged()
2997.                             $newValueOid                                                     = spl_object_id($newValue);
2998.                             $this->entityIdentifiers[$newValueOid]                           = $associatedId;
2999.                             $this->identityMap[$targetClass->rootEntityName][$relatedIdHash] = $newValue;
3001.                             if (
3002.                                 $newValue instanceof NotifyPropertyChanged &&
3003.                                 ( ! $newValue instanceof Proxy || $newValue->__isInitialized())
3004.                             ) {
3005.                                 $newValue->addPropertyChangedListener($this);
3006.                             }
3008.                             $this->entityStates[$newValueOid] = self::STATE_MANAGED;
3009.                             // make sure that when an proxy is then finally loaded, $this->originalEntityData is set also!
3010.                             break;
3011.                     }
3013.                     $this->originalEntityData[$oid][$field] = $newValue;
3014.                     $class->reflFields[$field]->setValue($entity, $newValue);
3016.                     if ($assoc['inversedBy'] && $assoc['type'] & ClassMetadata::ONE_TO_ONE && $newValue !== null) {
3017.                         $inverseAssoc = $targetClass->associationMappings[$assoc['inversedBy']];
3018.                         $targetClass->reflFields[$inverseAssoc['fieldName']]->setValue($newValue, $entity);
3019.                     }
3021.                     break;
3023.                 default:
3024.                     // Ignore if its a cached collection
3025.                     if (isset($hints[Query::HINT_CACHE_ENABLED]) && $class->getFieldValue($entity, $field) instanceof PersistentCollection) {
3026.                         break;
3027.                     }
3029.                     // use the given collection
3030.                     if (isset($data[$field]) && $data[$field] instanceof PersistentCollection) {
3031.                         $data[$field]->setOwner($entity, $assoc);
3033.                         $class->reflFields[$field]->setValue($entity, $data[$field]);
3034.                         $this->originalEntityData[$oid][$field] = $data[$field];
3036.                         break;
3037.                     }
3039.                     // Inject collection
3040.                     $pColl = new PersistentCollection($this->em, $targetClass, new ArrayCollection());
3041.                     $pColl->setOwner($entity, $assoc);
3042.                     $pColl->setInitialized(false);
3044.                     $reflField = $class->reflFields[$field];
3045.                     $reflField->setValue($entity, $pColl);
3047.                     if ($assoc['fetch'] === ClassMetadata::FETCH_EAGER) {
3048.                         $this->loadCollection($pColl);
3049.                         $pColl->takeSnapshot();
3050.                     }
3052.                     $this->originalEntityData[$oid][$field] = $pColl;
3053.                     break;
3054.             }
3055.         }
3057.         // defer invoking of postLoad event to hydration complete step
3058.         $this->hydrationCompleteHandler->deferPostLoadInvoking($class, $entity);
3060.         return $entity;
3061.     }
3063.     /** @return void */
3064.     public function triggerEagerLoads()
3065.     {
3066.         if (! $this->eagerLoadingEntities) {
3067.             return;
3068.         }
3070.         // avoid infinite recursion
3071.         $eagerLoadingEntities       = $this->eagerLoadingEntities;
3072.         $this->eagerLoadingEntities = [];
3074.         foreach ($eagerLoadingEntities as $entityName => $ids) {
3075.             if (! $ids) {
3076.                 continue;
3077.             }
3079.             $class = $this->em->getClassMetadata($entityName);
3081.             $this->getEntityPersister($entityName)->loadAll(
3082.                 array_combine($class->identifier, [array_values($ids)])
3083.             );
3084.         }
3085.     }
3087.     /**
3088.      * Initializes (loads) an uninitialized persistent collection of an entity.
3089.      *
3090.      * @param PersistentCollection $collection The collection to initialize.
3091.      *
3092.      * @return void
3093.      *
3094.      * @todo Maybe later move to EntityManager#initialize($proxyOrCollection). See DDC-733.
3095.      */
3096.     public function loadCollection(PersistentCollection $collection)
3097.     {
3098.         $assoc     = $collection->getMapping();
3099.         $persister = $this->getEntityPersister($assoc['targetEntity']);
3101.         switch ($assoc['type']) {
3102.             case ClassMetadata::ONE_TO_MANY:
3103.                 $persister->loadOneToManyCollection($assoc, $collection->getOwner(), $collection);
3104.                 break;
3106.             case ClassMetadata::MANY_TO_MANY:
3107.                 $persister->loadManyToManyCollection($assoc, $collection->getOwner(), $collection);
3108.                 break;
3109.         }
3111.         $collection->setInitialized(true);
3112.     }
3114.     /**
3115.      * Gets the identity map of the UnitOfWork.
3116.      *
3117.      * @psalm-return array<class-string, array<string, object>>
3118.      */
3119.     public function getIdentityMap()
3120.     {
3121.         return $this->identityMap;
3122.     }
3124.     /**
3125.      * Gets the original data of an entity. The original data is the data that was
3126.      * present at the time the entity was reconstituted from the database.
3127.      *
3128.      * @param object $entity
3129.      *
3130.      * @return mixed[]
3131.      * @psalm-return array<string, mixed>
3132.      */
3133.     public function getOriginalEntityData($entity)
3134.     {
3135.         $oid = spl_object_id($entity);
3137.         return $this->originalEntityData[$oid] ?? [];
3138.     }
3140.     /**
3141.      * @param object  $entity
3142.      * @param mixed[] $data
3143.      *
3144.      * @return void
3145.      *
3146.      * @ignore
3147.      */
3148.     public function setOriginalEntityData($entity, array $data)
3149.     {
3150.         $this->originalEntityData[spl_object_id($entity)] = $data;
3151.     }
3153.     /**
3154.      * INTERNAL:
3155.      * Sets a property value of the original data array of an entity.
3156.      *
3157.      * @param int    $oid
3158.      * @param string $property
3159.      * @param mixed  $value
3160.      *
3161.      * @return void
3162.      *
3163.      * @ignore
3164.      */
3165.     public function setOriginalEntityProperty($oid, $property, $value)
3166.     {
3167.         $this->originalEntityData[$oid][$property] = $value;
3168.     }
3170.     /**
3171.      * Gets the identifier of an entity.
3172.      * The returned value is always an array of identifier values. If the entity
3173.      * has a composite identifier then the identifier values are in the same
3174.      * order as the identifier field names as returned by ClassMetadata#getIdentifierFieldNames().
3175.      *
3176.      * @param object $entity
3177.      *
3178.      * @return mixed[] The identifier values.
3179.      */
3180.     public function getEntityIdentifier($entity)
3181.     {
3182.         if (! isset($this->entityIdentifiers[spl_object_id($entity)])) {
3183.             throw EntityNotFoundException::noIdentifierFound(get_debug_type($entity));
3184.         }
3186.         return $this->entityIdentifiers[spl_object_id($entity)];
3187.     }
3189.     /**
3190.      * Processes an entity instance to extract their identifier values.
3191.      *
3192.      * @param object $entity The entity instance.
3193.      *
3194.      * @return mixed A scalar value.
3195.      *
3196.      * @throws ORMInvalidArgumentException
3197.      */
3198.     public function getSingleIdentifierValue($entity)
3199.     {
3200.         $class = $this->em->getClassMetadata(get_class($entity));
3202.         if ($class->isIdentifierComposite) {
3203.             throw ORMInvalidArgumentException::invalidCompositeIdentifier();
3204.         }
3206.         $values = $this->isInIdentityMap($entity)
3207.             ? $this->getEntityIdentifier($entity)
3208.             : $class->getIdentifierValues($entity);
3210.         return $values[$class->identifier[0]] ?? null;
3211.     }
3213.     /**
3214.      * Tries to find an entity with the given identifier in the identity map of
3215.      * this UnitOfWork.
3216.      *
3217.      * @param mixed  $id            The entity identifier to look for.
3218.      * @param string $rootClassName The name of the root class of the mapped entity hierarchy.
3219.      * @psalm-param class-string $rootClassName
3220.      *
3221.      * @return object|false Returns the entity with the specified identifier if it exists in
3222.      *                      this UnitOfWork, FALSE otherwise.
3223.      */
3224.     public function tryGetById($id, $rootClassName)
3225.     {
3226.         $idHash = self::getIdHashByIdentifier((array) $id);
3228.         return $this->identityMap[$rootClassName][$idHash] ?? false;
3229.     }
3231.     /**
3232.      * Schedules an entity for dirty-checking at commit-time.
3233.      *
3234.      * @param object $entity The entity to schedule for dirty-checking.
3235.      *
3236.      * @return void
3237.      *
3238.      * @todo Rename: scheduleForSynchronization
3239.      */
3240.     public function scheduleForDirtyCheck($entity)
3241.     {
3242.         $rootClassName = $this->em->getClassMetadata(get_class($entity))->rootEntityName;
3244.         $this->scheduledForSynchronization[$rootClassName][spl_object_id($entity)] = $entity;
3245.     }
3247.     /**
3248.      * Checks whether the UnitOfWork has any pending insertions.
3249.      *
3250.      * @return bool TRUE if this UnitOfWork has pending insertions, FALSE otherwise.
3251.      */
3252.     public function hasPendingInsertions()
3253.     {
3254.         return ! empty($this->entityInsertions);
3255.     }
3257.     /**
3258.      * Calculates the size of the UnitOfWork. The size of the UnitOfWork is the
3259.      * number of entities in the identity map.
3260.      *
3261.      * @return int
3262.      */
3263.     public function size()
3264.     {
3265.         return array_sum(array_map('count', $this->identityMap));
3266.     }
3268.     /**
3269.      * Gets the EntityPersister for an Entity.
3270.      *
3271.      * @param string $entityName The name of the Entity.
3272.      * @psalm-param class-string $entityName
3273.      *
3274.      * @return EntityPersister
3275.      */
3276.     public function getEntityPersister($entityName)
3277.     {
3278.         if (isset($this->persisters[$entityName])) {
3279.             return $this->persisters[$entityName];
3280.         }
3282.         $class = $this->em->getClassMetadata($entityName);
3284.         switch (true) {
3285.             case $class->isInheritanceTypeNone():
3286.                 $persister = new BasicEntityPersister($this->em, $class);
3287.                 break;
3289.             case $class->isInheritanceTypeSingleTable():
3290.                 $persister = new SingleTablePersister($this->em, $class);
3291.                 break;
3293.             case $class->isInheritanceTypeJoined():
3294.                 $persister = new JoinedSubclassPersister($this->em, $class);
3295.                 break;
3297.             default:
3298.                 throw new RuntimeException('No persister found for entity.');
3299.         }
3301.         if ($this->hasCache && $class->cache !== null) {
3302.             $persister = $this->em->getConfiguration()
3303.                 ->getSecondLevelCacheConfiguration()
3304.                 ->getCacheFactory()
3305.                 ->buildCachedEntityPersister($this->em, $persister, $class);
3306.         }
3308.         $this->persisters[$entityName] = $persister;
3310.         return $this->persisters[$entityName];
3311.     }
3313.     /**
3314.      * Gets a collection persister for a collection-valued association.
3315.      *
3316.      * @psalm-param AssociationMapping $association
3317.      *
3318.      * @return CollectionPersister
3319.      */
3320.     public function getCollectionPersister(array $association)
3321.     {
3322.         $role = isset($association['cache'])
3323.             ? $association['sourceEntity'] . '::' . $association['fieldName']
3324.             : $association['type'];
3326.         if (isset($this->collectionPersisters[$role])) {
3327.             return $this->collectionPersisters[$role];
3328.         }
3330.         $persister = $association['type'] === ClassMetadata::ONE_TO_MANY
3331.             ? new OneToManyPersister($this->em)
3332.             : new ManyToManyPersister($this->em);
3334.         if ($this->hasCache && isset($association['cache'])) {
3335.             $persister = $this->em->getConfiguration()
3336.                 ->getSecondLevelCacheConfiguration()
3337.                 ->getCacheFactory()
3338.                 ->buildCachedCollectionPersister($this->em, $persister, $association);
3339.         }
3341.         $this->collectionPersisters[$role] = $persister;
3343.         return $this->collectionPersisters[$role];
3344.     }
3346.     /**
3347.      * INTERNAL:
3348.      * Registers an entity as managed.
3349.      *
3350.      * @param object  $entity The entity.
3351.      * @param mixed[] $id     The identifier values.
3352.      * @param mixed[] $data   The original entity data.
3353.      *
3354.      * @return void
3355.      */
3356.     public function registerManaged($entity, array $id, array $data)
3357.     {
3358.         $oid = spl_object_id($entity);
3360.         $this->entityIdentifiers[$oid]  = $id;
3361.         $this->entityStates[$oid]       = self::STATE_MANAGED;
3362.         $this->originalEntityData[$oid] = $data;
3364.         $this->addToIdentityMap($entity);
3366.         if ($entity instanceof NotifyPropertyChanged && ( ! $entity instanceof Proxy || $entity->__isInitialized())) {
3367.             $entity->addPropertyChangedListener($this);
3368.         }
3369.     }
3371.     /**
3372.      * INTERNAL:
3373.      * Clears the property changeset of the entity with the given OID.
3374.      *
3375.      * @param int $oid The entity's OID.
3376.      *
3377.      * @return void
3378.      */
3379.     public function clearEntityChangeSet($oid)
3380.     {
3381.         unset($this->entityChangeSets[$oid]);
3382.     }
3384.     /* PropertyChangedListener implementation */
3386.     /**
3387.      * Notifies this UnitOfWork of a property change in an entity.
3388.      *
3389.      * @param object $sender       The entity that owns the property.
3390.      * @param string $propertyName The name of the property that changed.
3391.      * @param mixed  $oldValue     The old value of the property.
3392.      * @param mixed  $newValue     The new value of the property.
3393.      *
3394.      * @return void
3395.      */
3396.     public function propertyChanged($sender, $propertyName, $oldValue, $newValue)
3397.     {
3398.         $oid   = spl_object_id($sender);
3399.         $class = $this->em->getClassMetadata(get_class($sender));
3401.         $isAssocField = isset($class->associationMappings[$propertyName]);
3403.         if (! $isAssocField && ! isset($class->fieldMappings[$propertyName])) {
3404.             return; // ignore non-persistent fields
3405.         }
3407.         // Update changeset and mark entity for synchronization
3408.         $this->entityChangeSets[$oid][$propertyName] = [$oldValue, $newValue];
3410.         if (! isset($this->scheduledForSynchronization[$class->rootEntityName][$oid])) {
3411.             $this->scheduleForDirtyCheck($sender);
3412.         }
3413.     }
3415.     /**
3416.      * Gets the currently scheduled entity insertions in this UnitOfWork.
3417.      *
3418.      * @psalm-return array<int, object>
3419.      */
3420.     public function getScheduledEntityInsertions()
3421.     {
3422.         return $this->entityInsertions;
3423.     }
3425.     /**
3426.      * Gets the currently scheduled entity updates in this UnitOfWork.
3427.      *
3428.      * @psalm-return array<int, object>
3429.      */
3430.     public function getScheduledEntityUpdates()
3431.     {
3432.         return $this->entityUpdates;
3433.     }
3435.     /**
3436.      * Gets the currently scheduled entity deletions in this UnitOfWork.
3437.      *
3438.      * @psalm-return array<int, object>
3439.      */
3440.     public function getScheduledEntityDeletions()
3441.     {
3442.         return $this->entityDeletions;
3443.     }
3445.     /**
3446.      * Gets the currently scheduled complete collection deletions
3447.      *
3448.      * @psalm-return array<int, PersistentCollection<array-key, object>>
3449.      */
3450.     public function getScheduledCollectionDeletions()
3451.     {
3452.         return $this->collectionDeletions;
3453.     }
3455.     /**
3456.      * Gets the currently scheduled collection inserts, updates and deletes.
3457.      *
3458.      * @psalm-return array<int, PersistentCollection<array-key, object>>
3459.      */
3460.     public function getScheduledCollectionUpdates()
3461.     {
3462.         return $this->collectionUpdates;
3463.     }
3465.     /**
3466.      * Helper method to initialize a lazy loading proxy or persistent collection.
3467.      *
3468.      * @param object $obj
3469.      *
3470.      * @return void
3471.      */
3472.     public function initializeObject($obj)
3473.     {
3474.         if ($obj instanceof Proxy) {
3475.             $obj->__load();
3477.             return;
3478.         }
3480.         if ($obj instanceof PersistentCollection) {
3481.             $obj->initialize();
3482.         }
3483.     }
3485.     /**
3486.      * Helper method to show an object as string.
3487.      *
3488.      * @param object $obj
3489.      */
3490.     private static function objToStr($obj): string
3491.     {
3492.         return method_exists($obj, '__toString') ? (string) $obj : get_debug_type($obj) . '@' . spl_object_id($obj);
3493.     }
3495.     /**
3496.      * Marks an entity as read-only so that it will not be considered for updates during UnitOfWork#commit().
3497.      *
3498.      * This operation cannot be undone as some parts of the UnitOfWork now keep gathering information
3499.      * on this object that might be necessary to perform a correct update.
3500.      *
3501.      * @param object $object
3502.      *
3503.      * @return void
3504.      *
3505.      * @throws ORMInvalidArgumentException
3506.      */
3507.     public function markReadOnly($object)
3508.     {
3509.         if (! is_object($object) || ! $this->isInIdentityMap($object)) {
3510.             throw ORMInvalidArgumentException::readOnlyRequiresManagedEntity($object);
3511.         }
3513.         $this->readOnlyObjects[spl_object_id($object)] = true;
3514.     }
3516.     /**
3517.      * Is this entity read only?
3518.      *
3519.      * @param object $object
3520.      *
3521.      * @return bool
3522.      *
3523.      * @throws ORMInvalidArgumentException
3524.      */
3525.     public function isReadOnly($object)
3526.     {
3527.         if (! is_object($object)) {
3528.             throw ORMInvalidArgumentException::readOnlyRequiresManagedEntity($object);
3529.         }
3531.         return isset($this->readOnlyObjects[spl_object_id($object)]);
3532.     }
3534.     /**
3535.      * Perform whatever processing is encapsulated here after completion of the transaction.
3536.      */
3537.     private function afterTransactionComplete(): void
3538.     {
3539.         $this->performCallbackOnCachedPersister(static function (CachedPersister $persister) {
3540.             $persister->afterTransactionComplete();
3541.         });
3542.     }
3544.     /**
3545.      * Perform whatever processing is encapsulated here after completion of the rolled-back.
3546.      */
3547.     private function afterTransactionRolledBack(): void
3548.     {
3549.         $this->performCallbackOnCachedPersister(static function (CachedPersister $persister) {
3550.             $persister->afterTransactionRolledBack();
3551.         });
3552.     }
3554.     /**
3555.      * Performs an action after the transaction.
3556.      */
3557.     private function performCallbackOnCachedPersister(callable $callback): void
3558.     {
3559.         if (! $this->hasCache) {
3560.             return;
3561.         }
3563.         foreach (array_merge($this->persisters, $this->collectionPersisters) as $persister) {
3564.             if ($persister instanceof CachedPersister) {
3565.                 $callback($persister);
3566.             }
3567.         }
3568.     }
3570.     private function dispatchOnFlushEvent(): void
3571.     {
3572.         if ($this->evm->hasListeners(Events::onFlush)) {
3573.             $this->evm->dispatchEvent(Events::onFlush, new OnFlushEventArgs($this->em));
3574.         }
3575.     }
3577.     private function dispatchPostFlushEvent(): void
3578.     {
3579.         if ($this->evm->hasListeners(Events::postFlush)) {
3580.             $this->evm->dispatchEvent(Events::postFlush, new PostFlushEventArgs($this->em));
3581.         }
3582.     }
3584.     /**
3585.      * Verifies if two given entities actually are the same based on identifier comparison
3586.      *
3587.      * @param object $entity1
3588.      * @param object $entity2
3589.      */
3590.     private function isIdentifierEquals($entity1, $entity2): bool
3591.     {
3592.         if ($entity1 === $entity2) {
3593.             return true;
3594.         }
3596.         $class = $this->em->getClassMetadata(get_class($entity1));
3598.         if ($class !== $this->em->getClassMetadata(get_class($entity2))) {
3599.             return false;
3600.         }
3602.         $oid1 = spl_object_id($entity1);
3603.         $oid2 = spl_object_id($entity2);
3605.         $id1 = $this->entityIdentifiers[$oid1] ?? $this->identifierFlattener->flattenIdentifier($class, $class->getIdentifierValues($entity1));
3606.         $id2 = $this->entityIdentifiers[$oid2] ?? $this->identifierFlattener->flattenIdentifier($class, $class->getIdentifierValues($entity2));
3608.         return $id1 === $id2 || self::getIdHashByIdentifier($id1) === self::getIdHashByIdentifier($id2);
3609.     }
3611.     /** @throws ORMInvalidArgumentException */
3612.     private function assertThatThereAreNoUnintentionallyNonPersistedAssociations(): void
3613.     {
3614.         $entitiesNeedingCascadePersist = array_diff_key($this->nonCascadedNewDetectedEntities, $this->entityInsertions);
3616.         $this->nonCascadedNewDetectedEntities = [];
3618.         if ($entitiesNeedingCascadePersist) {
3619.             throw ORMInvalidArgumentException::newEntitiesFoundThroughRelationships(
3620.                 array_values($entitiesNeedingCascadePersist)
3621.             );
3622.         }
3623.     }
3625.     /**
3626.      * @param object $entity
3627.      * @param object $managedCopy
3628.      *
3629.      * @throws ORMException
3630.      * @throws OptimisticLockException
3631.      * @throws TransactionRequiredException
3632.      */
3633.     private function mergeEntityStateIntoManagedCopy($entity, $managedCopy): void
3634.     {
3635.         if (! $this->isLoaded($entity)) {
3636.             return;
3637.         }
3639.         if (! $this->isLoaded($managedCopy)) {
3640.             $managedCopy->__load();
3641.         }
3643.         $class = $this->em->getClassMetadata(get_class($entity));
3645.         foreach ($this->reflectionPropertiesGetter->getProperties($class->name) as $prop) {
3646.             $name = $prop->name;
3648.             $prop->setAccessible(true);
3650.             if (! isset($class->associationMappings[$name])) {
3651.                 if (! $class->isIdentifier($name)) {
3652.                     $prop->setValue($managedCopy, $prop->getValue($entity));
3653.                 }
3654.             } else {
3655.                 $assoc2 = $class->associationMappings[$name];
3657.                 if ($assoc2['type'] & ClassMetadata::TO_ONE) {
3658.                     $other = $prop->getValue($entity);
3659.                     if ($other === null) {
3660.                         $prop->setValue($managedCopy, null);
3661.                     } else {
3662.                         if ($other instanceof Proxy && ! $other->__isInitialized()) {
3663.                             // do not merge fields marked lazy that have not been fetched.
3664.                             continue;
3665.                         }
3667.                         if (! $assoc2['isCascadeMerge']) {
3668.                             if ($this->getEntityState($other) === self::STATE_DETACHED) {
3669.                                 $targetClass = $this->em->getClassMetadata($assoc2['targetEntity']);
3670.                                 $relatedId   = $targetClass->getIdentifierValues($other);
3672.                                 if ($targetClass->subClasses) {
3673.                                     $other = $this->em->find($targetClass->name, $relatedId);
3674.                                 } else {
3675.                                     $other = $this->em->getProxyFactory()->getProxy(
3676.                                         $assoc2['targetEntity'],
3677.                                         $relatedId
3678.                                     );
3679.                                     $this->registerManaged($other, $relatedId, []);
3680.                                 }
3681.                             }
3683.                             $prop->setValue($managedCopy, $other);
3684.                         }
3685.                     }
3686.                 } else {
3687.                     $mergeCol = $prop->getValue($entity);
3689.                     if ($mergeCol instanceof PersistentCollection && ! $mergeCol->isInitialized()) {
3690.                         // do not merge fields marked lazy that have not been fetched.
3691.                         // keep the lazy persistent collection of the managed copy.
3692.                         continue;
3693.                     }
3695.                     $managedCol = $prop->getValue($managedCopy);
3697.                     if (! $managedCol) {
3698.                         $managedCol = new PersistentCollection(
3699.                             $this->em,
3700.                             $this->em->getClassMetadata($assoc2['targetEntity']),
3701.                             new ArrayCollection()
3702.                         );
3703.                         $managedCol->setOwner($managedCopy, $assoc2);
3704.                         $prop->setValue($managedCopy, $managedCol);
3705.                     }
3707.                     if ($assoc2['isCascadeMerge']) {
3708.                         $managedCol->initialize();
3710.                         // clear and set dirty a managed collection if its not also the same collection to merge from.
3711.                         if (! $managedCol->isEmpty() && $managedCol !== $mergeCol) {
3712.                             $managedCol->unwrap()->clear();
3713.                             $managedCol->setDirty(true);
3715.                             if (
3716.                                 $assoc2['isOwningSide']
3717.                                 && $assoc2['type'] === ClassMetadata::MANY_TO_MANY
3718.                                 && $class->isChangeTrackingNotify()
3719.                             ) {
3720.                                 $this->scheduleForDirtyCheck($managedCopy);
3721.                             }
3722.                         }
3723.                     }
3724.                 }
3725.             }
3727.             if ($class->isChangeTrackingNotify()) {
3728.                 // Just treat all properties as changed, there is no other choice.
3729.                 $this->propertyChanged($managedCopy, $name, null, $prop->getValue($managedCopy));
3730.             }
3731.         }
3732.     }
3734.     /**
3735.      * This method called by hydrators, and indicates that hydrator totally completed current hydration cycle.
3736.      * Unit of work able to fire deferred events, related to loading events here.
3737.      *
3738.      * @internal should be called internally from object hydrators
3739.      *
3740.      * @return void
3741.      */
3742.     public function hydrationComplete()
3743.     {
3744.         $this->hydrationCompleteHandler->hydrationComplete();
3745.     }
3747.     private function clearIdentityMapForEntityName(string $entityName): void
3748.     {
3749.         if (! isset($this->identityMap[$entityName])) {
3750.             return;
3751.         }
3753.         $visited = [];
3755.         foreach ($this->identityMap[$entityName] as $entity) {
3756.             $this->doDetach($entity, $visited, false);
3757.         }
3758.     }
3760.     private function clearEntityInsertionsForEntityName(string $entityName): void
3761.     {
3762.         foreach ($this->entityInsertions as $hash => $entity) {
3763.             // note: performance optimization - `instanceof` is much faster than a function call
3764.             if ($entity instanceof $entityName && get_class($entity) === $entityName) {
3765.                 unset($this->entityInsertions[$hash]);
3766.             }
3767.         }
3768.     }
3770.     /**
3771.      * @param mixed $identifierValue
3772.      *
3773.      * @return mixed the identifier after type conversion
3774.      *
3775.      * @throws MappingException if the entity has more than a single identifier.
3776.      */
3777.     private function convertSingleFieldIdentifierToPHPValue(ClassMetadata $class, $identifierValue)
3778.     {
3779.         return $this->em->getConnection()->convertToPHPValue(
3780.             $identifierValue,
3781.             $class->getTypeOfField($class->getSingleIdentifierFieldName())
3782.         );
3783.     }
3785.     /**
3786.      * Given a flat identifier, this method will produce another flat identifier, but with all
3787.      * association fields that are mapped as identifiers replaced by entity references, recursively.
3788.      *
3789.      * @param mixed[] $flatIdentifier
3790.      *
3791.      * @return array<string, mixed>
3792.      */
3793.     private function normalizeIdentifier(ClassMetadata $targetClass, array $flatIdentifier): array
3794.     {
3795.         $normalizedAssociatedId = [];
3797.         foreach ($targetClass->getIdentifierFieldNames() as $name) {
3798.             if (! array_key_exists($name, $flatIdentifier)) {
3799.                 continue;
3800.             }
3802.             if (! $targetClass->isSingleValuedAssociation($name)) {
3803.                 $normalizedAssociatedId[$name] = $flatIdentifier[$name];
3804.                 continue;
3805.             }
3807.             $targetIdMetadata = $this->em->getClassMetadata($targetClass->getAssociationTargetClass($name));
3809.             // Note: the ORM prevents using an entity with a composite identifier as an identifier association
3810.             //       therefore, reset($targetIdMetadata->identifier) is always correct
3811.             $normalizedAssociatedId[$name] = $this->em->getReference(
3812.                 $targetIdMetadata->getName(),
3813.                 $this->normalizeIdentifier(
3814.                     $targetIdMetadata,
3815.                     [(string) reset($targetIdMetadata->identifier) => $flatIdentifier[$name]]
3816.                 )
3817.             );
3818.         }
3820.         return $normalizedAssociatedId;
3821.     }
3822. }