vendor/doctrine/mongodb-odm/lib/Doctrine/ODM/MongoDB/UnitOfWork.php line 2869

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ODM\MongoDB;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\Common\EventManager;
  10. use Doctrine\ODM\MongoDB\Hydrator\HydratorFactory;
  11. use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
  12. use Doctrine\ODM\MongoDB\Mapping\MappingException;
  13. use Doctrine\ODM\MongoDB\PersistentCollection\PersistentCollectionException;
  14. use Doctrine\ODM\MongoDB\PersistentCollection\PersistentCollectionInterface;
  15. use Doctrine\ODM\MongoDB\Persisters\CollectionPersister;
  16. use Doctrine\ODM\MongoDB\Persisters\PersistenceBuilder;
  17. use Doctrine\ODM\MongoDB\Query\Query;
  18. use Doctrine\ODM\MongoDB\Types\DateType;
  19. use Doctrine\ODM\MongoDB\Types\Type;
  20. use Doctrine\ODM\MongoDB\Utility\CollectionHelper;
  21. use Doctrine\ODM\MongoDB\Utility\LifecycleEventManager;
  22. use Doctrine\Persistence\Mapping\ReflectionService;
  23. use Doctrine\Persistence\Mapping\RuntimeReflectionService;
  24. use Doctrine\Persistence\NotifyPropertyChanged;
  25. use Doctrine\Persistence\PropertyChangedListener;
  26. use InvalidArgumentException;
  27. use MongoDB\BSON\UTCDateTime;
  28. use MongoDB\Driver\WriteConcern;
  29. use ProxyManager\Proxy\GhostObjectInterface;
  30. use ReflectionProperty;
  31. use UnexpectedValueException;
  33. use function array_filter;
  34. use function assert;
  35. use function count;
  36. use function get_class;
  37. use function in_array;
  38. use function is_array;
  39. use function is_object;
  40. use function method_exists;
  41. use function preg_match;
  42. use function serialize;
  43. use function spl_object_hash;
  44. use function sprintf;
  46. /**
  47.  * The UnitOfWork is responsible for tracking changes to objects during an
  48.  * "object-level" transaction and for writing out changes to the database
  49.  * in the correct order.
  50.  *
  51.  * @psalm-import-type FieldMapping from ClassMetadata
  52.  * @psalm-import-type AssociationFieldMapping from ClassMetadata
  53.  * @psalm-type ChangeSet = array{
  54.  *      0: mixed,
  55.  *      1: mixed
  56.  * }
  57.  * @psalm-type Hints = array<int, mixed>
  58.  * @psalm-type CommitOptions array{
  59.  *      fsync?: bool,
  60.  *      safe?: int,
  61.  *      w?: int,
  62.  *      writeConcern?: WriteConcern
  63.  * }
  64.  */
  65. final class UnitOfWork implements PropertyChangedListener
  66. {
  67.     /**
  68.      * A document is in MANAGED state when its persistence is managed by a DocumentManager.
  69.      */
  70.     public const STATE_MANAGED = 1;
  72.     /**
  73.      * A document is new if it has just been instantiated (i.e. using the "new" operator)
  74.      * and is not (yet) managed by a DocumentManager.
  75.      */
  76.     public const STATE_NEW = 2;
  78.     /**
  79.      * A detached document is an instance with a persistent identity that is not
  80.      * (or no longer) associated with a DocumentManager (and a UnitOfWork).
  81.      */
  82.     public const STATE_DETACHED = 3;
  84.     /**
  85.      * A removed document instance is an instance with a persistent identity,
  86.      * associated with a DocumentManager, whose persistent state has been
  87.      * deleted (or is scheduled for deletion).
  88.      */
  89.     public const STATE_REMOVED = 4;
  91.     /**
  92.      * The identity map holds references to all managed documents.
  93.      *
  94.      * Documents are grouped by their class name, and then indexed by the
  95.      * serialized string of their database identifier field or, if the class
  96.      * has no identifier, the SPL object hash. Serializing the identifier allows
  97.      * differentiation of values that may be equal (via type juggling) but not
  98.      * identical.
  99.      *
  100.      * Since all classes in a hierarchy must share the same identifier set,
  101.      * we always take the root class name of the hierarchy.
  102.      *
  103.      * @var array
  104.      * @psalm-var array<class-string, array<string, object>>
  105.      */
  106.     private $identityMap = [];
  108.     /**
  109.      * Map of all identifiers of managed documents.
  110.      * Keys are object ids (spl_object_hash).
  111.      *
  112.      * @var array<string, mixed>
  113.      */
  114.     private $documentIdentifiers = [];
  116.     /**
  117.      * Map of the original document data of managed documents.
  118.      * Keys are object ids (spl_object_hash). This is used for calculating changesets
  119.      * at commit time.
  120.      *
  121.      * @internal Note that PHPs "copy-on-write" behavior helps a lot with memory usage.
  122.      *           A value will only really be copied if the value in the document is modified
  123.      *           by the user.
  124.      *
  125.      * @var array<string, array<string, mixed>>
  126.      */
  127.     private $originalDocumentData = [];
  129.     /**
  130.      * Map of document changes. Keys are object ids (spl_object_hash).
  131.      * Filled at the beginning of a commit of the UnitOfWork and cleaned at the end.
  132.      *
  133.      * @var array
  134.      * @psalm-var array<string, array<string, ChangeSet>>
  135.      */
  136.     private $documentChangeSets = [];
  138.     /**
  139.      * The (cached) states of any known documents.
  140.      * Keys are object ids (spl_object_hash).
  141.      *
  142.      * @var array
  143.      * @psalm-var array<string, self::STATE_*>
  144.      */
  145.     private $documentStates = [];
  147.     /**
  148.      * Map of documents that are scheduled for dirty checking at commit time.
  149.      *
  150.      * Documents are grouped by their class name, and then indexed by their SPL
  151.      * object hash. This is only used for documents with a change tracking
  152.      * policy of DEFERRED_EXPLICIT.
  153.      *
  154.      * @var array
  155.      * @psalm-var array<class-string, array<string, object>>
  156.      */
  157.     private $scheduledForSynchronization = [];
  159.     /**
  160.      * A list of all pending document insertions.
  161.      *
  162.      * @var array<string, object>
  163.      */
  164.     private $documentInsertions = [];
  166.     /**
  167.      * A list of all pending document updates.
  168.      *
  169.      * @var array<string, object>
  170.      */
  171.     private $documentUpdates = [];
  173.     /**
  174.      * A list of all pending document upserts.
  175.      *
  176.      * @var array<string, object>
  177.      */
  178.     private $documentUpserts = [];
  180.     /**
  181.      * A list of all pending document deletions.
  182.      *
  183.      * @var array<string, object>
  184.      */
  185.     private $documentDeletions = [];
  187.     /**
  188.      * All pending collection deletions.
  189.      *
  190.      * @var array
  191.      * @psalm-var array<string, PersistentCollectionInterface<array-key, object>>
  192.      */
  193.     private $collectionDeletions = [];
  195.     /**
  196.      * All pending collection updates.
  197.      *
  198.      * @var array
  199.      * @psalm-var array<string, PersistentCollectionInterface<array-key, object>>
  200.      */
  201.     private $collectionUpdates = [];
  203.     /**
  204.      * A list of documents related to collections scheduled for update or deletion
  205.      *
  206.      * @var array
  207.      * @psalm-var array<string, array<string, PersistentCollectionInterface<array-key, object>>>
  208.      */
  209.     private $hasScheduledCollections = [];
  211.     /**
  212.      * List of collections visited during changeset calculation on a commit-phase of a UnitOfWork.
  213.      * At the end of the UnitOfWork all these collections will make new snapshots
  214.      * of their data.
  215.      *
  216.      * @psalm-var array<string, array<PersistentCollectionInterface<array-key, object>>>
  217.      */
  218.     private $visitedCollections = [];
  220.     /**
  221.      * The DocumentManager that "owns" this UnitOfWork instance.
  222.      *
  223.      * @var DocumentManager
  224.      */
  225.     private $dm;
  227.     /**
  228.      * The EventManager used for dispatching events.
  229.      *
  230.      * @var EventManager
  231.      */
  232.     private $evm;
  234.     /**
  235.      * Additional documents that are scheduled for removal.
  236.      *
  237.      * @var array<string, object>
  238.      */
  239.     private $orphanRemovals = [];
  241.     /**
  242.      * The HydratorFactory used for hydrating array Mongo documents to Doctrine object documents.
  243.      *
  244.      * @var HydratorFactory
  245.      */
  246.     private $hydratorFactory;
  248.     /**
  249.      * The document persister instances used to persist document instances.
  250.      *
  251.      * @var array
  252.      * @psalm-var array<class-string, Persisters\DocumentPersister>
  253.      */
  254.     private $persisters = [];
  256.     /**
  257.      * The collection persister instance used to persist changes to collections.
  258.      *
  259.      * @var Persisters\CollectionPersister|null
  260.      */
  261.     private $collectionPersister;
  263.     /**
  264.      * The persistence builder instance used in DocumentPersisters.
  265.      *
  266.      * @var PersistenceBuilder|null
  267.      */
  268.     private $persistenceBuilder;
  270.     /**
  271.      * Array of parent associations between embedded documents.
  272.      *
  273.      * @var array
  274.      * @psalm-var array<string, array{0: AssociationFieldMapping, 1: object|null, 2: string}>
  275.      */
  276.     private $parentAssociations = [];
  278.     /** @var LifecycleEventManager */
  279.     private $lifecycleEventManager;
  281.     /** @var ReflectionService */
  282.     private $reflectionService;
  284.     /**
  285.      * Array of embedded documents known to UnitOfWork. We need to hold them to prevent spl_object_hash
  286.      * collisions in case already managed object is lost due to GC (so now it won't). Embedded documents
  287.      * found during doDetach are removed from the registry, to empty it altogether clear() can be utilized.
  288.      *
  289.      * @var array<string, object>
  290.      */
  291.     private $embeddedDocumentsRegistry = [];
  293.     /** @var int */
  294.     private $commitsInProgress = 0;
  296.     /**
  297.      * Initializes a new UnitOfWork instance, bound to the given DocumentManager.
  298.      */
  299.     public function __construct(DocumentManager $dm, EventManager $evm, HydratorFactory $hydratorFactory)
  300.     {
  301.         $this->dm                    = $dm;
  302.         $this->evm                   = $evm;
  303.         $this->hydratorFactory       = $hydratorFactory;
  304.         $this->lifecycleEventManager = new LifecycleEventManager($dm, $this, $evm);
  305.         $this->reflectionService     = new RuntimeReflectionService();
  306.     }
  308.     /**
  309.      * Factory for returning new PersistenceBuilder instances used for preparing data into
  310.      * queries for insert persistence.
  311.      *
  312.      * @internal
  313.      */
  314.     public function getPersistenceBuilder(): PersistenceBuilder
  315.     {
  316.         if (! $this->persistenceBuilder) {
  317.             $this->persistenceBuilder = new PersistenceBuilder($this->dm, $this);
  318.         }
  320.         return $this->persistenceBuilder;
  321.     }
  323.     /**
  324.      * Sets the parent association for a given embedded document.
  325.      *
  326.      * @internal
  327.      *
  328.      * @psalm-param FieldMapping $mapping
  329.      */
  330.     public function setParentAssociation(object $document, array $mapping, ?object $parent, string $propertyPath): void
  331.     {
  332.         $oid                                   = spl_object_hash($document);
  333.         $this->embeddedDocumentsRegistry[$oid] = $document;
  334.         $this->parentAssociations[$oid]        = [$mapping, $parent, $propertyPath];
  335.     }
  337.     /**
  338.      * Gets the parent association for a given embedded document.
  339.      *
  340.      *     <code>
  341.      *     list($mapping, $parent, $propertyPath) = $this->getParentAssociation($embeddedDocument);
  342.      *     </code>
  343.      *
  344.      * @psalm-return array{0: AssociationFieldMapping, 1: object|null, 2: string}|null
  345.      */
  346.     public function getParentAssociation(object $document): ?array
  347.     {
  348.         $oid = spl_object_hash($document);
  350.         return $this->parentAssociations[$oid] ?? null;
  351.     }
  353.     /**
  354.      * Get the document persister instance for the given document name
  355.      *
  356.      * @psalm-param class-string<T> $documentName
  357.      *
  358.      * @psalm-return Persisters\DocumentPersister<T>
  359.      *
  360.      * @template T of object
  361.      */
  362.     public function getDocumentPersister(string $documentName): Persisters\DocumentPersister
  363.     {
  364.         if (! isset($this->persisters[$documentName])) {
  365.             $class                           = $this->dm->getClassMetadata($documentName);
  366.             $pb                              = $this->getPersistenceBuilder();
  367.             $this->persisters[$documentName] = new Persisters\DocumentPersister($pb, $this->dm, $this, $this->hydratorFactory, $class);
  368.         }
  370.         /** @psalm-var Persisters\DocumentPersister<T> */
  371.         return $this->persisters[$documentName];
  372.     }
  374.     /**
  375.      * Get the collection persister instance.
  376.      */
  377.     public function getCollectionPersister(): CollectionPersister
  378.     {
  379.         if (! isset($this->collectionPersister)) {
  380.             $pb                        = $this->getPersistenceBuilder();
  381.             $this->collectionPersister = new Persisters\CollectionPersister($this->dm, $pb, $this);
  382.         }
  384.         return $this->collectionPersister;
  385.     }
  387.     /**
  388.      * Set the document persister instance to use for the given document name
  389.      *
  390.      * @internal
  391.      *
  392.      * @psalm-param class-string<T> $documentName
  393.      * @psalm-param Persisters\DocumentPersister<T> $persister
  394.      *
  395.      * @template T of object
  396.      */
  397.     public function setDocumentPersister(string $documentName, Persisters\DocumentPersister $persister): void
  398.     {
  399.         $this->persisters[$documentName] = $persister;
  400.     }
  402.     /**
  403.      * Commits the UnitOfWork, executing all operations that have been postponed
  404.      * up to this point. The state of all managed documents will be synchronized with
  405.      * the database.
  406.      *
  407.      * The operations are executed in the following order:
  408.      *
  409.      * 1) All document insertions
  410.      * 2) All document updates
  411.      * 3) All document deletions
  412.      *
  413.      * @param array $options Array of options to be used with batchInsert(), update() and remove()
  414.      * @psalm-param CommitOptions $options
  415.      */
  416.     public function commit(array $options = []): void
  417.     {
  418.         // Raise preFlush
  419.         if ($this->evm->hasListeners(Events::preFlush)) {
  420.             $this->evm->dispatchEvent(Events::preFlush, new Event\PreFlushEventArgs($this->dm));
  421.         }
  423.         // Compute changes done since last commit.
  424.         $this->computeChangeSets();
  426.         if (
  427.             ! ($this->documentInsertions ||
  428.             $this->documentUpserts ||
  429.             $this->documentDeletions ||
  430.             $this->documentUpdates ||
  431.             $this->collectionUpdates ||
  432.             $this->collectionDeletions ||
  433.             $this->orphanRemovals)
  434.         ) {
  435.             return; // Nothing to do.
  436.         }
  438.         $this->commitsInProgress++;
  439.         if ($this->commitsInProgress > 1) {
  440.             throw MongoDBException::commitInProgress();
  441.         }
  443.         try {
  444.             if ($this->orphanRemovals) {
  445.                 foreach ($this->orphanRemovals as $removal) {
  446.                     $this->remove($removal);
  447.                 }
  448.             }
  450.             // Raise onFlush
  451.             if ($this->evm->hasListeners(Events::onFlush)) {
  452.                 $this->evm->dispatchEvent(Events::onFlush, new Event\OnFlushEventArgs($this->dm));
  453.             }
  455.             foreach ($this->getClassesForCommitAction($this->documentUpserts) as $classAndDocuments) {
  456.                 [$class, $documents] = $classAndDocuments;
  457.                 $this->executeUpserts($class, $documents, $options);
  458.             }
  460.             foreach ($this->getClassesForCommitAction($this->documentInsertions) as $classAndDocuments) {
  461.                 [$class, $documents] = $classAndDocuments;
  462.                 $this->executeInserts($class, $documents, $options);
  463.             }
  465.             foreach ($this->getClassesForCommitAction($this->documentUpdates) as $classAndDocuments) {
  466.                 [$class, $documents] = $classAndDocuments;
  467.                 $this->executeUpdates($class, $documents, $options);
  468.             }
  470.             foreach ($this->getClassesForCommitAction($this->documentDeletions, true) as $classAndDocuments) {
  471.                 [$class, $documents] = $classAndDocuments;
  472.                 $this->executeDeletions($class, $documents, $options);
  473.             }
  475.             // Raise postFlush
  476.             if ($this->evm->hasListeners(Events::postFlush)) {
  477.                 $this->evm->dispatchEvent(Events::postFlush, new Event\PostFlushEventArgs($this->dm));
  478.             }
  480.             // Clear up
  481.             $this->documentInsertions          =
  482.             $this->documentUpserts             =
  483.             $this->documentUpdates             =
  484.             $this->documentDeletions           =
  485.             $this->documentChangeSets          =
  486.             $this->collectionUpdates           =
  487.             $this->collectionDeletions         =
  488.             $this->visitedCollections          =
  489.             $this->scheduledForSynchronization =
  490.             $this->orphanRemovals              =
  491.             $this->hasScheduledCollections     = [];
  492.         } finally {
  493.             $this->commitsInProgress--;
  494.         }
  495.     }
  497.     /**
  498.      * Groups a list of scheduled documents by their class.
  499.      *
  500.      * @param array<string, object> $documents
  501.      *
  502.      * @psalm-return array<class-string, array{0: ClassMetadata<object>, 1: array<string, object>}>
  503.      */
  504.     private function getClassesForCommitAction(array $documents, bool $includeEmbedded = false): array
  505.     {
  506.         if (empty($documents)) {
  507.             return [];
  508.         }
  510.         $divided = [];
  511.         $embeds  = [];
  512.         foreach ($documents as $oid => $d) {
  513.             $className = get_class($d);
  514.             if (isset($embeds[$className])) {
  515.                 continue;
  516.             }
  518.             if (isset($divided[$className])) {
  519.                 $divided[$className][1][$oid] = $d;
  520.                 continue;
  521.             }
  523.             $class = $this->dm->getClassMetadata($className);
  524.             if ($class->isEmbeddedDocument && ! $includeEmbedded) {
  525.                 $embeds[$className] = true;
  526.                 continue;
  527.             }
  529.             if ($class->isView()) {
  530.                 continue;
  531.             }
  533.             if (empty($divided[$class->name])) {
  534.                 $divided[$class->name] = [$class, [$oid => $d]];
  535.             } else {
  536.                 $divided[$class->name][1][$oid] = $d;
  537.             }
  538.         }
  540.         return $divided;
  541.     }
  543.     /**
  544.      * Compute changesets of all documents scheduled for insertion.
  545.      *
  546.      * Embedded documents will not be processed.
  547.      */
  548.     private function computeScheduleInsertsChangeSets(): void
  549.     {
  550.         foreach ($this->documentInsertions as $document) {
  551.             $class = $this->dm->getClassMetadata(get_class($document));
  552.             if ($class->isEmbeddedDocument || $class->isView()) {
  553.                 continue;
  554.             }
  556.             $this->computeChangeSet($class, $document);
  557.         }
  558.     }
  560.     /**
  561.      * Compute changesets of all documents scheduled for upsert.
  562.      *
  563.      * Embedded documents will not be processed.
  564.      */
  565.     private function computeScheduleUpsertsChangeSets(): void
  566.     {
  567.         foreach ($this->documentUpserts as $document) {
  568.             $class = $this->dm->getClassMetadata(get_class($document));
  569.             if ($class->isEmbeddedDocument || $class->isView()) {
  570.                 continue;
  571.             }
  573.             $this->computeChangeSet($class, $document);
  574.         }
  575.     }
  577.     /**
  578.      * Gets the changeset for a document.
  579.      *
  580.      * @return array array('property' => array(0 => mixed, 1 => mixed))
  581.      * @psalm-return array<string, ChangeSet>
  582.      */
  583.     public function getDocumentChangeSet(object $document): array
  584.     {
  585.         $oid = spl_object_hash($document);
  587.         return $this->documentChangeSets[$oid] ?? [];
  588.     }
  590.     /**
  591.      * Sets the changeset for a document.
  592.      *
  593.      * @internal
  594.      *
  595.      * @psalm-param array<string, ChangeSet> $changeset
  596.      */
  597.     public function setDocumentChangeSet(object $document, array $changeset): void
  598.     {
  599.         $this->documentChangeSets[spl_object_hash($document)] = $changeset;
  600.     }
  602.     /**
  603.      * Get a documents actual data, flattening all the objects to arrays.
  604.      *
  605.      * @internal
  606.      *
  607.      * @return array<string, mixed>
  608.      */
  609.     public function getDocumentActualData(object $document): array
  610.     {
  611.         $class      = $this->dm->getClassMetadata(get_class($document));
  612.         $actualData = [];
  613.         foreach ($class->reflFields as $name => $refProp) {
  614.             $mapping = $class->fieldMappings[$name];
  615.             // skip not saved fields
  616.             if (isset($mapping['notSaved']) && $mapping['notSaved'] === true) {
  617.                 continue;
  618.             }
  620.             $value = $refProp->getValue($document);
  621.             if (
  622.                 (isset($mapping['association']) && $mapping['type'] === ClassMetadata::MANY)
  623.                 && $value !== null && ! ($value instanceof PersistentCollectionInterface)
  624.             ) {
  625.                 // If $actualData[$name] is not a Collection then use an ArrayCollection.
  626.                 if (! $value instanceof Collection) {
  627.                     $value = new ArrayCollection($value);
  628.                 }
  630.                 // Inject PersistentCollection
  631.                 $coll = $this->dm->getConfiguration()->getPersistentCollectionFactory()->create($this->dm, $mapping, $value);
  632.                 $coll->setOwner($document, $mapping);
  633.                 $coll->setDirty(! $value->isEmpty());
  634.                 $class->reflFields[$name]->setValue($document, $coll);
  635.                 $actualData[$name] = $coll;
  636.             } else {
  637.                 $actualData[$name] = $value;
  638.             }
  639.         }
  641.         return $actualData;
  642.     }
  644.     /**
  645.      * Computes the changes that happened to a single document.
  646.      *
  647.      * Modifies/populates the following properties:
  648.      *
  649.      * {@link originalDocumentData}
  650.      * If the document is NEW or MANAGED but not yet fully persisted (only has an id)
  651.      * then it was not fetched from the database and therefore we have no original
  652.      * document data yet. All of the current document data is stored as the original document data.
  653.      *
  654.      * {@link documentChangeSets}
  655.      * The changes detected on all properties of the document are stored there.
  656.      * A change is a tuple array where the first entry is the old value and the second
  657.      * entry is the new value of the property. Changesets are used by persisters
  658.      * to INSERT/UPDATE the persistent document state.
  659.      *
  660.      * {@link documentUpdates}
  661.      * If the document is already fully MANAGED (has been fetched from the database before)
  662.      * and any changes to its properties are detected, then a reference to the document is stored
  663.      * there to mark it for an update.
  664.      *
  665.      * @psalm-param ClassMetadata<T> $class
  666.      * @psalm-param T $document
  667.      *
  668.      * @template T of object
  669.      */
  670.     public function computeChangeSet(ClassMetadata $class, object $document): void
  671.     {
  672.         if (! $class->isInheritanceTypeNone()) {
  673.             $class = $this->dm->getClassMetadata(get_class($document));
  674.         }
  676.         // Fire PreFlush lifecycle callbacks
  677.         if (! empty($class->lifecycleCallbacks[Events::preFlush])) {
  678.             $class->invokeLifecycleCallbacks(Events::preFlush, $document, [new Event\PreFlushEventArgs($this->dm)]);
  679.         }
  681.         $this->computeOrRecomputeChangeSet($class, $document);
  682.     }
  684.     /**
  685.      * Used to do the common work of computeChangeSet and recomputeSingleDocumentChangeSet
  686.      *
  687.      * @psalm-param ClassMetadata<T> $class
  688.      * @psalm-param T $document
  689.      *
  690.      * @template T of object
  691.      */
  692.     private function computeOrRecomputeChangeSet(ClassMetadata $class, object $document, bool $recompute = false): void
  693.     {
  694.         if ($class->isView()) {
  695.             return;
  696.         }
  698.         $oid           = spl_object_hash($document);
  699.         $actualData    = $this->getDocumentActualData($document);
  700.         $isNewDocument = ! isset($this->originalDocumentData[$oid]);
  701.         if ($isNewDocument) {
  702.             // Document is either NEW or MANAGED but not yet fully persisted (only has an id).
  703.             // These result in an INSERT.
  704.             $this->originalDocumentData[$oid] = $actualData;
  705.             $changeSet                        = [];
  706.             foreach ($actualData as $propName => $actualValue) {
  707.                 /* At this PersistentCollection shouldn't be here, probably it
  708.                  * was cloned and its ownership must be fixed
  709.                  */
  710.                 if ($actualValue instanceof PersistentCollectionInterface && $actualValue->getOwner() !== $document) {
  711.                     $actualData[$propName] = $this->fixPersistentCollectionOwnership($actualValue, $document, $class, $propName);
  712.                     $actualValue           = $actualData[$propName];
  713.                 }
  715.                 // ignore inverse side of reference relationship
  716.                 if (isset($class->fieldMappings[$propName]['reference']) && $class->fieldMappings[$propName]['isInverseSide']) {
  717.                     continue;
  718.                 }
  720.                 $changeSet[$propName] = [null, $actualValue];
  721.             }
  723.             $this->documentChangeSets[$oid] = $changeSet;
  724.         } else {
  725.             if ($class->isReadOnly) {
  726.                 return;
  727.             }
  729.             // Document is "fully" MANAGED: it was already fully persisted before
  730.             // and we have a copy of the original data
  731.             $originalData           = $this->originalDocumentData[$oid];
  732.             $isChangeTrackingNotify = $class->isChangeTrackingNotify();
  733.             if ($isChangeTrackingNotify && ! $recompute && isset($this->documentChangeSets[$oid])) {
  734.                 $changeSet = $this->documentChangeSets[$oid];
  735.             } else {
  736.                 $changeSet = [];
  737.             }
  739.             $gridFSMetadataProperty = null;
  741.             if ($class->isFile) {
  742.                 try {
  743.                     $gridFSMetadata         = $class->getFieldMappingByDbFieldName('metadata');
  744.                     $gridFSMetadataProperty = $gridFSMetadata['fieldName'];
  745.                 } catch (MappingException $e) {
  746.                 }
  747.             }
  749.             foreach ($actualData as $propName => $actualValue) {
  750.                 // skip not saved fields
  751.                 if (
  752.                     (isset($class->fieldMappings[$propName]['notSaved']) && $class->fieldMappings[$propName]['notSaved'] === true) ||
  753.                     ($class->isFile && $propName !== $gridFSMetadataProperty)
  754.                 ) {
  755.                     continue;
  756.                 }
  758.                 $orgValue = $originalData[$propName] ?? null;
  760.                 // skip if value has not changed
  761.                 if ($orgValue === $actualValue) {
  762.                     if (! $actualValue instanceof PersistentCollectionInterface) {
  763.                         continue;
  764.                     }
  766.                     if (! $actualValue->isDirty() && ! $this->isCollectionScheduledForDeletion($actualValue)) {
  767.                         // consider dirty collections as changed as well
  768.                         continue;
  769.                     }
  770.                 }
  772.                 // if relationship is a embed-one, schedule orphan removal to trigger cascade remove operations
  773.                 if (isset($class->fieldMappings[$propName]['embedded']) && $class->fieldMappings[$propName]['type'] === ClassMetadata::ONE) {
  774.                     if ($orgValue !== null) {
  775.                         $this->scheduleOrphanRemoval($orgValue);
  776.                     }
  778.                     $changeSet[$propName] = [$orgValue, $actualValue];
  779.                     continue;
  780.                 }
  782.                 // if owning side of reference-one relationship
  783.                 if (isset($class->fieldMappings[$propName]['reference']) && $class->fieldMappings[$propName]['type'] === ClassMetadata::ONE && $class->fieldMappings[$propName]['isOwningSide']) {
  784.                     if ($orgValue !== null && $class->fieldMappings[$propName]['orphanRemoval']) {
  785.                         $this->scheduleOrphanRemoval($orgValue);
  786.                     }
  788.                     $changeSet[$propName] = [$orgValue, $actualValue];
  789.                     continue;
  790.                 }
  792.                 if ($isChangeTrackingNotify) {
  793.                     continue;
  794.                 }
  796.                 // ignore inverse side of reference relationship
  797.                 if (isset($class->fieldMappings[$propName]['reference']) && $class->fieldMappings[$propName]['isInverseSide']) {
  798.                     continue;
  799.                 }
  801.                 // Persistent collection was exchanged with the "originally"
  802.                 // created one. This can only mean it was cloned and replaced
  803.                 // on another document.
  804.                 if ($actualValue instanceof PersistentCollectionInterface && $actualValue->getOwner() !== $document) {
  805.                     $actualValue = $this->fixPersistentCollectionOwnership($actualValue, $document, $class, $propName);
  806.                 }
  808.                 // if embed-many or reference-many relationship
  809.                 if (isset($class->fieldMappings[$propName]['type']) && $class->fieldMappings[$propName]['type'] === ClassMetadata::MANY) {
  810.                     $changeSet[$propName] = [$orgValue, $actualValue];
  811.                     /* If original collection was exchanged with a non-empty value
  812.                      * and $set will be issued, there is no need to $unset it first
  813.                      */
  814.                     if ($actualValue && $actualValue->isDirty() && CollectionHelper::usesSet($class->fieldMappings[$propName]['strategy'])) {
  815.                         continue;
  816.                     }
  818.                     if ($orgValue !== $actualValue && $orgValue instanceof PersistentCollectionInterface) {
  819.                         $this->scheduleCollectionDeletion($orgValue);
  820.                     }
  822.                     continue;
  823.                 }
  825.                 // skip equivalent date values
  826.                 if (isset($class->fieldMappings[$propName]['type']) && $class->fieldMappings[$propName]['type'] === 'date') {
  827.                     $dateType = Type::getType('date');
  828.                     assert($dateType instanceof DateType);
  829.                     $dbOrgValue    = $dateType->convertToDatabaseValue($orgValue);
  830.                     $dbActualValue = $dateType->convertToDatabaseValue($actualValue);
  832.                     $orgTimestamp    = $dbOrgValue instanceof UTCDateTime ? $dbOrgValue->toDateTime()->getTimestamp() : null;
  833.                     $actualTimestamp = $dbActualValue instanceof UTCDateTime ? $dbActualValue->toDateTime()->getTimestamp() : null;
  835.                     if ($orgTimestamp === $actualTimestamp) {
  836.                         continue;
  837.                     }
  838.                 }
  840.                 // regular field
  841.                 $changeSet[$propName] = [$orgValue, $actualValue];
  842.             }
  844.             if ($changeSet) {
  845.                 $this->documentChangeSets[$oid] = isset($this->documentChangeSets[$oid])
  846.                     ? $changeSet + $this->documentChangeSets[$oid]
  847.                     : $changeSet;
  849.                 $this->originalDocumentData[$oid] = $actualData;
  850.                 $this->scheduleForUpdate($document);
  851.             }
  852.         }
  854.         // Look for changes in associations of the document
  855.         $associationMappings = array_filter(
  856.             $class->associationMappings,
  857.             static function ($assoc) {
  858.                 return empty($assoc['notSaved']);
  859.             }
  860.         );
  862.         foreach ($associationMappings as $mapping) {
  863.             $value = $class->reflFields[$mapping['fieldName']]->getValue($document);
  865.             if ($value === null) {
  866.                 continue;
  867.             }
  869.             $this->computeAssociationChanges($document, $mapping, $value);
  871.             if (isset($mapping['reference'])) {
  872.                 continue;
  873.             }
  875.             $values = $mapping['type'] === ClassMetadata::ONE ? [$value] : $value->unwrap();
  877.             foreach ($values as $obj) {
  878.                 $oid2 = spl_object_hash($obj);
  880.                 if (! isset($this->documentChangeSets[$oid2])) {
  881.                     continue;
  882.                 }
  884.                 if (empty($this->documentChangeSets[$oid][$mapping['fieldName']])) {
  885.                     // instance of $value is the same as it was previously otherwise there would be
  886.                     // change set already in place
  887.                     $this->documentChangeSets[$oid][$mapping['fieldName']] = [$value, $value];
  888.                 }
  890.                 if (! $isNewDocument) {
  891.                     $this->scheduleForUpdate($document);
  892.                 }
  894.                 break;
  895.             }
  896.         }
  897.     }
  899.     /**
  900.      * Computes all the changes that have been done to documents and collections
  901.      * since the last commit and stores these changes in the _documentChangeSet map
  902.      * temporarily for access by the persisters, until the UoW commit is finished.
  903.      */
  904.     public function computeChangeSets(): void
  905.     {
  906.         $this->computeScheduleInsertsChangeSets();
  907.         $this->computeScheduleUpsertsChangeSets();
  909.         // Compute changes for other MANAGED documents. Change tracking policies take effect here.
  910.         foreach ($this->identityMap as $className => $documents) {
  911.             $class = $this->dm->getClassMetadata($className);
  912.             if ($class->isEmbeddedDocument || $class->isView()) {
  913.                 /* we do not want to compute changes to embedded documents up front
  914.                  * in case embedded document was replaced and its changeset
  915.                  * would corrupt data. Embedded documents' change set will
  916.                  * be calculated by reachability from owning document.
  917.                  */
  918.                 continue;
  919.             }
  921.             // If change tracking is explicit or happens through notification, then only compute
  922.             // changes on document of that type that are explicitly marked for synchronization.
  923.             switch (true) {
  924.                 case $class->isChangeTrackingDeferredImplicit():
  925.                     $documentsToProcess = $documents;
  926.                     break;
  928.                 case isset($this->scheduledForSynchronization[$className]):
  929.                     $documentsToProcess = $this->scheduledForSynchronization[$className];
  930.                     break;
  932.                 default:
  933.                     $documentsToProcess = [];
  934.             }
  936.             foreach ($documentsToProcess as $document) {
  937.                 // Ignore uninitialized proxy objects
  938.                 if ($document instanceof GhostObjectInterface && ! $document->isProxyInitialized()) {
  939.                     continue;
  940.                 }
  942.                 // Only MANAGED documents that are NOT SCHEDULED FOR INSERTION, UPSERT OR DELETION are processed here.
  943.                 $oid = spl_object_hash($document);
  944.                 if (
  945.                     isset($this->documentInsertions[$oid])
  946.                     || isset($this->documentUpserts[$oid])
  947.                     || isset($this->documentDeletions[$oid])
  948.                     || ! isset($this->documentStates[$oid])
  949.                 ) {
  950.                     continue;
  951.                 }
  953.                 $this->computeChangeSet($class, $document);
  954.             }
  955.         }
  956.     }
  958.     /**
  959.      * Computes the changes of an association.
  960.      *
  961.      * @param mixed $value The value of the association.
  962.      * @psalm-param AssociationFieldMapping $assoc
  963.      *
  964.      * @throws InvalidArgumentException
  965.      */
  966.     private function computeAssociationChanges(object $parentDocument, array $assoc, $value): void
  967.     {
  968.         $isNewParentDocument   = isset($this->documentInsertions[spl_object_hash($parentDocument)]);
  969.         $class                 = $this->dm->getClassMetadata(get_class($parentDocument));
  970.         $topOrExistingDocument = ( ! $isNewParentDocument || ! $class->isEmbeddedDocument);
  972.         if ($value instanceof GhostObjectInterface && ! $value->isProxyInitialized()) {
  973.             return;
  974.         }
  976.         if ($value instanceof PersistentCollectionInterface && $value->isDirty() && $value->getOwner() !== null && ($assoc['isOwningSide'] || isset($assoc['embedded']))) {
  977.             if ($topOrExistingDocument || CollectionHelper::usesSet($assoc['strategy'])) {
  978.                 $this->scheduleCollectionUpdate($value);
  979.             }
  981.             $topmostOwner                                               = $this->getOwningDocument($value->getOwner());
  982.             $this->visitedCollections[spl_object_hash($topmostOwner)][] = $value;
  983.             if (! empty($assoc['orphanRemoval']) || isset($assoc['embedded'])) {
  984.                 $value->initialize();
  985.                 foreach ($value->getDeletedDocuments() as $orphan) {
  986.                     $this->scheduleOrphanRemoval($orphan);
  987.                 }
  988.             }
  989.         }
  991.         // Look through the documents, and in any of their associations,
  992.         // for transient (new) documents, recursively. ("Persistence by reachability")
  993.         // Unwrap. Uninitialized collections will simply be empty.
  994.         $unwrappedValue = $assoc['type'] === ClassMetadata::ONE ? [$value] : $value->unwrap();
  996.         $count = 0;
  997.         foreach ($unwrappedValue as $key => $entry) {
  998.             if (! is_object($entry)) {
  999.                 throw new InvalidArgumentException(
  1000.                     sprintf('Expected object, found "%s" in %s::%s', $entry, get_class($parentDocument), $assoc['name'])
  1001.                 );
  1002.             }
  1004.             $targetClass = $this->dm->getClassMetadata(get_class($entry));
  1006.             $state = $this->getDocumentState($entry, self::STATE_NEW);
  1008.             // Handle "set" strategy for multi-level hierarchy
  1009.             $pathKey = ! isset($assoc['strategy']) || CollectionHelper::isList($assoc['strategy']) ? $count : $key;
  1010.             $path    = $assoc['type'] === ClassMetadata::MANY ? $assoc['name'] . '.' . $pathKey : $assoc['name'];
  1012.             $count++;
  1014.             switch ($state) {
  1015.                 case self::STATE_NEW:
  1016.                     if (! $assoc['isCascadePersist']) {
  1017.                         throw new InvalidArgumentException('A new document was found through a relationship that was not'
  1018.                             . ' configured to cascade persist operations: ' . $this->objToStr($entry) . '.'
  1019.                             . ' Explicitly persist the new document or configure cascading persist operations'
  1020.                             . ' on the relationship.');
  1021.                     }
  1023.                     $this->persistNew($targetClass, $entry);
  1024.                     $this->setParentAssociation($entry, $assoc, $parentDocument, $path);
  1025.                     $this->computeChangeSet($targetClass, $entry);
  1026.                     break;
  1028.                 case self::STATE_MANAGED:
  1029.                     if ($targetClass->isEmbeddedDocument) {
  1030.                         [, $knownParent] = $this->getParentAssociation($entry);
  1031.                         if ($knownParent && $knownParent !== $parentDocument) {
  1032.                             $entry = clone $entry;
  1033.                             if ($assoc['type'] === ClassMetadata::ONE) {
  1034.                                 $class->setFieldValue($parentDocument, $assoc['fieldName'], $entry);
  1035.                                 $this->setOriginalDocumentProperty(spl_object_hash($parentDocument), $assoc['fieldName'], $entry);
  1036.                                 $poid = spl_object_hash($parentDocument);
  1037.                                 if (isset($this->documentChangeSets[$poid][$assoc['fieldName']])) {
  1038.                                     $this->documentChangeSets[$poid][$assoc['fieldName']][1] = $entry;
  1039.                                 }
  1040.                             } else {
  1041.                                 // must use unwrapped value to not trigger orphan removal
  1042.                                 $unwrappedValue[$key] = $entry;
  1043.                             }
  1045.                             $this->persistNew($targetClass, $entry);
  1046.                         }
  1048.                         $this->setParentAssociation($entry, $assoc, $parentDocument, $path);
  1049.                         $this->computeChangeSet($targetClass, $entry);
  1050.                     }
  1052.                     break;
  1054.                 case self::STATE_REMOVED:
  1055.                     // Consume the $value as array (it's either an array or an ArrayAccess)
  1056.                     // and remove the element from Collection.
  1057.                     if ($assoc['type'] === ClassMetadata::MANY) {
  1058.                         unset($value[$key]);
  1059.                     }
  1061.                     break;
  1063.                 case self::STATE_DETACHED:
  1064.                     // Can actually not happen right now as we assume STATE_NEW,
  1065.                     // so the exception will be raised from the DBAL layer (constraint violation).
  1066.                     throw new InvalidArgumentException('A detached document was found through a '
  1067.                         . 'relationship during cascading a persist operation.');
  1069.                 default:
  1070.                     // MANAGED associated documents are already taken into account
  1071.                     // during changeset calculation anyway, since they are in the identity map.
  1072.             }
  1073.         }
  1074.     }
  1076.     /**
  1077.      * Computes the changeset of an individual document, independently of the
  1078.      * computeChangeSets() routine that is used at the beginning of a UnitOfWork#commit().
  1079.      *
  1080.      * The passed document must be a managed document. If the document already has a change set
  1081.      * because this method is invoked during a commit cycle then the change sets are added.
  1082.      * whereby changes detected in this method prevail.
  1083.      *
  1084.      * @psalm-param ClassMetadata<T> $class
  1085.      * @psalm-param T $document
  1086.      *
  1087.      * @throws InvalidArgumentException If the passed document is not MANAGED.
  1088.      *
  1089.      * @template T of object
  1090.      */
  1091.     public function recomputeSingleDocumentChangeSet(ClassMetadata $class, object $document): void
  1092.     {
  1093.         // Ignore uninitialized proxy objects
  1094.         if ($document instanceof GhostObjectInterface && ! $document->isProxyInitialized()) {
  1095.             return;
  1096.         }
  1098.         $oid = spl_object_hash($document);
  1100.         if (! isset($this->documentStates[$oid]) || $this->documentStates[$oid] !== self::STATE_MANAGED) {
  1101.             throw new InvalidArgumentException('Document must be managed.');
  1102.         }
  1104.         if (! $class->isInheritanceTypeNone()) {
  1105.             $class = $this->dm->getClassMetadata(get_class($document));
  1106.         }
  1108.         $this->computeOrRecomputeChangeSet($class, $document, true);
  1109.     }
  1111.     /**
  1112.      * @psalm-param ClassMetadata<T> $class
  1113.      * @psalm-param T $document
  1114.      *
  1115.      * @throws InvalidArgumentException If there is something wrong with document's identifier.
  1116.      *
  1117.      * @template T of object
  1118.      */
  1119.     private function persistNew(ClassMetadata $class, object $document): void
  1120.     {
  1121.         $this->lifecycleEventManager->prePersist($class, $document);
  1122.         $oid    = spl_object_hash($document);
  1123.         $upsert = false;
  1124.         if ($class->identifier) {
  1125.             $idValue = $class->getIdentifierValue($document);
  1126.             $upsert  = ! $class->isEmbeddedDocument && $idValue !== null;
  1128.             if ($class->generatorType === ClassMetadata::GENERATOR_TYPE_NONE && $idValue === null) {
  1129.                 throw new InvalidArgumentException(sprintf(
  1130.                     '%s uses NONE identifier generation strategy but no identifier was provided when persisting.',
  1131.                     get_class($document)
  1132.                 ));
  1133.             }
  1135.             if ($class->generatorType === ClassMetadata::GENERATOR_TYPE_AUTO && $idValue !== null && ! preg_match('#^[0-9a-f]{24}$#', (string) $idValue)) {
  1136.                 throw new InvalidArgumentException(sprintf(
  1137.                     '%s uses AUTO identifier generation strategy but provided identifier is not a valid ObjectId.',
  1138.                     get_class($document)
  1139.                 ));
  1140.             }
  1142.             if ($class->generatorType !== ClassMetadata::GENERATOR_TYPE_NONE && $idValue === null && $class->idGenerator !== null) {
  1143.                 $idValue = $class->idGenerator->generate($this->dm, $document);
  1144.                 $idValue = $class->getPHPIdentifierValue($class->getDatabaseIdentifierValue($idValue));
  1145.                 $class->setIdentifierValue($document, $idValue);
  1146.             }
  1148.             $this->documentIdentifiers[$oid] = $idValue;
  1149.         } else {
  1150.             // this is for embedded documents without identifiers
  1151.             $this->documentIdentifiers[$oid] = $oid;
  1152.         }
  1154.         $this->documentStates[$oid] = self::STATE_MANAGED;
  1156.         if ($upsert) {
  1157.             $this->scheduleForUpsert($class, $document);
  1158.         } else {
  1159.             $this->scheduleForInsert($class, $document);
  1160.         }
  1161.     }
  1163.     /**
  1164.      * Executes all document insertions for documents of the specified type.
  1165.      *
  1166.      * @psalm-param ClassMetadata<T> $class
  1167.      * @psalm-param T[] $documents
  1168.      * @psalm-param CommitOptions $options
  1169.      *
  1170.      * @template T of object
  1171.      */
  1172.     private function executeInserts(ClassMetadata $class, array $documents, array $options = []): void
  1173.     {
  1174.         $persister = $this->getDocumentPersister($class->name);
  1176.         foreach ($documents as $oid => $document) {
  1177.             $persister->addInsert($document);
  1178.             unset($this->documentInsertions[$oid]);
  1179.         }
  1181.         $persister->executeInserts($options);
  1183.         foreach ($documents as $document) {
  1184.             $this->lifecycleEventManager->postPersist($class, $document);
  1185.         }
  1186.     }
  1188.     /**
  1189.      * Executes all document upserts for documents of the specified type.
  1190.      *
  1191.      * @psalm-param ClassMetadata<T> $class
  1192.      * @psalm-param T[] $documents
  1193.      * @psalm-param CommitOptions $options
  1194.      *
  1195.      * @template T of object
  1196.      */
  1197.     private function executeUpserts(ClassMetadata $class, array $documents, array $options = []): void
  1198.     {
  1199.         $persister = $this->getDocumentPersister($class->name);
  1201.         foreach ($documents as $oid => $document) {
  1202.             $persister->addUpsert($document);
  1203.             unset($this->documentUpserts[$oid]);
  1204.         }
  1206.         $persister->executeUpserts($options);
  1208.         foreach ($documents as $document) {
  1209.             $this->lifecycleEventManager->postPersist($class, $document);
  1210.         }
  1211.     }
  1213.     /**
  1214.      * Executes all document updates for documents of the specified type.
  1215.      *
  1216.      * @psalm-param ClassMetadata<T> $class
  1217.      * @psalm-param T[] $documents
  1218.      * @psalm-param CommitOptions $options
  1219.      *
  1220.      * @template T of object
  1221.      */
  1222.     private function executeUpdates(ClassMetadata $class, array $documents, array $options = []): void
  1223.     {
  1224.         if ($class->isReadOnly) {
  1225.             return;
  1226.         }
  1228.         $className = $class->name;
  1229.         $persister = $this->getDocumentPersister($className);
  1231.         foreach ($documents as $oid => $document) {
  1232.             $this->lifecycleEventManager->preUpdate($class, $document);
  1234.             if (! empty($this->documentChangeSets[$oid]) || $this->hasScheduledCollections($document)) {
  1235.                 $persister->update($document, $options);
  1236.             }
  1238.             unset($this->documentUpdates[$oid]);
  1240.             $this->lifecycleEventManager->postUpdate($class, $document);
  1241.         }
  1242.     }
  1244.     /**
  1245.      * Executes all document deletions for documents of the specified type.
  1246.      *
  1247.      * @psalm-param ClassMetadata<T> $class
  1248.      * @psalm-param T[] $documents
  1249.      * @psalm-param CommitOptions $options
  1250.      *
  1251.      * @template T of object
  1252.      */
  1253.     private function executeDeletions(ClassMetadata $class, array $documents, array $options = []): void
  1254.     {
  1255.         $persister = $this->getDocumentPersister($class->name);
  1257.         foreach ($documents as $oid => $document) {
  1258.             if (! $class->isEmbeddedDocument) {
  1259.                 $persister->delete($document, $options);
  1260.             }
  1262.             unset(
  1263.                 $this->documentDeletions[$oid],
  1264.                 $this->documentIdentifiers[$oid],
  1265.                 $this->originalDocumentData[$oid]
  1266.             );
  1268.             // Clear snapshot information for any referenced PersistentCollection
  1269.             // http://www.doctrine-project.org/jira/browse/MODM-95
  1270.             foreach ($class->associationMappings as $fieldMapping) {
  1271.                 if (! isset($fieldMapping['type']) || $fieldMapping['type'] !== ClassMetadata::MANY) {
  1272.                     continue;
  1273.                 }
  1275.                 $value = $class->reflFields[$fieldMapping['fieldName']]->getValue($document);
  1276.                 if (! ($value instanceof PersistentCollectionInterface)) {
  1277.                     continue;
  1278.                 }
  1280.                 $value->clearSnapshot();
  1281.             }
  1283.             // Document with this $oid after deletion treated as NEW, even if the $oid
  1284.             // is obtained by a new document because the old one went out of scope.
  1285.             $this->documentStates[$oid] = self::STATE_NEW;
  1287.             $this->lifecycleEventManager->postRemove($class, $document);
  1288.         }
  1289.     }
  1291.     /**
  1292.      * Schedules a document for insertion into the database.
  1293.      * If the document already has an identifier, it will be added to the
  1294.      * identity map.
  1295.      *
  1296.      * @internal
  1297.      *
  1298.      * @psalm-param ClassMetadata<T> $class
  1299.      * @psalm-param T $document
  1300.      *
  1301.      * @throws InvalidArgumentException
  1302.      *
  1303.      * @template T of object
  1304.      */
  1305.     public function scheduleForInsert(ClassMetadata $class, object $document): void
  1306.     {
  1307.         $oid = spl_object_hash($document);
  1309.         if (isset($this->documentUpdates[$oid])) {
  1310.             throw new InvalidArgumentException('Dirty document can not be scheduled for insertion.');
  1311.         }
  1313.         if (isset($this->documentDeletions[$oid])) {
  1314.             throw new InvalidArgumentException('Removed document can not be scheduled for insertion.');
  1315.         }
  1317.         if (isset($this->documentInsertions[$oid])) {
  1318.             throw new InvalidArgumentException('Document can not be scheduled for insertion twice.');
  1319.         }
  1321.         $this->documentInsertions[$oid] = $document;
  1323.         if (! isset($this->documentIdentifiers[$oid])) {
  1324.             return;
  1325.         }
  1327.         $this->addToIdentityMap($document);
  1328.     }
  1330.     /**
  1331.      * Schedules a document for upsert into the database and adds it to the
  1332.      * identity map
  1333.      *
  1334.      * @internal
  1335.      *
  1336.      * @psalm-param ClassMetadata<T> $class
  1337.      * @psalm-param T $document
  1338.      *
  1339.      * @throws InvalidArgumentException
  1340.      *
  1341.      * @template T of object
  1342.      */
  1343.     public function scheduleForUpsert(ClassMetadata $class, object $document): void
  1344.     {
  1345.         $oid = spl_object_hash($document);
  1347.         if ($class->isEmbeddedDocument) {
  1348.             throw new InvalidArgumentException('Embedded document can not be scheduled for upsert.');
  1349.         }
  1351.         if (isset($this->documentUpdates[$oid])) {
  1352.             throw new InvalidArgumentException('Dirty document can not be scheduled for upsert.');
  1353.         }
  1355.         if (isset($this->documentDeletions[$oid])) {
  1356.             throw new InvalidArgumentException('Removed document can not be scheduled for upsert.');
  1357.         }
  1359.         if (isset($this->documentUpserts[$oid])) {
  1360.             throw new InvalidArgumentException('Document can not be scheduled for upsert twice.');
  1361.         }
  1363.         $this->documentUpserts[$oid]     = $document;
  1364.         $this->documentIdentifiers[$oid] = $class->getIdentifierValue($document);
  1365.         $this->addToIdentityMap($document);
  1366.     }
  1368.     /**
  1369.      * Checks whether a document is scheduled for insertion.
  1370.      */
  1371.     public function isScheduledForInsert(object $document): bool
  1372.     {
  1373.         return isset($this->documentInsertions[spl_object_hash($document)]);
  1374.     }
  1376.     /**
  1377.      * Checks whether a document is scheduled for upsert.
  1378.      */
  1379.     public function isScheduledForUpsert(object $document): bool
  1380.     {
  1381.         return isset($this->documentUpserts[spl_object_hash($document)]);
  1382.     }
  1384.     /**
  1385.      * Schedules a document for being updated.
  1386.      *
  1387.      * @internal
  1388.      *
  1389.      * @throws InvalidArgumentException
  1390.      */
  1391.     public function scheduleForUpdate(object $document): void
  1392.     {
  1393.         $oid = spl_object_hash($document);
  1394.         if (! isset($this->documentIdentifiers[$oid])) {
  1395.             throw new InvalidArgumentException('Document has no identity.');
  1396.         }
  1398.         if (isset($this->documentDeletions[$oid])) {
  1399.             throw new InvalidArgumentException('Document is removed.');
  1400.         }
  1402.         if (
  1403.             isset($this->documentUpdates[$oid])
  1404.             || isset($this->documentInsertions[$oid])
  1405.             || isset($this->documentUpserts[$oid])
  1406.         ) {
  1407.             return;
  1408.         }
  1410.         $this->documentUpdates[$oid] = $document;
  1411.     }
  1413.     /**
  1414.      * Checks whether a document is registered as dirty in the unit of work.
  1415.      * Note: Is not very useful currently as dirty documents are only registered
  1416.      * at commit time.
  1417.      */
  1418.     public function isScheduledForUpdate(object $document): bool
  1419.     {
  1420.         return isset($this->documentUpdates[spl_object_hash($document)]);
  1421.     }
  1423.     /**
  1424.      * Checks whether a document is registered to be checked in the unit of work.
  1425.      */
  1426.     public function isScheduledForSynchronization(object $document): bool
  1427.     {
  1428.         $class = $this->dm->getClassMetadata(get_class($document));
  1430.         return isset($this->scheduledForSynchronization[$class->name][spl_object_hash($document)]);
  1431.     }
  1433.     /**
  1434.      * Schedules a document for deletion.
  1435.      *
  1436.      * @internal
  1437.      */
  1438.     public function scheduleForDelete(object $document, bool $isView = false): void
  1439.     {
  1440.         $oid = spl_object_hash($document);
  1442.         if (isset($this->documentInsertions[$oid])) {
  1443.             if ($this->isInIdentityMap($document)) {
  1444.                 $this->removeFromIdentityMap($document);
  1445.             }
  1447.             unset($this->documentInsertions[$oid]);
  1449.             return; // document has not been persisted yet, so nothing more to do.
  1450.         }
  1452.         if (! $this->isInIdentityMap($document)) {
  1453.             return; // ignore
  1454.         }
  1456.         $this->removeFromIdentityMap($document);
  1457.         $this->documentStates[$oid] = self::STATE_REMOVED;
  1459.         if (isset($this->documentUpdates[$oid])) {
  1460.             unset($this->documentUpdates[$oid]);
  1461.         }
  1463.         if (isset($this->documentUpserts[$oid])) {
  1464.             unset($this->documentUpserts[$oid]);
  1465.         }
  1467.         if (isset($this->documentDeletions[$oid])) {
  1468.             return;
  1469.         }
  1471.         if ($isView) {
  1472.             return;
  1473.         }
  1475.         $this->documentDeletions[$oid] = $document;
  1476.     }
  1478.     /**
  1479.      * Checks whether a document is registered as removed/deleted with the unit
  1480.      * of work.
  1481.      */
  1482.     public function isScheduledForDelete(object $document): bool
  1483.     {
  1484.         return isset($this->documentDeletions[spl_object_hash($document)]);
  1485.     }
  1487.     /**
  1488.      * Checks whether a document is scheduled for insertion, update or deletion.
  1489.      *
  1490.      * @internal
  1491.      */
  1492.     public function isDocumentScheduled(object $document): bool
  1493.     {
  1494.         $oid = spl_object_hash($document);
  1496.         return isset($this->documentInsertions[$oid]) ||
  1497.             isset($this->documentUpserts[$oid]) ||
  1498.             isset($this->documentUpdates[$oid]) ||
  1499.             isset($this->documentDeletions[$oid]);
  1500.     }
  1502.     /**
  1503.      * Registers a document in the identity map.
  1504.      *
  1505.      * Note that documents in a hierarchy are registered with the class name of
  1506.      * the root document. Identifiers are serialized before being used as array
  1507.      * keys to allow differentiation of equal, but not identical, values.
  1508.      *
  1509.      * @internal
  1510.      */
  1511.     public function addToIdentityMap(object $document): bool
  1512.     {
  1513.         $class = $this->dm->getClassMetadata(get_class($document));
  1514.         $id    = $this->getIdForIdentityMap($document);
  1516.         if (isset($this->identityMap[$class->name][$id])) {
  1517.             return false;
  1518.         }
  1520.         $this->identityMap[$class->name][$id] = $document;
  1522.         if (
  1523.             $document instanceof NotifyPropertyChanged &&
  1524.             ( ! $document instanceof GhostObjectInterface || $document->isProxyInitialized())
  1525.         ) {
  1526.             $document->addPropertyChangedListener($this);
  1527.         }
  1529.         return true;
  1530.     }
  1532.     /**
  1533.      * Gets the state of a document with regard to the current unit of work.
  1534.      *
  1535.      * @param int|null $assume The state to assume if the state is not yet known (not MANAGED or REMOVED).
  1536.      *                         This parameter can be set to improve performance of document state detection
  1537.      *                         by potentially avoiding a database lookup if the distinction between NEW and DETACHED
  1538.      *                         is either known or does not matter for the caller of the method.
  1539.      */
  1540.     public function getDocumentState(object $document, ?int $assume = null): int
  1541.     {
  1542.         $oid = spl_object_hash($document);
  1544.         if (isset($this->documentStates[$oid])) {
  1545.             return $this->documentStates[$oid];
  1546.         }
  1548.         $class = $this->dm->getClassMetadata(get_class($document));
  1550.         if ($class->isEmbeddedDocument) {
  1551.             return self::STATE_NEW;
  1552.         }
  1554.         if ($assume !== null) {
  1555.             return $assume;
  1556.         }
  1558.         /* State can only be NEW or DETACHED, because MANAGED/REMOVED states are
  1559.          * known. Note that you cannot remember the NEW or DETACHED state in
  1560.          * _documentStates since the UoW does not hold references to such
  1561.          * objects and the object hash can be reused. More generally, because
  1562.          * the state may "change" between NEW/DETACHED without the UoW being
  1563.          * aware of it.
  1564.          */
  1565.         $id = $class->getIdentifierObject($document);
  1567.         if ($id === null) {
  1568.             return self::STATE_NEW;
  1569.         }
  1571.         // Check for a version field, if available, to avoid a DB lookup.
  1572.         if ($class->isVersioned && $class->versionField !== null) {
  1573.             return $class->getFieldValue($document, $class->versionField)
  1574.                 ? self::STATE_DETACHED
  1575.                 : self::STATE_NEW;
  1576.         }
  1578.         // Last try before DB lookup: check the identity map.
  1579.         if ($this->tryGetById($id, $class)) {
  1580.             return self::STATE_DETACHED;
  1581.         }
  1583.         // DB lookup
  1584.         if ($this->getDocumentPersister($class->name)->exists($document)) {
  1585.             return self::STATE_DETACHED;
  1586.         }
  1588.         return self::STATE_NEW;
  1589.     }
  1591.     /**
  1592.      * Removes a document from the identity map. This effectively detaches the
  1593.      * document from the persistence management of Doctrine.
  1594.      *
  1595.      * @internal
  1596.      *
  1597.      * @throws InvalidArgumentException
  1598.      */
  1599.     public function removeFromIdentityMap(object $document): bool
  1600.     {
  1601.         $oid = spl_object_hash($document);
  1603.         // Check if id is registered first
  1604.         if (! isset($this->documentIdentifiers[$oid])) {
  1605.             return false;
  1606.         }
  1608.         $class = $this->dm->getClassMetadata(get_class($document));
  1609.         $id    = $this->getIdForIdentityMap($document);
  1611.         if (isset($this->identityMap[$class->name][$id])) {
  1612.             unset($this->identityMap[$class->name][$id]);
  1613.             $this->documentStates[$oid] = self::STATE_DETACHED;
  1615.             return true;
  1616.         }
  1618.         return false;
  1619.     }
  1621.     /**
  1622.      * Gets a document in the identity map by its identifier hash.
  1623.      *
  1624.      * @internal
  1625.      *
  1626.      * @param mixed $id Document identifier
  1627.      * @psalm-param ClassMetadata<T> $class
  1628.      *
  1629.      * @psalm-return T
  1630.      *
  1631.      * @throws InvalidArgumentException If the class does not have an identifier.
  1632.      *
  1633.      * @template T of object
  1634.      *
  1635.      * @psalm-suppress InvalidReturnStatement, InvalidReturnType because of the inability of defining a generic property map
  1636.      */
  1637.     public function getById($id, ClassMetadata $class): object
  1638.     {
  1639.         if (! $class->identifier) {
  1640.             throw new InvalidArgumentException(sprintf('Class "%s" does not have an identifier', $class->name));
  1641.         }
  1643.         $serializedId = serialize($class->getDatabaseIdentifierValue($id));
  1645.         return $this->identityMap[$class->name][$serializedId];
  1646.     }
  1648.     /**
  1649.      * Tries to get a document by its identifier hash. If no document is found
  1650.      * for the given hash, FALSE is returned.
  1651.      *
  1652.      * @internal
  1653.      *
  1654.      * @param mixed $id Document identifier
  1655.      * @psalm-param ClassMetadata<T> $class
  1656.      *
  1657.      * @return mixed The found document or FALSE.
  1658.      * @psalm-return T|false
  1659.      *
  1660.      * @throws InvalidArgumentException If the class does not have an identifier.
  1661.      *
  1662.      * @template T of object
  1663.      *
  1664.      * @psalm-suppress InvalidReturnStatement, InvalidReturnType because of the inability of defining a generic property map
  1665.      */
  1666.     public function tryGetById($id, ClassMetadata $class)
  1667.     {
  1668.         if (! $class->identifier) {
  1669.             throw new InvalidArgumentException(sprintf('Class "%s" does not have an identifier', $class->name));
  1670.         }
  1672.         $serializedId = serialize($class->getDatabaseIdentifierValue($id));
  1674.         return $this->identityMap[$class->name][$serializedId] ?? false;
  1675.     }
  1677.     /**
  1678.      * Schedules a document for dirty-checking at commit-time.
  1679.      *
  1680.      * @internal
  1681.      */
  1682.     public function scheduleForSynchronization(object $document): void
  1683.     {
  1684.         $class                                                                       = $this->dm->getClassMetadata(get_class($document));
  1685.         $this->scheduledForSynchronization[$class->name][spl_object_hash($document)] = $document;
  1686.     }
  1688.     /**
  1689.      * Checks whether a document is registered in the identity map.
  1690.      *
  1691.      * @internal
  1692.      */
  1693.     public function isInIdentityMap(object $document): bool
  1694.     {
  1695.         $oid = spl_object_hash($document);
  1697.         if (! isset($this->documentIdentifiers[$oid])) {
  1698.             return false;
  1699.         }
  1701.         $class = $this->dm->getClassMetadata(get_class($document));
  1702.         $id    = $this->getIdForIdentityMap($document);
  1704.         return isset($this->identityMap[$class->name][$id]);
  1705.     }
  1707.     private function getIdForIdentityMap(object $document): string
  1708.     {
  1709.         $class = $this->dm->getClassMetadata(get_class($document));
  1711.         if (! $class->identifier) {
  1712.             $id = spl_object_hash($document);
  1713.         } else {
  1714.             $id = $this->documentIdentifiers[spl_object_hash($document)];
  1715.             $id = serialize($class->getDatabaseIdentifierValue($id));
  1716.         }
  1718.         return $id;
  1719.     }
  1721.     /**
  1722.      * Checks whether an identifier exists in the identity map.
  1723.      *
  1724.      * @internal
  1725.      *
  1726.      * @param mixed $id
  1727.      */
  1728.     public function containsId($id, string $rootClassName): bool
  1729.     {
  1730.         return isset($this->identityMap[$rootClassName][serialize($id)]);
  1731.     }
  1733.     /**
  1734.      * Persists a document as part of the current unit of work.
  1735.      *
  1736.      * @internal
  1737.      *
  1738.      * @throws MongoDBException If trying to persist MappedSuperclass.
  1739.      * @throws InvalidArgumentException If there is something wrong with document's identifier.
  1740.      */
  1741.     public function persist(object $document): void
  1742.     {
  1743.         $class = $this->dm->getClassMetadata(get_class($document));
  1744.         if ($class->isMappedSuperclass || $class->isQueryResultDocument) {
  1745.             throw MongoDBException::cannotPersistMappedSuperclass($class->name);
  1746.         }
  1748.         $visited = [];
  1749.         $this->doPersist($document, $visited);
  1750.     }
  1752.     /**
  1753.      * Saves a document as part of the current unit of work.
  1754.      * This method is internally called during save() cascades as it tracks
  1755.      * the already visited documents to prevent infinite recursions.
  1756.      *
  1757.      * NOTE: This method always considers documents that are not yet known to
  1758.      * this UnitOfWork as NEW.
  1759.      *
  1760.      * @param array<string, object> $visited
  1761.      *
  1762.      * @throws InvalidArgumentException
  1763.      * @throws MongoDBException
  1764.      */
  1765.     private function doPersist(object $document, array &$visited): void
  1766.     {
  1767.         $oid = spl_object_hash($document);
  1768.         if (isset($visited[$oid])) {
  1769.             return; // Prevent infinite recursion
  1770.         }
  1772.         $visited[$oid] = $document; // Mark visited
  1774.         $class = $this->dm->getClassMetadata(get_class($document));
  1776.         $documentState = $this->getDocumentState($document, self::STATE_NEW);
  1777.         switch ($documentState) {
  1778.             case self::STATE_MANAGED:
  1779.                 // Nothing to do, except if policy is "deferred explicit"
  1780.                 if ($class->isChangeTrackingDeferredExplicit() && ! $class->isView()) {
  1781.                     $this->scheduleForSynchronization($document);
  1782.                 }
  1784.                 break;
  1785.             case self::STATE_NEW:
  1786.                 if ($class->isFile) {
  1787.                     throw MongoDBException::cannotPersistGridFSFile($class->name);
  1788.                 }
  1790.                 if ($class->isView()) {
  1791.                     return;
  1792.                 }
  1794.                 $this->persistNew($class, $document);
  1795.                 break;
  1797.             case self::STATE_REMOVED:
  1798.                 // Document becomes managed again
  1799.                 unset($this->documentDeletions[$oid]);
  1801.                 $this->documentStates[$oid] = self::STATE_MANAGED;
  1802.                 break;
  1804.             case self::STATE_DETACHED:
  1805.                 throw new InvalidArgumentException(
  1806.                     'Behavior of persist() for a detached document is not yet defined.'
  1807.                 );
  1809.             default:
  1810.                 throw MongoDBException::invalidDocumentState($documentState);
  1811.         }
  1813.         $this->cascadePersist($document, $visited);
  1814.     }
  1816.     /**
  1817.      * Deletes a document as part of the current unit of work.
  1818.      *
  1819.      * @internal
  1820.      */
  1821.     public function remove(object $document): void
  1822.     {
  1823.         $visited = [];
  1824.         $this->doRemove($document, $visited);
  1825.     }
  1827.     /**
  1828.      * Deletes a document as part of the current unit of work.
  1829.      *
  1830.      * This method is internally called during delete() cascades as it tracks
  1831.      * the already visited documents to prevent infinite recursions.
  1832.      *
  1833.      * @param array<string, object> $visited
  1834.      *
  1835.      * @throws MongoDBException
  1836.      */
  1837.     private function doRemove(object $document, array &$visited): void
  1838.     {
  1839.         $oid = spl_object_hash($document);
  1840.         if (isset($visited[$oid])) {
  1841.             return; // Prevent infinite recursion
  1842.         }
  1844.         $visited[$oid] = $document; // mark visited
  1846.         /* Cascade first, because scheduleForDelete() removes the entity from
  1847.          * the identity map, which can cause problems when a lazy Proxy has to
  1848.          * be initialized for the cascade operation.
  1849.          */
  1850.         $this->cascadeRemove($document, $visited);
  1852.         $class         = $this->dm->getClassMetadata(get_class($document));
  1853.         $documentState = $this->getDocumentState($document);
  1854.         switch ($documentState) {
  1855.             case self::STATE_NEW:
  1856.             case self::STATE_REMOVED:
  1857.                 // nothing to do
  1858.                 break;
  1859.             case self::STATE_MANAGED:
  1860.                 $this->lifecycleEventManager->preRemove($class, $document);
  1861.                 $this->scheduleForDelete($document, $class->isView());
  1862.                 break;
  1863.             case self::STATE_DETACHED:
  1864.                 throw MongoDBException::detachedDocumentCannotBeRemoved();
  1866.             default:
  1867.                 throw MongoDBException::invalidDocumentState($documentState);
  1868.         }
  1869.     }
  1871.     /**
  1872.      * Merges the state of the given detached document into this UnitOfWork.
  1873.      *
  1874.      * @internal
  1875.      */
  1876.     public function merge(object $document): object
  1877.     {
  1878.         $visited = [];
  1880.         return $this->doMerge($document, $visited);
  1881.     }
  1883.     /**
  1884.      * Executes a merge operation on a document.
  1885.      *
  1886.      * @param array<string, object> $visited
  1887.      * @psalm-param AssociationFieldMapping|null $assoc
  1888.      *
  1889.      * @throws InvalidArgumentException If the entity instance is NEW.
  1890.      * @throws LockException If the document uses optimistic locking through a
  1891.      *                       version attribute and the version check against the
  1892.      *                       managed copy fails.
  1893.      */
  1894.     private function doMerge(object $document, array &$visited, ?object $prevManagedCopy = null, ?array $assoc = null): object
  1895.     {
  1896.         $oid = spl_object_hash($document);
  1898.         if (isset($visited[$oid])) {
  1899.             return $visited[$oid]; // Prevent infinite recursion
  1900.         }
  1902.         $visited[$oid] = $document; // mark visited
  1904.         $class = $this->dm->getClassMetadata(get_class($document));
  1906.         /* First we assume DETACHED, although it can still be NEW but we can
  1907.          * avoid an extra DB round trip this way. If it is not MANAGED but has
  1908.          * an identity, we need to fetch it from the DB anyway in order to
  1909.          * merge. MANAGED documents are ignored by the merge operation.
  1910.          */
  1911.         $managedCopy = $document;
  1913.         if ($this->getDocumentState($document, self::STATE_DETACHED) !== self::STATE_MANAGED) {
  1914.             if ($document instanceof GhostObjectInterface && ! $document->isProxyInitialized()) {
  1915.                 $document->initializeProxy();
  1916.             }
  1918.             $identifier = $class->getIdentifier();
  1919.             // We always have one element in the identifier array but it might be null
  1920.             $id          = $identifier[0] !== null ? $class->getIdentifierObject($document) : null;
  1921.             $managedCopy = null;
  1923.             // Try to fetch document from the database
  1924.             if (! $class->isEmbeddedDocument && $id !== null) {
  1925.                 $managedCopy = $this->dm->find($class->name, $id);
  1927.                 // Managed copy may be removed in which case we can't merge
  1928.                 if ($managedCopy && $this->getDocumentState($managedCopy) === self::STATE_REMOVED) {
  1929.                     throw new InvalidArgumentException('Removed entity detected during merge. Cannot merge with a removed entity.');
  1930.                 }
  1932.                 if ($managedCopy instanceof GhostObjectInterface && ! $managedCopy->isProxyInitialized()) {
  1933.                     $managedCopy->initializeProxy();
  1934.                 }
  1935.             }
  1937.             if ($managedCopy === null) {
  1938.                 // Create a new managed instance
  1939.                 $managedCopy = $class->newInstance();
  1940.                 if ($id !== null) {
  1941.                     $class->setIdentifierValue($managedCopy, $id);
  1942.                 }
  1944.                 $this->persistNew($class, $managedCopy);
  1945.             }
  1947.             if ($class->isVersioned) {
  1948.                 $managedCopyVersion = $class->reflFields[$class->versionField]->getValue($managedCopy);
  1949.                 $documentVersion    = $class->reflFields[$class->versionField]->getValue($document);
  1951.                 // Throw exception if versions don't match
  1952.                 if ($managedCopyVersion !== $documentVersion) {
  1953.                     throw LockException::lockFailedVersionMissmatch($document, $documentVersion, $managedCopyVersion);
  1954.                 }
  1955.             }
  1957.             // Merge state of $document into existing (managed) document
  1958.             foreach ($class->reflClass->getProperties() as $nativeReflection) {
  1959.                 $name = $nativeReflection->name;
  1960.                 $prop = $this->reflectionService->getAccessibleProperty($class->name, $name);
  1961.                 assert($prop instanceof ReflectionProperty);
  1963.                 if (method_exists($prop, 'isInitialized') && ! $prop->isInitialized($document)) {
  1964.                     continue;
  1965.                 }
  1967.                 if (! isset($class->associationMappings[$name])) {
  1968.                     if (! $class->isIdentifier($name)) {
  1969.                         $prop->setValue($managedCopy, $prop->getValue($document));
  1970.                     }
  1971.                 } else {
  1972.                     $assoc2 = $class->associationMappings[$name];
  1974.                     if ($assoc2['type'] === ClassMetadata::ONE) {
  1975.                         $other = $prop->getValue($document);
  1977.                         if ($other === null) {
  1978.                             $prop->setValue($managedCopy, null);
  1979.                         } elseif ($other instanceof GhostObjectInterface && ! $other->isProxyInitialized()) {
  1980.                             // Do not merge fields marked lazy that have not been fetched
  1981.                             continue;
  1982.                         } elseif (! $assoc2['isCascadeMerge']) {
  1983.                             if ($this->getDocumentState($other) === self::STATE_DETACHED) {
  1984.                                 $targetDocument = $assoc2['targetDocument'] ?? get_class($other);
  1985.                                 $targetClass    = $this->dm->getClassMetadata($targetDocument);
  1986.                                 assert($targetClass instanceof ClassMetadata);
  1987.                                 $relatedId = $targetClass->getIdentifierObject($other);
  1989.                                 $current = $prop->getValue($managedCopy);
  1990.                                 if ($current !== null) {
  1991.                                     $this->removeFromIdentityMap($current);
  1992.                                 }
  1994.                                 if ($targetClass->subClasses) {
  1995.                                     $other = $this->dm->find($targetClass->name, $relatedId);
  1996.                                 } else {
  1997.                                     $other = $this
  1998.                                         ->dm
  1999.                                         ->getProxyFactory()
  2000.                                         ->getProxy($targetClass, $relatedId);
  2001.                                     $this->registerManaged($other, $relatedId, []);
  2002.                                 }
  2003.                             }
  2005.                             $prop->setValue($managedCopy, $other);
  2006.                         }
  2007.                     } else {
  2008.                         $mergeCol = $prop->getValue($document);
  2010.                         if ($mergeCol instanceof PersistentCollectionInterface && ! $mergeCol->isInitialized() && ! $assoc2['isCascadeMerge']) {
  2011.                             /* Do not merge fields marked lazy that have not
  2012.                              * been fetched. Keep the lazy persistent collection
  2013.                              * of the managed copy.
  2014.                              */
  2015.                             continue;
  2016.                         }
  2018.                         $managedCol = $prop->getValue($managedCopy);
  2020.                         if (! $managedCol) {
  2021.                             $managedCol = $this->dm->getConfiguration()->getPersistentCollectionFactory()->create($this->dm, $assoc2, null);
  2022.                             $managedCol->setOwner($managedCopy, $assoc2);
  2023.                             $prop->setValue($managedCopy, $managedCol);
  2024.                             $this->originalDocumentData[$oid][$name] = $managedCol;
  2025.                         }
  2027.                         /* Note: do not process association's target documents.
  2028.                          * They will be handled during the cascade. Initialize
  2029.                          * and, if necessary, clear $managedCol for now.
  2030.                          */
  2031.                         if ($assoc2['isCascadeMerge']) {
  2032.                             $managedCol->initialize();
  2034.                             // If $managedCol differs from the merged collection, clear and set dirty
  2035.                             if (! $managedCol->isEmpty() && $managedCol !== $mergeCol) {
  2036.                                 $managedCol->unwrap()->clear();
  2037.                                 $managedCol->setDirty(true);
  2039.                                 if ($assoc2['isOwningSide'] && $class->isChangeTrackingNotify()) {
  2040.                                     $this->scheduleForSynchronization($managedCopy);
  2041.                                 }
  2042.                             }
  2043.                         }
  2044.                     }
  2045.                 }
  2047.                 if (! $class->isChangeTrackingNotify()) {
  2048.                     continue;
  2049.                 }
  2051.                 // Just treat all properties as changed, there is no other choice.
  2052.                 $this->propertyChanged($managedCopy, $name, null, $prop->getValue($managedCopy));
  2053.             }
  2055.             if ($class->isChangeTrackingDeferredExplicit()) {
  2056.                 $this->scheduleForSynchronization($document);
  2057.             }
  2058.         }
  2060.         if ($prevManagedCopy !== null) {
  2061.             $assocField = $assoc['fieldName'];
  2062.             $prevClass  = $this->dm->getClassMetadata(get_class($prevManagedCopy));
  2064.             if ($assoc['type'] === ClassMetadata::ONE) {
  2065.                 $prevClass->reflFields[$assocField]->setValue($prevManagedCopy, $managedCopy);
  2066.             } else {
  2067.                 $prevClass->reflFields[$assocField]->getValue($prevManagedCopy)->add($managedCopy);
  2069.                 if ($assoc['type'] === ClassMetadata::MANY && isset($assoc['mappedBy'])) {
  2070.                     $class->reflFields[$assoc['mappedBy']]->setValue($managedCopy, $prevManagedCopy);
  2071.                 }
  2072.             }
  2073.         }
  2075.         // Mark the managed copy visited as well
  2076.         $visited[spl_object_hash($managedCopy)] = $managedCopy;
  2078.         $this->cascadeMerge($document, $managedCopy, $visited);
  2080.         return $managedCopy;
  2081.     }
  2083.     /**
  2084.      * Detaches a document from the persistence management. It's persistence will
  2085.      * no longer be managed by Doctrine.
  2086.      *
  2087.      * @internal
  2088.      */
  2089.     public function detach(object $document): void
  2090.     {
  2091.         $visited = [];
  2092.         $this->doDetach($document, $visited);
  2093.     }
  2095.     /**
  2096.      * Executes a detach operation on the given document.
  2097.      *
  2098.      * @param array<string, object> $visited
  2099.      */
  2100.     private function doDetach(object $document, array &$visited): void
  2101.     {
  2102.         $oid = spl_object_hash($document);
  2103.         if (isset($visited[$oid])) {
  2104.             return; // Prevent infinite recursion
  2105.         }
  2107.         $visited[$oid] = $document; // mark visited
  2109.         switch ($this->getDocumentState($document, self::STATE_DETACHED)) {
  2110.             case self::STATE_MANAGED:
  2111.                 $this->removeFromIdentityMap($document);
  2112.                 unset(
  2113.                     $this->documentInsertions[$oid],
  2114.                     $this->documentUpdates[$oid],
  2115.                     $this->documentDeletions[$oid],
  2116.                     $this->documentIdentifiers[$oid],
  2117.                     $this->documentStates[$oid],
  2118.                     $this->originalDocumentData[$oid],
  2119.                     $this->parentAssociations[$oid],
  2120.                     $this->documentUpserts[$oid],
  2121.                     $this->hasScheduledCollections[$oid],
  2122.                     $this->embeddedDocumentsRegistry[$oid]
  2123.                 );
  2124.                 break;
  2125.             case self::STATE_NEW:
  2126.             case self::STATE_DETACHED:
  2127.                 return;
  2128.         }
  2130.         $this->cascadeDetach($document, $visited);
  2131.     }
  2133.     /**
  2134.      * Refreshes the state of the given document from the database, overwriting
  2135.      * any local, unpersisted changes.
  2136.      *
  2137.      * @internal
  2138.      *
  2139.      * @throws InvalidArgumentException If the document is not MANAGED.
  2140.      */
  2141.     public function refresh(object $document): void
  2142.     {
  2143.         $visited = [];
  2144.         $this->doRefresh($document, $visited);
  2145.     }
  2147.     /**
  2148.      * Executes a refresh operation on a document.
  2149.      *
  2150.      * @param array<string, object> $visited
  2151.      *
  2152.      * @throws InvalidArgumentException If the document is not MANAGED.
  2153.      */
  2154.     private function doRefresh(object $document, array &$visited): void
  2155.     {
  2156.         $oid = spl_object_hash($document);
  2157.         if (isset($visited[$oid])) {
  2158.             return; // Prevent infinite recursion
  2159.         }
  2161.         $visited[$oid] = $document; // mark visited
  2163.         $class = $this->dm->getClassMetadata(get_class($document));
  2165.         if (! $class->isEmbeddedDocument) {
  2166.             if ($this->getDocumentState($document) !== self::STATE_MANAGED) {
  2167.                 throw new InvalidArgumentException('Document is not MANAGED.');
  2168.             }
  2170.             $this->getDocumentPersister($class->name)->refresh($document);
  2171.         }
  2173.         $this->cascadeRefresh($document, $visited);
  2174.     }
  2176.     /**
  2177.      * Cascades a refresh operation to associated documents.
  2178.      *
  2179.      * @param array<string, object> $visited
  2180.      */
  2181.     private function cascadeRefresh(object $document, array &$visited): void
  2182.     {
  2183.         $class = $this->dm->getClassMetadata(get_class($document));
  2185.         $associationMappings = array_filter(
  2186.             $class->associationMappings,
  2187.             static function ($assoc) {
  2188.                 return $assoc['isCascadeRefresh'];
  2189.             }
  2190.         );
  2192.         foreach ($associationMappings as $mapping) {
  2193.             $relatedDocuments = $class->reflFields[$mapping['fieldName']]->getValue($document);
  2194.             if ($relatedDocuments instanceof Collection || is_array($relatedDocuments)) {
  2195.                 if ($relatedDocuments instanceof PersistentCollectionInterface) {
  2196.                     // Unwrap so that foreach() does not initialize
  2197.                     $relatedDocuments = $relatedDocuments->unwrap();
  2198.                 }
  2200.                 foreach ($relatedDocuments as $relatedDocument) {
  2201.                     $this->doRefresh($relatedDocument, $visited);
  2202.                 }
  2203.             } elseif ($relatedDocuments !== null) {
  2204.                 $this->doRefresh($relatedDocuments, $visited);
  2205.             }
  2206.         }
  2207.     }
  2209.     /**
  2210.      * Cascades a detach operation to associated documents.
  2211.      *
  2212.      * @param array<string, object> $visited
  2213.      */
  2214.     private function cascadeDetach(object $document, array &$visited): void
  2215.     {
  2216.         $class = $this->dm->getClassMetadata(get_class($document));
  2217.         foreach ($class->fieldMappings as $mapping) {
  2218.             if (! $mapping['isCascadeDetach']) {
  2219.                 continue;
  2220.             }
  2222.             $relatedDocuments = $class->reflFields[$mapping['fieldName']]->getValue($document);
  2223.             if ($relatedDocuments instanceof Collection || is_array($relatedDocuments)) {
  2224.                 if ($relatedDocuments instanceof PersistentCollectionInterface) {
  2225.                     // Unwrap so that foreach() does not initialize
  2226.                     $relatedDocuments = $relatedDocuments->unwrap();
  2227.                 }
  2229.                 foreach ($relatedDocuments as $relatedDocument) {
  2230.                     $this->doDetach($relatedDocument, $visited);
  2231.                 }
  2232.             } elseif ($relatedDocuments !== null) {
  2233.                 $this->doDetach($relatedDocuments, $visited);
  2234.             }
  2235.         }
  2236.     }
  2238.     /**
  2239.      * Cascades a merge operation to associated documents.
  2240.      *
  2241.      * @param array<string, object> $visited
  2242.      */
  2243.     private function cascadeMerge(object $document, object $managedCopy, array &$visited): void
  2244.     {
  2245.         $class = $this->dm->getClassMetadata(get_class($document));
  2247.         $associationMappings = array_filter(
  2248.             $class->associationMappings,
  2249.             static function ($assoc) {
  2250.                 return $assoc['isCascadeMerge'];
  2251.             }
  2252.         );
  2254.         foreach ($associationMappings as $assoc) {
  2255.             $relatedDocuments = $class->reflFields[$assoc['fieldName']]->getValue($document);
  2257.             if ($relatedDocuments instanceof Collection || is_array($relatedDocuments)) {
  2258.                 if ($relatedDocuments === $class->reflFields[$assoc['fieldName']]->getValue($managedCopy)) {
  2259.                     // Collections are the same, so there is nothing to do
  2260.                     continue;
  2261.                 }
  2263.                 foreach ($relatedDocuments as $relatedDocument) {
  2264.                     $this->doMerge($relatedDocument, $visited, $managedCopy, $assoc);
  2265.                 }
  2266.             } elseif ($relatedDocuments !== null) {
  2267.                 $this->doMerge($relatedDocuments, $visited, $managedCopy, $assoc);
  2268.             }
  2269.         }
  2270.     }
  2272.     /**
  2273.      * Cascades the save operation to associated documents.
  2274.      *
  2275.      * @param array<string, object> $visited
  2276.      */
  2277.     private function cascadePersist(object $document, array &$visited): void
  2278.     {
  2279.         $class = $this->dm->getClassMetadata(get_class($document));
  2281.         $associationMappings = array_filter(
  2282.             $class->associationMappings,
  2283.             static function ($assoc) {
  2284.                 return $assoc['isCascadePersist'];
  2285.             }
  2286.         );
  2288.         foreach ($associationMappings as $fieldName => $mapping) {
  2289.             $relatedDocuments = $class->reflFields[$fieldName]->getValue($document);
  2291.             if ($relatedDocuments instanceof Collection || is_array($relatedDocuments)) {
  2292.                 if ($relatedDocuments instanceof PersistentCollectionInterface) {
  2293.                     if ($relatedDocuments->getOwner() !== $document) {
  2294.                         $relatedDocuments = $this->fixPersistentCollectionOwnership($relatedDocuments, $document, $class, $mapping['fieldName']);
  2295.                     }
  2297.                     // Unwrap so that foreach() does not initialize
  2298.                     $relatedDocuments = $relatedDocuments->unwrap();
  2299.                 }
  2301.                 $count = 0;
  2302.                 foreach ($relatedDocuments as $relatedKey => $relatedDocument) {
  2303.                     if (! empty($mapping['embedded'])) {
  2304.                         [, $knownParent] = $this->getParentAssociation($relatedDocument);
  2305.                         if ($knownParent && $knownParent !== $document) {
  2306.                             $relatedDocument               = clone $relatedDocument;
  2307.                             $relatedDocuments[$relatedKey] = $relatedDocument;
  2308.                         }
  2310.                         $pathKey = CollectionHelper::isList($mapping['strategy']) ? $count++ : $relatedKey;
  2311.                         $this->setParentAssociation($relatedDocument, $mapping, $document, $mapping['fieldName'] . '.' . $pathKey);
  2312.                     }
  2314.                     $this->doPersist($relatedDocument, $visited);
  2315.                 }
  2316.             } elseif ($relatedDocuments !== null) {
  2317.                 if (! empty($mapping['embedded'])) {
  2318.                     [, $knownParent] = $this->getParentAssociation($relatedDocuments);
  2319.                     if ($knownParent && $knownParent !== $document) {
  2320.                         $relatedDocuments = clone $relatedDocuments;
  2321.                         $class->setFieldValue($document, $mapping['fieldName'], $relatedDocuments);
  2322.                     }
  2324.                     $this->setParentAssociation($relatedDocuments, $mapping, $document, $mapping['fieldName']);
  2325.                 }
  2327.                 $this->doPersist($relatedDocuments, $visited);
  2328.             }
  2329.         }
  2330.     }
  2332.     /**
  2333.      * Cascades the delete operation to associated documents.
  2334.      *
  2335.      * @param array<string, object> $visited
  2336.      */
  2337.     private function cascadeRemove(object $document, array &$visited): void
  2338.     {
  2339.         $class = $this->dm->getClassMetadata(get_class($document));
  2340.         foreach ($class->fieldMappings as $mapping) {
  2341.             if (! $mapping['isCascadeRemove'] && ( ! isset($mapping['orphanRemoval']) || ! $mapping['orphanRemoval'])) {
  2342.                 continue;
  2343.             }
  2345.             if ($document instanceof GhostObjectInterface && ! $document->isProxyInitialized()) {
  2346.                 $document->initializeProxy();
  2347.             }
  2349.             $relatedDocuments = $class->reflFields[$mapping['fieldName']]->getValue($document);
  2350.             if ($relatedDocuments instanceof Collection || is_array($relatedDocuments)) {
  2351.                 // If its a PersistentCollection initialization is intended! No unwrap!
  2352.                 foreach ($relatedDocuments as $relatedDocument) {
  2353.                     $this->doRemove($relatedDocument, $visited);
  2354.                 }
  2355.             } elseif ($relatedDocuments !== null) {
  2356.                 $this->doRemove($relatedDocuments, $visited);
  2357.             }
  2358.         }
  2359.     }
  2361.     /**
  2362.      * Acquire a lock on the given document.
  2363.      *
  2364.      * @internal
  2365.      *
  2366.      * @throws LockException
  2367.      * @throws InvalidArgumentException
  2368.      */
  2369.     public function lock(object $document, int $lockMode, ?int $lockVersion = null): void
  2370.     {
  2371.         if ($this->getDocumentState($document) !== self::STATE_MANAGED) {
  2372.             throw new InvalidArgumentException('Document is not MANAGED.');
  2373.         }
  2375.         $documentName = get_class($document);
  2376.         $class        = $this->dm->getClassMetadata($documentName);
  2378.         if ($lockMode === LockMode::OPTIMISTIC) {
  2379.             if (! $class->isVersioned) {
  2380.                 throw LockException::notVersioned($documentName);
  2381.             }
  2383.             if ($lockVersion !== null) {
  2384.                 $documentVersion = $class->reflFields[$class->versionField]->getValue($document);
  2385.                 if ($documentVersion !== $lockVersion) {
  2386.                     throw LockException::lockFailedVersionMissmatch($document, $lockVersion, $documentVersion);
  2387.                 }
  2388.             }
  2389.         } elseif (in_array($lockMode, [LockMode::PESSIMISTIC_READ, LockMode::PESSIMISTIC_WRITE])) {
  2390.             $this->getDocumentPersister($class->name)->lock($document, $lockMode);
  2391.         }
  2392.     }
  2394.     /**
  2395.      * Releases a lock on the given document.
  2396.      *
  2397.      * @internal
  2398.      *
  2399.      * @throws InvalidArgumentException
  2400.      */
  2401.     public function unlock(object $document): void
  2402.     {
  2403.         if ($this->getDocumentState($document) !== self::STATE_MANAGED) {
  2404.             throw new InvalidArgumentException('Document is not MANAGED.');
  2405.         }
  2407.         $documentName = get_class($document);
  2408.         $this->getDocumentPersister($documentName)->unlock($document);
  2409.     }
  2411.     /**
  2412.      * Clears the UnitOfWork.
  2413.      *
  2414.      * @internal
  2415.      */
  2416.     public function clear(?string $documentName = null): void
  2417.     {
  2418.         if ($documentName === null) {
  2419.             $this->identityMap                 =
  2420.             $this->documentIdentifiers         =
  2421.             $this->originalDocumentData        =
  2422.             $this->documentChangeSets          =
  2423.             $this->documentStates              =
  2424.             $this->scheduledForSynchronization =
  2425.             $this->documentInsertions          =
  2426.             $this->documentUpserts             =
  2427.             $this->documentUpdates             =
  2428.             $this->documentDeletions           =
  2429.             $this->collectionUpdates           =
  2430.             $this->collectionDeletions         =
  2431.             $this->parentAssociations          =
  2432.             $this->embeddedDocumentsRegistry   =
  2433.             $this->orphanRemovals              =
  2434.             $this->hasScheduledCollections     = [];
  2435.         } else {
  2436.             $visited = [];
  2437.             foreach ($this->identityMap as $className => $documents) {
  2438.                 if ($className !== $documentName) {
  2439.                     continue;
  2440.                 }
  2442.                 foreach ($documents as $document) {
  2443.                     $this->doDetach($document, $visited);
  2444.                 }
  2445.             }
  2446.         }
  2448.         if (! $this->evm->hasListeners(Events::onClear)) {
  2449.             return;
  2450.         }
  2452.         $this->evm->dispatchEvent(Events::onClear, new Event\OnClearEventArgs($this->dm, $documentName));
  2453.     }
  2455.     /**
  2456.      * Schedules an embedded document for removal. The remove() operation will be
  2457.      * invoked on that document at the beginning of the next commit of this
  2458.      * UnitOfWork.
  2459.      *
  2460.      * @internal
  2461.      */
  2462.     public function scheduleOrphanRemoval(object $document): void
  2463.     {
  2464.         $this->orphanRemovals[spl_object_hash($document)] = $document;
  2465.     }
  2467.     /**
  2468.      * Unschedules an embedded or referenced object for removal.
  2469.      *
  2470.      * @internal
  2471.      */
  2472.     public function unscheduleOrphanRemoval(object $document): void
  2473.     {
  2474.         $oid = spl_object_hash($document);
  2475.         unset($this->orphanRemovals[$oid]);
  2476.     }
  2478.     /**
  2479.      * Fixes PersistentCollection state if it wasn't used exactly as we had in mind:
  2480.      *  1) sets owner if it was cloned
  2481.      *  2) clones collection, sets owner, updates document's property and, if necessary, updates originalData
  2482.      *  3) NOP if state is OK
  2483.      * Returned collection should be used from now on (only important with 2nd point)
  2484.      *
  2485.      * @psalm-param PersistentCollectionInterface<array-key, object> $coll
  2486.      * @psalm-param T $document
  2487.      * @psalm-param ClassMetadata<T> $class
  2488.      *
  2489.      * @psalm-return PersistentCollectionInterface<array-key, object>
  2490.      *
  2491.      * @template T of object
  2492.      */
  2493.     private function fixPersistentCollectionOwnership(PersistentCollectionInterface $coll, object $document, ClassMetadata $class, string $propName): PersistentCollectionInterface
  2494.     {
  2495.         $owner = $coll->getOwner();
  2496.         if ($owner === null) { // cloned
  2497.             $coll->setOwner($document, $class->fieldMappings[$propName]);
  2498.         } elseif ($owner !== $document) { // no clone, we have to fix
  2499.             if (! $coll->isInitialized()) {
  2500.                 $coll->initialize(); // we have to do this otherwise the cols share state
  2501.             }
  2503.             $newValue = clone $coll;
  2504.             $newValue->setOwner($document, $class->fieldMappings[$propName]);
  2505.             $class->reflFields[$propName]->setValue($document, $newValue);
  2506.             if ($this->isScheduledForUpdate($document)) {
  2507.                 // @todo following line should be superfluous once collections are stored in change sets
  2508.                 $this->setOriginalDocumentProperty(spl_object_hash($document), $propName, $newValue);
  2509.             }
  2511.             return $newValue;
  2512.         }
  2514.         return $coll;
  2515.     }
  2517.     /**
  2518.      * Schedules a complete collection for removal when this UnitOfWork commits.
  2519.      *
  2520.      * @internal
  2521.      *
  2522.      * @psalm-param PersistentCollectionInterface<array-key, object> $coll
  2523.      */
  2524.     public function scheduleCollectionDeletion(PersistentCollectionInterface $coll): void
  2525.     {
  2526.         $oid = spl_object_hash($coll);
  2527.         unset($this->collectionUpdates[$oid]);
  2528.         if (isset($this->collectionDeletions[$oid])) {
  2529.             return;
  2530.         }
  2532.         $this->collectionDeletions[$oid] = $coll;
  2533.         $this->scheduleCollectionOwner($coll);
  2534.     }
  2536.     /**
  2537.      * Checks whether a PersistentCollection is scheduled for deletion.
  2538.      *
  2539.      * @internal
  2540.      *
  2541.      * @psalm-param PersistentCollectionInterface<array-key, object> $coll
  2542.      */
  2543.     public function isCollectionScheduledForDeletion(PersistentCollectionInterface $coll): bool
  2544.     {
  2545.         return isset($this->collectionDeletions[spl_object_hash($coll)]);
  2546.     }
  2548.     /**
  2549.      * Unschedules a collection from being deleted when this UnitOfWork commits.
  2550.      *
  2551.      * @internal
  2552.      *
  2553.      * @psalm-param PersistentCollectionInterface<array-key, object> $coll
  2554.      */
  2555.     public function unscheduleCollectionDeletion(PersistentCollectionInterface $coll): void
  2556.     {
  2557.         if ($coll->getOwner() === null) {
  2558.             return;
  2559.         }
  2561.         $oid = spl_object_hash($coll);
  2562.         if (! isset($this->collectionDeletions[$oid])) {
  2563.             return;
  2564.         }
  2566.         $topmostOwner = $this->getOwningDocument($coll->getOwner());
  2567.         unset($this->collectionDeletions[$oid]);
  2568.         unset($this->hasScheduledCollections[spl_object_hash($topmostOwner)][$oid]);
  2569.     }
  2571.     /**
  2572.      * Schedules a collection for update when this UnitOfWork commits.
  2573.      *
  2574.      * @internal
  2575.      *
  2576.      * @psalm-param PersistentCollectionInterface<array-key, object> $coll
  2577.      */
  2578.     public function scheduleCollectionUpdate(PersistentCollectionInterface $coll): void
  2579.     {
  2580.         $mapping = $coll->getMapping();
  2581.         if (CollectionHelper::usesSet($mapping['strategy'])) {
  2582.             /* There is no need to $unset collection if it will be $set later
  2583.              * This is NOP if collection is not scheduled for deletion
  2584.              */
  2585.             $this->unscheduleCollectionDeletion($coll);
  2586.         }
  2588.         $oid = spl_object_hash($coll);
  2589.         if (isset($this->collectionUpdates[$oid])) {
  2590.             return;
  2591.         }
  2593.         $this->collectionUpdates[$oid] = $coll;
  2594.         $this->scheduleCollectionOwner($coll);
  2595.     }
  2597.     /**
  2598.      * Unschedules a collection from being updated when this UnitOfWork commits.
  2599.      *
  2600.      * @internal
  2601.      *
  2602.      * @psalm-param PersistentCollectionInterface<array-key, object> $coll
  2603.      */
  2604.     public function unscheduleCollectionUpdate(PersistentCollectionInterface $coll): void
  2605.     {
  2606.         if ($coll->getOwner() === null) {
  2607.             return;
  2608.         }
  2610.         $oid = spl_object_hash($coll);
  2611.         if (! isset($this->collectionUpdates[$oid])) {
  2612.             return;
  2613.         }
  2615.         $topmostOwner = $this->getOwningDocument($coll->getOwner());
  2616.         unset($this->collectionUpdates[$oid]);
  2617.         unset($this->hasScheduledCollections[spl_object_hash($topmostOwner)][$oid]);
  2618.     }
  2620.     /**
  2621.      * Checks whether a PersistentCollection is scheduled for update.
  2622.      *
  2623.      * @internal
  2624.      *
  2625.      * @psalm-param PersistentCollectionInterface<array-key, object> $coll
  2626.      */
  2627.     public function isCollectionScheduledForUpdate(PersistentCollectionInterface $coll): bool
  2628.     {
  2629.         return isset($this->collectionUpdates[spl_object_hash($coll)]);
  2630.     }
  2632.     /**
  2633.      * Gets PersistentCollections that have been visited during computing change
  2634.      * set of $document
  2635.      *
  2636.      * @internal
  2637.      *
  2638.      * @return PersistentCollectionInterface[]
  2639.      * @psalm-return array<PersistentCollectionInterface<array-key, object>>
  2640.      */
  2641.     public function getVisitedCollections(object $document): array
  2642.     {
  2643.         $oid = spl_object_hash($document);
  2645.         return $this->visitedCollections[$oid] ?? [];
  2646.     }
  2648.     /**
  2649.      * Gets PersistentCollections that are scheduled to update and related to $document
  2650.      *
  2651.      * @internal
  2652.      *
  2653.      * @return PersistentCollectionInterface[]
  2654.      * @psalm-return array<string, PersistentCollectionInterface<array-key, object>>
  2655.      */
  2656.     public function getScheduledCollections(object $document): array
  2657.     {
  2658.         $oid = spl_object_hash($document);
  2660.         return $this->hasScheduledCollections[$oid] ?? [];
  2661.     }
  2663.     /**
  2664.      * Checks whether the document is related to a PersistentCollection
  2665.      * scheduled for update or deletion.
  2666.      *
  2667.      * @internal
  2668.      */
  2669.     public function hasScheduledCollections(object $document): bool
  2670.     {
  2671.         return isset($this->hasScheduledCollections[spl_object_hash($document)]);
  2672.     }
  2674.     /**
  2675.      * Marks the PersistentCollection's top-level owner as having a relation to
  2676.      * a collection scheduled for update or deletion.
  2677.      *
  2678.      * If the owner is not scheduled for any lifecycle action, it will be
  2679.      * scheduled for update to ensure that versioning takes place if necessary.
  2680.      *
  2681.      * If the collection is nested within atomic collection, it is immediately
  2682.      * unscheduled and atomic one is scheduled for update instead. This makes
  2683.      * calculating update data way easier.
  2684.      *
  2685.      * @psalm-param PersistentCollectionInterface<array-key, object> $coll
  2686.      */
  2687.     private function scheduleCollectionOwner(PersistentCollectionInterface $coll): void
  2688.     {
  2689.         if ($coll->getOwner() === null) {
  2690.             return;
  2691.         }
  2693.         $document                                                                          = $this->getOwningDocument($coll->getOwner());
  2694.         $this->hasScheduledCollections[spl_object_hash($document)][spl_object_hash($coll)] = $coll;
  2696.         if ($document !== $coll->getOwner()) {
  2697.             $parent  = $coll->getOwner();
  2698.             $mapping = [];
  2699.             while (($parentAssoc = $this->getParentAssociation($parent)) !== null) {
  2700.                 [$mapping, $parent] = $parentAssoc;
  2701.             }
  2703.             if (CollectionHelper::isAtomic($mapping['strategy'])) {
  2704.                 $class            = $this->dm->getClassMetadata(get_class($document));
  2705.                 $atomicCollection = $class->getFieldValue($document, $mapping['fieldName']);
  2706.                 $this->scheduleCollectionUpdate($atomicCollection);
  2707.                 $this->unscheduleCollectionDeletion($coll);
  2708.                 $this->unscheduleCollectionUpdate($coll);
  2709.             }
  2710.         }
  2712.         if ($this->isDocumentScheduled($document)) {
  2713.             return;
  2714.         }
  2716.         $this->scheduleForUpdate($document);
  2717.     }
  2719.     /**
  2720.      * Get the top-most owning document of a given document
  2721.      *
  2722.      * If a top-level document is provided, that same document will be returned.
  2723.      * For an embedded document, we will walk through parent associations until
  2724.      * we find a top-level document.
  2725.      *
  2726.      * @throws UnexpectedValueException When a top-level document could not be found.
  2727.      */
  2728.     public function getOwningDocument(object $document): object
  2729.     {
  2730.         $class = $this->dm->getClassMetadata(get_class($document));
  2731.         while ($class->isEmbeddedDocument) {
  2732.             $parentAssociation = $this->getParentAssociation($document);
  2734.             if (! $parentAssociation) {
  2735.                 throw new UnexpectedValueException('Could not determine parent association for ' . get_class($document));
  2736.             }
  2738.             [, $document] = $parentAssociation;
  2739.             $class        = $this->dm->getClassMetadata(get_class($document));
  2740.         }
  2742.         return $document;
  2743.     }
  2745.     /**
  2746.      * Gets the class name for an association (embed or reference) with respect
  2747.      * to any discriminator value.
  2748.      *
  2749.      * @internal
  2750.      *
  2751.      * @param FieldMapping              $mapping
  2752.      * @param array<string, mixed>|null $data
  2753.      *
  2754.      * @psalm-return class-string
  2755.      */
  2756.     public function getClassNameForAssociation(array $mapping, $data): string
  2757.     {
  2758.         $discriminatorField = $mapping['discriminatorField'] ?? null;
  2760.         $discriminatorValue = null;
  2761.         if (isset($discriminatorField, $data[$discriminatorField])) {
  2762.             $discriminatorValue = $data[$discriminatorField];
  2763.         } elseif (isset($mapping['defaultDiscriminatorValue'])) {
  2764.             $discriminatorValue = $mapping['defaultDiscriminatorValue'];
  2765.         }
  2767.         if ($discriminatorValue !== null) {
  2768.             return $mapping['discriminatorMap'][$discriminatorValue]
  2769.                 ?? (string) $discriminatorValue;
  2770.         }
  2772.         $class = $this->dm->getClassMetadata($mapping['targetDocument']);
  2774.         if (isset($class->discriminatorField, $data[$class->discriminatorField])) {
  2775.             $discriminatorValue = $data[$class->discriminatorField];
  2776.         } elseif ($class->defaultDiscriminatorValue !== null) {
  2777.             $discriminatorValue = $class->defaultDiscriminatorValue;
  2778.         }
  2780.         if ($discriminatorValue !== null) {
  2781.             return $class->discriminatorMap[$discriminatorValue] ?? $discriminatorValue;
  2782.         }
  2784.         return $mapping['targetDocument'];
  2785.     }
  2787.     /**
  2788.      * Creates a document. Used for reconstitution of documents during hydration.
  2789.      *
  2790.      * @psalm-param class-string<T> $className
  2791.      * @psalm-param array<string, mixed> $data
  2792.      * @psalm-param T|null $document
  2793.      * @psalm-param Hints $hints
  2794.      *
  2795.      * @psalm-return T
  2796.      *
  2797.      * @template T of object
  2798.      */
  2799.     public function getOrCreateDocument(string $className, array $data, array &$hints = [], ?object $document = null): object
  2800.     {
  2801.         $class = $this->dm->getClassMetadata($className);
  2803.         // @TODO figure out how to remove this
  2804.         $discriminatorValue = null;
  2805.         if (isset($class->discriminatorField, $data[$class->discriminatorField])) {
  2806.             $discriminatorValue = $data[$class->discriminatorField];
  2807.         } elseif (isset($class->defaultDiscriminatorValue)) {
  2808.             $discriminatorValue = $class->defaultDiscriminatorValue;
  2809.         }
  2811.         if ($discriminatorValue !== null) {
  2812.             /** @psalm-var class-string<T> $className */
  2813.             $className =  $class->discriminatorMap[$discriminatorValue] ?? $discriminatorValue;
  2815.             $class = $this->dm->getClassMetadata($className);
  2817.             unset($data[$class->discriminatorField]);
  2818.         }
  2820.         if (! empty($hints[Query::HINT_READ_ONLY])) {
  2821.             /** @psalm-var T $document */
  2822.             $document = $class->newInstance();
  2823.             $this->hydratorFactory->hydrate($document, $data, $hints);
  2825.             return $document;
  2826.         }
  2828.         $isManagedObject = false;
  2829.         $serializedId    = null;
  2830.         $id              = null;
  2831.         if (! $class->isQueryResultDocument) {
  2832.             $id              = $class->getDatabaseIdentifierValue($data['_id']);
  2833.             $serializedId    = serialize($id);
  2834.             $isManagedObject = isset($this->identityMap[$class->name][$serializedId]);
  2835.         }
  2837.         $oid = null;
  2838.         if ($isManagedObject) {
  2839.             /** @psalm-var T $document */
  2840.             $document = $this->identityMap[$class->name][$serializedId];
  2841.             $oid      = spl_object_hash($document);
  2842.             if ($document instanceof GhostObjectInterface && ! $document->isProxyInitialized()) {
  2843.                 $document->setProxyInitializer(null);
  2844.                 $overrideLocalValues = true;
  2845.                 if ($document instanceof NotifyPropertyChanged) {
  2846.                     $document->addPropertyChangedListener($this);
  2847.                 }
  2848.             } else {
  2849.                 $overrideLocalValues = ! empty($hints[Query::HINT_REFRESH]);
  2850.             }
  2852.             if ($overrideLocalValues) {
  2853.                 $data                             = $this->hydratorFactory->hydrate($document, $data, $hints);
  2854.                 $this->originalDocumentData[$oid] = $data;
  2855.             }
  2856.         } else {
  2857.             if ($document === null) {
  2858.                 /** @psalm-var T $document */
  2859.                 $document = $class->newInstance();
  2860.             }
  2862.             if (! $class->isQueryResultDocument) {
  2863.                 $this->registerManaged($document, $id, $data);
  2864.                 $oid                                            = spl_object_hash($document);
  2865.                 $this->documentStates[$oid]                     = self::STATE_MANAGED;
  2866.                 $this->identityMap[$class->name][$serializedId] = $document;
  2867.             }
  2869.             $data = $this->hydratorFactory->hydrate($document, $data, $hints);
  2871.             if (! $class->isQueryResultDocument && ! $class->isView()) {
  2872.                 $this->originalDocumentData[$oid] = $data;
  2873.             }
  2874.         }
  2876.         return $document;
  2877.     }
  2879.     /**
  2880.      * Initializes (loads) an uninitialized persistent collection of a document.
  2881.      *
  2882.      * @internal
  2883.      *
  2884.      * @psalm-param PersistentCollectionInterface<array-key, object> $collection
  2885.      */
  2886.     public function loadCollection(PersistentCollectionInterface $collection): void
  2887.     {
  2888.         if ($collection->getOwner() === null) {
  2889.             throw PersistentCollectionException::ownerRequiredToLoadCollection();
  2890.         }
  2892.         $this->getDocumentPersister(get_class($collection->getOwner()))->loadCollection($collection);
  2893.         $this->lifecycleEventManager->postCollectionLoad($collection);
  2894.     }
  2896.     /**
  2897.      * Gets the identity map of the UnitOfWork.
  2898.      *
  2899.      * @internal
  2900.      *
  2901.      * @psalm-return array<class-string, array<string, object>>
  2902.      */
  2903.     public function getIdentityMap(): array
  2904.     {
  2905.         return $this->identityMap;
  2906.     }
  2908.     /**
  2909.      * Gets the original data of a document. The original data is the data that was
  2910.      * present at the time the document was reconstituted from the database.
  2911.      *
  2912.      * @return array<string, mixed>
  2913.      */
  2914.     public function getOriginalDocumentData(object $document): array
  2915.     {
  2916.         $oid = spl_object_hash($document);
  2918.         return $this->originalDocumentData[$oid] ?? [];
  2919.     }
  2921.     /**
  2922.      * @internal
  2923.      *
  2924.      * @param array<string, mixed> $data
  2925.      */
  2926.     public function setOriginalDocumentData(object $document, array $data): void
  2927.     {
  2928.         $oid                              = spl_object_hash($document);
  2929.         $this->originalDocumentData[$oid] = $data;
  2930.         unset($this->documentChangeSets[$oid]);
  2931.     }
  2933.     /**
  2934.      * Sets a property value of the original data array of a document.
  2935.      *
  2936.      * @internal
  2937.      *
  2938.      * @param mixed $value
  2939.      */
  2940.     public function setOriginalDocumentProperty(string $oid, string $property, $value): void
  2941.     {
  2942.         $this->originalDocumentData[$oid][$property] = $value;
  2943.     }
  2945.     /**
  2946.      * Gets the identifier of a document.
  2947.      *
  2948.      * @return mixed The identifier value
  2949.      */
  2950.     public function getDocumentIdentifier(object $document)
  2951.     {
  2952.         return $this->documentIdentifiers[spl_object_hash($document)] ?? null;
  2953.     }
  2955.     /**
  2956.      * Checks whether the UnitOfWork has any pending insertions.
  2957.      *
  2958.      * @internal
  2959.      *
  2960.      * @return bool TRUE if this UnitOfWork has pending insertions, FALSE otherwise.
  2961.      */
  2962.     public function hasPendingInsertions(): bool
  2963.     {
  2964.         return ! empty($this->documentInsertions);
  2965.     }
  2967.     /**
  2968.      * Calculates the size of the UnitOfWork. The size of the UnitOfWork is the
  2969.      * number of documents in the identity map.
  2970.      *
  2971.      * @internal
  2972.      */
  2973.     public function size(): int
  2974.     {
  2975.         $count = 0;
  2976.         foreach ($this->identityMap as $documentSet) {
  2977.             $count += count($documentSet);
  2978.         }
  2980.         return $count;
  2981.     }
  2983.     /**
  2984.      * Registers a document as managed.
  2985.      *
  2986.      * TODO: This method assumes that $id is a valid PHP identifier for the
  2987.      * document class. If the class expects its database identifier to be an
  2988.      * ObjectId, and an incompatible $id is registered (e.g. an integer), the
  2989.      * document identifiers map will become inconsistent with the identity map.
  2990.      * In the future, we may want to round-trip $id through a PHP and database
  2991.      * conversion and throw an exception if it's inconsistent.
  2992.      *
  2993.      * @internal
  2994.      *
  2995.      * @param mixed                $id   The identifier values.
  2996.      * @param array<string, mixed> $data
  2997.      */
  2998.     public function registerManaged(object $document, $id, array $data): void
  2999.     {
  3000.         $oid   = spl_object_hash($document);
  3001.         $class = $this->dm->getClassMetadata(get_class($document));
  3003.         if (! $class->identifier || $id === null) {
  3004.             $this->documentIdentifiers[$oid] = $oid;
  3005.         } else {
  3006.             $this->documentIdentifiers[$oid] = $class->getPHPIdentifierValue($id);
  3007.         }
  3009.         $this->documentStates[$oid]       = self::STATE_MANAGED;
  3010.         $this->originalDocumentData[$oid] = $data;
  3011.         $this->addToIdentityMap($document);
  3012.     }
  3014.     /**
  3015.      * Clears the property changeset of the document with the given OID.
  3016.      *
  3017.      * @internal
  3018.      */
  3019.     public function clearDocumentChangeSet(string $oid): void
  3020.     {
  3021.         $this->documentChangeSets[$oid] = [];
  3022.     }
  3024.     /* PropertyChangedListener implementation */
  3026.     /**
  3027.      * Notifies this UnitOfWork of a property change in a document.
  3028.      *
  3029.      * @param object $sender       The document that owns the property.
  3030.      * @param string $propertyName The name of the property that changed.
  3031.      * @param mixed  $oldValue     The old value of the property.
  3032.      * @param mixed  $newValue     The new value of the property.
  3033.      */
  3034.     public function propertyChanged($sender, $propertyName, $oldValue, $newValue)
  3035.     {
  3036.         $oid   = spl_object_hash($sender);
  3037.         $class = $this->dm->getClassMetadata(get_class($sender));
  3039.         if (! isset($class->fieldMappings[$propertyName])) {
  3040.             return; // ignore non-persistent fields
  3041.         }
  3043.         // Update changeset and mark document for synchronization
  3044.         $this->documentChangeSets[$oid][$propertyName] = [$oldValue, $newValue];
  3045.         if (isset($this->scheduledForSynchronization[$class->name][$oid])) {
  3046.             return;
  3047.         }
  3049.         $this->scheduleForSynchronization($sender);
  3050.     }
  3052.     /**
  3053.      * Gets the currently scheduled document insertions in this UnitOfWork.
  3054.      *
  3055.      * @psalm-return array<string, object>
  3056.      */
  3057.     public function getScheduledDocumentInsertions(): array
  3058.     {
  3059.         return $this->documentInsertions;
  3060.     }
  3062.     /**
  3063.      * Gets the currently scheduled document upserts in this UnitOfWork.
  3064.      *
  3065.      * @psalm-return array<string, object>
  3066.      */
  3067.     public function getScheduledDocumentUpserts(): array
  3068.     {
  3069.         return $this->documentUpserts;
  3070.     }
  3072.     /**
  3073.      * Gets the currently scheduled document updates in this UnitOfWork.
  3074.      *
  3075.      * @psalm-return array<string, object>
  3076.      */
  3077.     public function getScheduledDocumentUpdates(): array
  3078.     {
  3079.         return $this->documentUpdates;
  3080.     }
  3082.     /**
  3083.      * Gets the currently scheduled document deletions in this UnitOfWork.
  3084.      *
  3085.      * @psalm-return array<string, object>
  3086.      */
  3087.     public function getScheduledDocumentDeletions(): array
  3088.     {
  3089.         return $this->documentDeletions;
  3090.     }
  3092.     /**
  3093.      * Get the currently scheduled complete collection deletions
  3094.      *
  3095.      * @internal
  3096.      *
  3097.      * @psalm-return array<string, PersistentCollectionInterface<array-key, object>>
  3098.      */
  3099.     public function getScheduledCollectionDeletions(): array
  3100.     {
  3101.         return $this->collectionDeletions;
  3102.     }
  3104.     /**
  3105.      * Gets the currently scheduled collection inserts, updates and deletes.
  3106.      *
  3107.      * @internal
  3108.      *
  3109.      * @psalm-return array<string, PersistentCollectionInterface<array-key, object>>
  3110.      */
  3111.     public function getScheduledCollectionUpdates(): array
  3112.     {
  3113.         return $this->collectionUpdates;
  3114.     }
  3116.     /**
  3117.      * Helper method to initialize a lazy loading proxy or persistent collection.
  3118.      *
  3119.      * @internal
  3120.      */
  3121.     public function initializeObject(object $obj): void
  3122.     {
  3123.         if ($obj instanceof GhostObjectInterface) {
  3124.             $obj->initializeProxy();
  3125.         } elseif ($obj instanceof PersistentCollectionInterface) {
  3126.             $obj->initialize();
  3127.         }
  3128.     }
  3130.     private function objToStr(object $obj): string
  3131.     {
  3132.         return method_exists($obj, '__toString') ? (string) $obj : get_class($obj) . '@' . spl_object_hash($obj);
  3133.     }
  3134. }