From 05e38eadbeb3de19e5b26003c2b401e00bb71df4 Mon Sep 17 00:00:00 2001 From: polo Date: Sun, 18 Oct 2026 00:08:23 +0200 Subject: =?UTF-8?q?sortie=20de=20vendor=20du=20d=C3=A9p=C3=B4t,=20oubli=20?= =?UTF-8?q?dans=20config-template.ini?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- vendor/doctrine/orm/src/UnitOfWork.php | 3252 -------------------------------- 1 file changed, 3252 deletions(-) delete mode 100644 vendor/doctrine/orm/src/UnitOfWork.php (limited to 'vendor/doctrine/orm/src/UnitOfWork.php') diff --git a/vendor/doctrine/orm/src/UnitOfWork.php b/vendor/doctrine/orm/src/UnitOfWork.php deleted file mode 100644 index 26f17d2..0000000 --- a/vendor/doctrine/orm/src/UnitOfWork.php +++ /dev/null @@ -1,3252 +0,0 @@ -> - */ - private array $identityMap = []; - - /** - * Map of all identifiers of managed entities. - * Keys are object ids (spl_object_id). - * - * @psalm-var array> - */ - private array $entityIdentifiers = []; - - /** - * Map of the original entity data of managed entities. - * Keys are object ids (spl_object_id). This is used for calculating changesets - * at commit time. - * - * Internal note: Note that PHPs "copy-on-write" behavior helps a lot with memory usage. - * A value will only really be copied if the value in the entity is modified - * by the user. - * - * @psalm-var array> - */ - private array $originalEntityData = []; - - /** - * Map of entity changes. Keys are object ids (spl_object_id). - * Filled at the beginning of a commit of the UnitOfWork and cleaned at the end. - * - * @psalm-var array> - */ - private array $entityChangeSets = []; - - /** - * The (cached) states of any known entities. - * Keys are object ids (spl_object_id). - * - * @psalm-var array - */ - private array $entityStates = []; - - /** - * Map of entities that are scheduled for dirty checking at commit time. - * This is only used for entities with a change tracking policy of DEFERRED_EXPLICIT. - * Keys are object ids (spl_object_id). - * - * @psalm-var array> - */ - private array $scheduledForSynchronization = []; - - /** - * A list of all pending entity insertions. - * - * @psalm-var array - */ - private array $entityInsertions = []; - - /** - * A list of all pending entity updates. - * - * @psalm-var array - */ - private array $entityUpdates = []; - - /** - * Any pending extra updates that have been scheduled by persisters. - * - * @psalm-var array}> - */ - private array $extraUpdates = []; - - /** - * A list of all pending entity deletions. - * - * @psalm-var array - */ - private array $entityDeletions = []; - - /** - * New entities that were discovered through relationships that were not - * marked as cascade-persist. During flush, this array is populated and - * then pruned of any entities that were discovered through a valid - * cascade-persist path. (Leftovers cause an error.) - * - * Keys are OIDs, payload is a two-item array describing the association - * and the entity. - * - * @var array indexed by respective object spl_object_id() - */ - private array $nonCascadedNewDetectedEntities = []; - - /** - * All pending collection deletions. - * - * @psalm-var array> - */ - private array $collectionDeletions = []; - - /** - * All pending collection updates. - * - * @psalm-var array> - */ - private array $collectionUpdates = []; - - /** - * List of collections visited during changeset calculation on a commit-phase of a UnitOfWork. - * At the end of the UnitOfWork all these collections will make new snapshots - * of their data. - * - * @psalm-var array> - */ - private array $visitedCollections = []; - - /** - * List of collections visited during the changeset calculation that contain to-be-removed - * entities and need to have keys removed post commit. - * - * Indexed by Collection object ID, which also serves as the key in self::$visitedCollections; - * values are the key names that need to be removed. - * - * @psalm-var array> - */ - private array $pendingCollectionElementRemovals = []; - - /** - * The entity persister instances used to persist entity instances. - * - * @psalm-var array - */ - private array $persisters = []; - - /** - * The collection persister instances used to persist collections. - * - * @psalm-var array - */ - private array $collectionPersisters = []; - - /** - * The EventManager used for dispatching events. - */ - private readonly EventManager $evm; - - /** - * The ListenersInvoker used for dispatching events. - */ - private readonly ListenersInvoker $listenersInvoker; - - /** - * The IdentifierFlattener used for manipulating identifiers - */ - private readonly IdentifierFlattener $identifierFlattener; - - /** - * Orphaned entities that are scheduled for removal. - * - * @psalm-var array - */ - private array $orphanRemovals = []; - - /** - * Read-Only objects are never evaluated - * - * @var array - */ - private array $readOnlyObjects = []; - - /** - * Map of Entity Class-Names and corresponding IDs that should eager loaded when requested. - * - * @psalm-var array> - */ - private array $eagerLoadingEntities = []; - - /** @var array> */ - private array $eagerLoadingCollections = []; - - protected bool $hasCache = false; - - /** - * Helper for handling completion of hydration - */ - private readonly HydrationCompleteHandler $hydrationCompleteHandler; - - /** - * Initializes a new UnitOfWork instance, bound to the given EntityManager. - * - * @param EntityManagerInterface $em The EntityManager that "owns" this UnitOfWork instance. - */ - public function __construct( - private readonly EntityManagerInterface $em, - ) { - $this->evm = $em->getEventManager(); - $this->listenersInvoker = new ListenersInvoker($em); - $this->hasCache = $em->getConfiguration()->isSecondLevelCacheEnabled(); - $this->identifierFlattener = new IdentifierFlattener($this, $em->getMetadataFactory()); - $this->hydrationCompleteHandler = new HydrationCompleteHandler($this->listenersInvoker, $em); - } - - /** - * Commits the UnitOfWork, executing all operations that have been postponed - * up to this point. The state of all managed entities will be synchronized with - * the database. - * - * The operations are executed in the following order: - * - * 1) All entity insertions - * 2) All entity updates - * 3) All collection deletions - * 4) All collection updates - * 5) All entity deletions - * - * @throws Exception - */ - public function commit(): void - { - $connection = $this->em->getConnection(); - - if ($connection instanceof PrimaryReadReplicaConnection) { - $connection->ensureConnectedToPrimary(); - } - - // Raise preFlush - if ($this->evm->hasListeners(Events::preFlush)) { - $this->evm->dispatchEvent(Events::preFlush, new PreFlushEventArgs($this->em)); - } - - // Compute changes done since last commit. - $this->computeChangeSets(); - - if ( - ! ($this->entityInsertions || - $this->entityDeletions || - $this->entityUpdates || - $this->collectionUpdates || - $this->collectionDeletions || - $this->orphanRemovals) - ) { - $this->dispatchOnFlushEvent(); - $this->dispatchPostFlushEvent(); - - $this->postCommitCleanup(); - - return; // Nothing to do. - } - - $this->assertThatThereAreNoUnintentionallyNonPersistedAssociations(); - - if ($this->orphanRemovals) { - foreach ($this->orphanRemovals as $orphan) { - $this->remove($orphan); - } - } - - $this->dispatchOnFlushEvent(); - - $conn = $this->em->getConnection(); - $conn->beginTransaction(); - - try { - // Collection deletions (deletions of complete collections) - foreach ($this->collectionDeletions as $collectionToDelete) { - // Deferred explicit tracked collections can be removed only when owning relation was persisted - $owner = $collectionToDelete->getOwner(); - - if ($this->em->getClassMetadata($owner::class)->isChangeTrackingDeferredImplicit() || $this->isScheduledForDirtyCheck($owner)) { - $this->getCollectionPersister($collectionToDelete->getMapping())->delete($collectionToDelete); - } - } - - if ($this->entityInsertions) { - // Perform entity insertions first, so that all new entities have their rows in the database - // and can be referred to by foreign keys. The commit order only needs to take new entities - // into account (new entities referring to other new entities), since all other types (entities - // with updates or scheduled deletions) are currently not a problem, since they are already - // in the database. - $this->executeInserts(); - } - - if ($this->entityUpdates) { - // Updates do not need to follow a particular order - $this->executeUpdates(); - } - - // Extra updates that were requested by persisters. - // This may include foreign keys that could not be set when an entity was inserted, - // which may happen in the case of circular foreign key relationships. - if ($this->extraUpdates) { - $this->executeExtraUpdates(); - } - - // Collection updates (deleteRows, updateRows, insertRows) - // No particular order is necessary, since all entities themselves are already - // in the database - foreach ($this->collectionUpdates as $collectionToUpdate) { - $this->getCollectionPersister($collectionToUpdate->getMapping())->update($collectionToUpdate); - } - - // Entity deletions come last. Their order only needs to take care of other deletions - // (first delete entities depending upon others, before deleting depended-upon entities). - if ($this->entityDeletions) { - $this->executeDeletions(); - } - - $commitFailed = false; - try { - if ($conn->commit() === false) { - $commitFailed = true; - } - } catch (DBAL\Exception $e) { - $commitFailed = true; - } - - if ($commitFailed) { - throw new OptimisticLockException('Commit failed', null, $e ?? null); - } - } catch (Throwable $e) { - $this->em->close(); - - if ($conn->isTransactionActive()) { - $conn->rollBack(); - } - - $this->afterTransactionRolledBack(); - - throw $e; - } - - $this->afterTransactionComplete(); - - // Unset removed entities from collections, and take new snapshots from - // all visited collections. - foreach ($this->visitedCollections as $coid => $coll) { - if (isset($this->pendingCollectionElementRemovals[$coid])) { - foreach ($this->pendingCollectionElementRemovals[$coid] as $key => $valueIgnored) { - unset($coll[$key]); - } - } - - $coll->takeSnapshot(); - } - - $this->dispatchPostFlushEvent(); - - $this->postCommitCleanup(); - } - - private function postCommitCleanup(): void - { - $this->entityInsertions = - $this->entityUpdates = - $this->entityDeletions = - $this->extraUpdates = - $this->collectionUpdates = - $this->nonCascadedNewDetectedEntities = - $this->collectionDeletions = - $this->pendingCollectionElementRemovals = - $this->visitedCollections = - $this->orphanRemovals = - $this->entityChangeSets = - $this->scheduledForSynchronization = []; - } - - /** - * Computes the changesets of all entities scheduled for insertion. - */ - private function computeScheduleInsertsChangeSets(): void - { - foreach ($this->entityInsertions as $entity) { - $class = $this->em->getClassMetadata($entity::class); - - $this->computeChangeSet($class, $entity); - } - } - - /** - * Executes any extra updates that have been scheduled. - */ - private function executeExtraUpdates(): void - { - foreach ($this->extraUpdates as $oid => $update) { - [$entity, $changeset] = $update; - - $this->entityChangeSets[$oid] = $changeset; - $this->getEntityPersister($entity::class)->update($entity); - } - - $this->extraUpdates = []; - } - - /** - * Gets the changeset for an entity. - * - * @return mixed[][] - * @psalm-return array - */ - public function & getEntityChangeSet(object $entity): array - { - $oid = spl_object_id($entity); - $data = []; - - if (! isset($this->entityChangeSets[$oid])) { - return $data; - } - - return $this->entityChangeSets[$oid]; - } - - /** - * Computes the changes that happened to a single entity. - * - * Modifies/populates the following properties: - * - * {@link _originalEntityData} - * If the entity is NEW or MANAGED but not yet fully persisted (only has an id) - * then it was not fetched from the database and therefore we have no original - * entity data yet. All of the current entity data is stored as the original entity data. - * - * {@link _entityChangeSets} - * The changes detected on all properties of the entity are stored there. - * A change is a tuple array where the first entry is the old value and the second - * entry is the new value of the property. Changesets are used by persisters - * to INSERT/UPDATE the persistent entity state. - * - * {@link _entityUpdates} - * If the entity is already fully MANAGED (has been fetched from the database before) - * and any changes to its properties are detected, then a reference to the entity is stored - * there to mark it for an update. - * - * {@link _collectionDeletions} - * If a PersistentCollection has been de-referenced in a fully MANAGED entity, - * then this collection is marked for deletion. - * - * @param ClassMetadata $class The class descriptor of the entity. - * @param object $entity The entity for which to compute the changes. - * @psalm-param ClassMetadata $class - * @psalm-param T $entity - * - * @template T of object - * - * @ignore - */ - public function computeChangeSet(ClassMetadata $class, object $entity): void - { - $oid = spl_object_id($entity); - - if (isset($this->readOnlyObjects[$oid])) { - return; - } - - if (! $class->isInheritanceTypeNone()) { - $class = $this->em->getClassMetadata($entity::class); - } - - $invoke = $this->listenersInvoker->getSubscribedSystems($class, Events::preFlush) & ~ListenersInvoker::INVOKE_MANAGER; - - if ($invoke !== ListenersInvoker::INVOKE_NONE) { - $this->listenersInvoker->invoke($class, Events::preFlush, $entity, new PreFlushEventArgs($this->em), $invoke); - } - - $actualData = []; - - foreach ($class->reflFields as $name => $refProp) { - $value = $refProp->getValue($entity); - - if ($class->isCollectionValuedAssociation($name) && $value !== null) { - if ($value instanceof PersistentCollection) { - if ($value->getOwner() === $entity) { - $actualData[$name] = $value; - continue; - } - - $value = new ArrayCollection($value->getValues()); - } - - // If $value is not a Collection then use an ArrayCollection. - if (! $value instanceof Collection) { - $value = new ArrayCollection($value); - } - - $assoc = $class->associationMappings[$name]; - assert($assoc->isToMany()); - - // Inject PersistentCollection - $value = new PersistentCollection( - $this->em, - $this->em->getClassMetadata($assoc->targetEntity), - $value, - ); - $value->setOwner($entity, $assoc); - $value->setDirty(! $value->isEmpty()); - - $refProp->setValue($entity, $value); - - $actualData[$name] = $value; - - continue; - } - - if (( ! $class->isIdentifier($name) || ! $class->isIdGeneratorIdentity()) && ($name !== $class->versionField)) { - $actualData[$name] = $value; - } - } - - if (! isset($this->originalEntityData[$oid])) { - // Entity is either NEW or MANAGED but not yet fully persisted (only has an id). - // These result in an INSERT. - $this->originalEntityData[$oid] = $actualData; - $changeSet = []; - - foreach ($actualData as $propName => $actualValue) { - if (! isset($class->associationMappings[$propName])) { - $changeSet[$propName] = [null, $actualValue]; - - continue; - } - - $assoc = $class->associationMappings[$propName]; - - if ($assoc->isToOneOwningSide()) { - $changeSet[$propName] = [null, $actualValue]; - } - } - - $this->entityChangeSets[$oid] = $changeSet; - } else { - // Entity is "fully" MANAGED: it was already fully persisted before - // and we have a copy of the original data - $originalData = $this->originalEntityData[$oid]; - $changeSet = []; - - foreach ($actualData as $propName => $actualValue) { - // skip field, its a partially omitted one! - if (! (isset($originalData[$propName]) || array_key_exists($propName, $originalData))) { - continue; - } - - $orgValue = $originalData[$propName]; - - if (! empty($class->fieldMappings[$propName]->enumType)) { - if (is_array($orgValue)) { - foreach ($orgValue as $id => $val) { - if ($val instanceof BackedEnum) { - $orgValue[$id] = $val->value; - } - } - } else { - if ($orgValue instanceof BackedEnum) { - $orgValue = $orgValue->value; - } - } - } - - // skip if value haven't changed - if ($orgValue === $actualValue) { - continue; - } - - // if regular field - if (! isset($class->associationMappings[$propName])) { - $changeSet[$propName] = [$orgValue, $actualValue]; - - continue; - } - - $assoc = $class->associationMappings[$propName]; - - // Persistent collection was exchanged with the "originally" - // created one. This can only mean it was cloned and replaced - // on another entity. - if ($actualValue instanceof PersistentCollection) { - assert($assoc->isToMany()); - $owner = $actualValue->getOwner(); - if ($owner === null) { // cloned - $actualValue->setOwner($entity, $assoc); - } elseif ($owner !== $entity) { // no clone, we have to fix - if (! $actualValue->isInitialized()) { - $actualValue->initialize(); // we have to do this otherwise the cols share state - } - - $newValue = clone $actualValue; - $newValue->setOwner($entity, $assoc); - $class->reflFields[$propName]->setValue($entity, $newValue); - } - } - - if ($orgValue instanceof PersistentCollection) { - // A PersistentCollection was de-referenced, so delete it. - $coid = spl_object_id($orgValue); - - if (isset($this->collectionDeletions[$coid])) { - continue; - } - - $this->collectionDeletions[$coid] = $orgValue; - $changeSet[$propName] = $orgValue; // Signal changeset, to-many assocs will be ignored. - - continue; - } - - if ($assoc->isToOne()) { - if ($assoc->isOwningSide()) { - $changeSet[$propName] = [$orgValue, $actualValue]; - } - - if ($orgValue !== null && $assoc->orphanRemoval) { - assert(is_object($orgValue)); - $this->scheduleOrphanRemoval($orgValue); - } - } - } - - if ($changeSet) { - $this->entityChangeSets[$oid] = $changeSet; - $this->originalEntityData[$oid] = $actualData; - $this->entityUpdates[$oid] = $entity; - } - } - - // Look for changes in associations of the entity - foreach ($class->associationMappings as $field => $assoc) { - $val = $class->reflFields[$field]->getValue($entity); - if ($val === null) { - continue; - } - - $this->computeAssociationChanges($assoc, $val); - - if ( - ! isset($this->entityChangeSets[$oid]) && - $assoc->isManyToManyOwningSide() && - $val instanceof PersistentCollection && - $val->isDirty() - ) { - $this->entityChangeSets[$oid] = []; - $this->originalEntityData[$oid] = $actualData; - $this->entityUpdates[$oid] = $entity; - } - } - } - - /** - * Computes all the changes that have been done to entities and collections - * since the last commit and stores these changes in the _entityChangeSet map - * temporarily for access by the persisters, until the UoW commit is finished. - */ - public function computeChangeSets(): void - { - // Compute changes for INSERTed entities first. This must always happen. - $this->computeScheduleInsertsChangeSets(); - - // Compute changes for other MANAGED entities. Change tracking policies take effect here. - foreach ($this->identityMap as $className => $entities) { - $class = $this->em->getClassMetadata($className); - - // Skip class if instances are read-only - if ($class->isReadOnly) { - continue; - } - - $entitiesToProcess = match (true) { - $class->isChangeTrackingDeferredImplicit() => $entities, - isset($this->scheduledForSynchronization[$className]) => $this->scheduledForSynchronization[$className], - default => [], - }; - - foreach ($entitiesToProcess as $entity) { - // Ignore uninitialized proxy objects - if ($this->isUninitializedObject($entity)) { - continue; - } - - // Only MANAGED entities that are NOT SCHEDULED FOR INSERTION OR DELETION are processed here. - $oid = spl_object_id($entity); - - if (! isset($this->entityInsertions[$oid]) && ! isset($this->entityDeletions[$oid]) && isset($this->entityStates[$oid])) { - $this->computeChangeSet($class, $entity); - } - } - } - } - - /** - * Computes the changes of an association. - * - * @param mixed $value The value of the association. - * - * @throws ORMInvalidArgumentException - * @throws ORMException - */ - private function computeAssociationChanges(AssociationMapping $assoc, mixed $value): void - { - if ($this->isUninitializedObject($value)) { - return; - } - - // If this collection is dirty, schedule it for updates - if ($value instanceof PersistentCollection && $value->isDirty()) { - $coid = spl_object_id($value); - - $this->collectionUpdates[$coid] = $value; - $this->visitedCollections[$coid] = $value; - } - - // Look through the entities, and in any of their associations, - // for transient (new) entities, recursively. ("Persistence by reachability") - // Unwrap. Uninitialized collections will simply be empty. - $unwrappedValue = $assoc->isToOne() ? [$value] : $value->unwrap(); - $targetClass = $this->em->getClassMetadata($assoc->targetEntity); - - foreach ($unwrappedValue as $key => $entry) { - if (! ($entry instanceof $targetClass->name)) { - throw ORMInvalidArgumentException::invalidAssociation($targetClass, $assoc, $entry); - } - - $state = $this->getEntityState($entry, self::STATE_NEW); - - if (! ($entry instanceof $assoc->targetEntity)) { - throw UnexpectedAssociationValue::create( - $assoc->sourceEntity, - $assoc->fieldName, - get_debug_type($entry), - $assoc->targetEntity, - ); - } - - switch ($state) { - case self::STATE_NEW: - if (! $assoc->isCascadePersist()) { - /* - * For now just record the details, because this may - * not be an issue if we later discover another pathway - * through the object-graph where cascade-persistence - * is enabled for this object. - */ - $this->nonCascadedNewDetectedEntities[spl_object_id($entry)] = [$assoc, $entry]; - - break; - } - - $this->persistNew($targetClass, $entry); - $this->computeChangeSet($targetClass, $entry); - - break; - - case self::STATE_REMOVED: - // Consume the $value as array (it's either an array or an ArrayAccess) - // and remove the element from Collection. - if (! $assoc->isToMany()) { - break; - } - - $coid = spl_object_id($value); - $this->visitedCollections[$coid] = $value; - - if (! isset($this->pendingCollectionElementRemovals[$coid])) { - $this->pendingCollectionElementRemovals[$coid] = []; - } - - $this->pendingCollectionElementRemovals[$coid][$key] = true; - break; - - case self::STATE_DETACHED: - // Can actually not happen right now as we assume STATE_NEW, - // so the exception will be raised from the DBAL layer (constraint violation). - throw ORMInvalidArgumentException::detachedEntityFoundThroughRelationship($assoc, $entry); - - default: - // MANAGED associated entities are already taken into account - // during changeset calculation anyway, since they are in the identity map. - } - } - } - - /** - * @psalm-param ClassMetadata $class - * @psalm-param T $entity - * - * @template T of object - */ - private function persistNew(ClassMetadata $class, object $entity): void - { - $oid = spl_object_id($entity); - $invoke = $this->listenersInvoker->getSubscribedSystems($class, Events::prePersist); - - if ($invoke !== ListenersInvoker::INVOKE_NONE) { - $this->listenersInvoker->invoke($class, Events::prePersist, $entity, new PrePersistEventArgs($entity, $this->em), $invoke); - } - - $idGen = $class->idGenerator; - - if (! $idGen->isPostInsertGenerator()) { - $idValue = $idGen->generateId($this->em, $entity); - - if (! $idGen instanceof AssignedGenerator) { - $idValue = [$class->getSingleIdentifierFieldName() => $this->convertSingleFieldIdentifierToPHPValue($class, $idValue)]; - - $class->setIdentifierValues($entity, $idValue); - } - - // Some identifiers may be foreign keys to new entities. - // In this case, we don't have the value yet and should treat it as if we have a post-insert generator - if (! $this->hasMissingIdsWhichAreForeignKeys($class, $idValue)) { - $this->entityIdentifiers[$oid] = $idValue; - } - } - - $this->entityStates[$oid] = self::STATE_MANAGED; - - $this->scheduleForInsert($entity); - } - - /** @param mixed[] $idValue */ - private function hasMissingIdsWhichAreForeignKeys(ClassMetadata $class, array $idValue): bool - { - foreach ($idValue as $idField => $idFieldValue) { - if ($idFieldValue === null && isset($class->associationMappings[$idField])) { - return true; - } - } - - return false; - } - - /** - * INTERNAL: - * Computes the changeset of an individual entity, independently of the - * computeChangeSets() routine that is used at the beginning of a UnitOfWork#commit(). - * - * The passed entity must be a managed entity. If the entity already has a change set - * because this method is invoked during a commit cycle then the change sets are added. - * whereby changes detected in this method prevail. - * - * @param ClassMetadata $class The class descriptor of the entity. - * @param object $entity The entity for which to (re)calculate the change set. - * @psalm-param ClassMetadata $class - * @psalm-param T $entity - * - * @throws ORMInvalidArgumentException If the passed entity is not MANAGED. - * - * @template T of object - * @ignore - */ - public function recomputeSingleEntityChangeSet(ClassMetadata $class, object $entity): void - { - $oid = spl_object_id($entity); - - if (! isset($this->entityStates[$oid]) || $this->entityStates[$oid] !== self::STATE_MANAGED) { - throw ORMInvalidArgumentException::entityNotManaged($entity); - } - - if (! $class->isInheritanceTypeNone()) { - $class = $this->em->getClassMetadata($entity::class); - } - - $actualData = []; - - foreach ($class->reflFields as $name => $refProp) { - if ( - ( ! $class->isIdentifier($name) || ! $class->isIdGeneratorIdentity()) - && ($name !== $class->versionField) - && ! $class->isCollectionValuedAssociation($name) - ) { - $actualData[$name] = $refProp->getValue($entity); - } - } - - if (! isset($this->originalEntityData[$oid])) { - throw new RuntimeException('Cannot call recomputeSingleEntityChangeSet before computeChangeSet on an entity.'); - } - - $originalData = $this->originalEntityData[$oid]; - $changeSet = []; - - foreach ($actualData as $propName => $actualValue) { - $orgValue = $originalData[$propName] ?? null; - - if (isset($class->fieldMappings[$propName]->enumType)) { - if (is_array($orgValue)) { - foreach ($orgValue as $id => $val) { - if ($val instanceof BackedEnum) { - $orgValue[$id] = $val->value; - } - } - } else { - if ($orgValue instanceof BackedEnum) { - $orgValue = $orgValue->value; - } - } - } - - if ($orgValue !== $actualValue) { - $changeSet[$propName] = [$orgValue, $actualValue]; - } - } - - if ($changeSet) { - if (isset($this->entityChangeSets[$oid])) { - $this->entityChangeSets[$oid] = [...$this->entityChangeSets[$oid], ...$changeSet]; - } elseif (! isset($this->entityInsertions[$oid])) { - $this->entityChangeSets[$oid] = $changeSet; - $this->entityUpdates[$oid] = $entity; - } - - $this->originalEntityData[$oid] = $actualData; - } - } - - /** - * Executes entity insertions - */ - private function executeInserts(): void - { - $entities = $this->computeInsertExecutionOrder(); - $eventsToDispatch = []; - - foreach ($entities as $entity) { - $oid = spl_object_id($entity); - $class = $this->em->getClassMetadata($entity::class); - $persister = $this->getEntityPersister($class->name); - - $persister->addInsert($entity); - - unset($this->entityInsertions[$oid]); - - $persister->executeInserts(); - - if (! isset($this->entityIdentifiers[$oid])) { - //entity was not added to identity map because some identifiers are foreign keys to new entities. - //add it now - $this->addToEntityIdentifiersAndEntityMap($class, $oid, $entity); - } - - $invoke = $this->listenersInvoker->getSubscribedSystems($class, Events::postPersist); - - if ($invoke !== ListenersInvoker::INVOKE_NONE) { - $eventsToDispatch[] = ['class' => $class, 'entity' => $entity, 'invoke' => $invoke]; - } - } - - // Defer dispatching `postPersist` events to until all entities have been inserted and post-insert - // IDs have been assigned. - foreach ($eventsToDispatch as $event) { - $this->listenersInvoker->invoke( - $event['class'], - Events::postPersist, - $event['entity'], - new PostPersistEventArgs($event['entity'], $this->em), - $event['invoke'], - ); - } - } - - /** - * @psalm-param ClassMetadata $class - * @psalm-param T $entity - * - * @template T of object - */ - private function addToEntityIdentifiersAndEntityMap( - ClassMetadata $class, - int $oid, - object $entity, - ): void { - $identifier = []; - - foreach ($class->getIdentifierFieldNames() as $idField) { - $origValue = $class->getFieldValue($entity, $idField); - - $value = null; - if (isset($class->associationMappings[$idField])) { - // NOTE: Single Columns as associated identifiers only allowed - this constraint it is enforced. - $value = $this->getSingleIdentifierValue($origValue); - } - - $identifier[$idField] = $value ?? $origValue; - $this->originalEntityData[$oid][$idField] = $origValue; - } - - $this->entityStates[$oid] = self::STATE_MANAGED; - $this->entityIdentifiers[$oid] = $identifier; - - $this->addToIdentityMap($entity); - } - - /** - * Executes all entity updates - */ - private function executeUpdates(): void - { - foreach ($this->entityUpdates as $oid => $entity) { - $class = $this->em->getClassMetadata($entity::class); - $persister = $this->getEntityPersister($class->name); - $preUpdateInvoke = $this->listenersInvoker->getSubscribedSystems($class, Events::preUpdate); - $postUpdateInvoke = $this->listenersInvoker->getSubscribedSystems($class, Events::postUpdate); - - if ($preUpdateInvoke !== ListenersInvoker::INVOKE_NONE) { - $this->listenersInvoker->invoke($class, Events::preUpdate, $entity, new PreUpdateEventArgs($entity, $this->em, $this->getEntityChangeSet($entity)), $preUpdateInvoke); - - $this->recomputeSingleEntityChangeSet($class, $entity); - } - - if (! empty($this->entityChangeSets[$oid])) { - $persister->update($entity); - } - - unset($this->entityUpdates[$oid]); - - if ($postUpdateInvoke !== ListenersInvoker::INVOKE_NONE) { - $this->listenersInvoker->invoke($class, Events::postUpdate, $entity, new PostUpdateEventArgs($entity, $this->em), $postUpdateInvoke); - } - } - } - - /** - * Executes all entity deletions - */ - private function executeDeletions(): void - { - $entities = $this->computeDeleteExecutionOrder(); - $eventsToDispatch = []; - - foreach ($entities as $entity) { - $this->removeFromIdentityMap($entity); - - $oid = spl_object_id($entity); - $class = $this->em->getClassMetadata($entity::class); - $persister = $this->getEntityPersister($class->name); - $invoke = $this->listenersInvoker->getSubscribedSystems($class, Events::postRemove); - - $persister->delete($entity); - - unset( - $this->entityDeletions[$oid], - $this->entityIdentifiers[$oid], - $this->originalEntityData[$oid], - $this->entityStates[$oid], - ); - - // Entity with this $oid after deletion treated as NEW, even if the $oid - // is obtained by a new entity because the old one went out of scope. - //$this->entityStates[$oid] = self::STATE_NEW; - if (! $class->isIdentifierNatural()) { - $class->reflFields[$class->identifier[0]]->setValue($entity, null); - } - - if ($invoke !== ListenersInvoker::INVOKE_NONE) { - $eventsToDispatch[] = ['class' => $class, 'entity' => $entity, 'invoke' => $invoke]; - } - } - - // Defer dispatching `postRemove` events to until all entities have been removed. - foreach ($eventsToDispatch as $event) { - $this->listenersInvoker->invoke( - $event['class'], - Events::postRemove, - $event['entity'], - new PostRemoveEventArgs($event['entity'], $this->em), - $event['invoke'], - ); - } - } - - /** @return list */ - private function computeInsertExecutionOrder(): array - { - $sort = new TopologicalSort(); - - // First make sure we have all the nodes - foreach ($this->entityInsertions as $entity) { - $sort->addNode($entity); - } - - // Now add edges - foreach ($this->entityInsertions as $entity) { - $class = $this->em->getClassMetadata($entity::class); - - foreach ($class->associationMappings as $assoc) { - // We only need to consider the owning sides of to-one associations, - // since many-to-many associations are persisted at a later step and - // have no insertion order problems (all entities already in the database - // at that time). - if (! $assoc->isToOneOwningSide()) { - continue; - } - - $targetEntity = $class->getFieldValue($entity, $assoc->fieldName); - - // If there is no entity that we need to refer to, or it is already in the - // database (i. e. does not have to be inserted), no need to consider it. - if ($targetEntity === null || ! $sort->hasNode($targetEntity)) { - continue; - } - - // An entity that references back to itself _and_ uses an application-provided ID - // (the "NONE" generator strategy) can be exempted from commit order computation. - // See https://github.com/doctrine/orm/pull/10735/ for more details on this edge case. - // A non-NULLable self-reference would be a cycle in the graph. - if ($targetEntity === $entity && $class->isIdentifierNatural()) { - continue; - } - - // According to https://www.doctrine-project.org/projects/doctrine-orm/en/2.14/reference/annotations-reference.html#annref_joincolumn, - // the default for "nullable" is true. Unfortunately, it seems this default is not applied at the metadata driver, factory or other - // level, but in fact we may have an undefined 'nullable' key here, so we must assume that default here as well. - // - // Same in \Doctrine\ORM\Tools\EntityGenerator::isAssociationIsNullable or \Doctrine\ORM\Persisters\Entity\BasicEntityPersister::getJoinSQLForJoinColumns, - // to give two examples. - $joinColumns = reset($assoc->joinColumns); - $isNullable = ! isset($joinColumns->nullable) || $joinColumns->nullable; - - // Add dependency. The dependency direction implies that "$entity depends on $targetEntity". The - // topological sort result will output the depended-upon nodes first, which means we can insert - // entities in that order. - $sort->addEdge($entity, $targetEntity, $isNullable); - } - } - - return $sort->sort(); - } - - /** @return list */ - private function computeDeleteExecutionOrder(): array - { - $stronglyConnectedComponents = new StronglyConnectedComponents(); - $sort = new TopologicalSort(); - - foreach ($this->entityDeletions as $entity) { - $stronglyConnectedComponents->addNode($entity); - $sort->addNode($entity); - } - - // First, consider only "on delete cascade" associations between entities - // and find strongly connected groups. Once we delete any one of the entities - // in such a group, _all_ of the other entities will be removed as well. So, - // we need to treat those groups like a single entity when performing delete - // order topological sorting. - foreach ($this->entityDeletions as $entity) { - $class = $this->em->getClassMetadata($entity::class); - - foreach ($class->associationMappings as $assoc) { - // We only need to consider the owning sides of to-one associations, - // since many-to-many associations can always be (and have already been) - // deleted in a preceding step. - if (! $assoc->isToOneOwningSide()) { - continue; - } - - $joinColumns = reset($assoc->joinColumns); - if (! isset($joinColumns->onDelete)) { - continue; - } - - $onDeleteOption = strtolower($joinColumns->onDelete); - if ($onDeleteOption !== 'cascade') { - continue; - } - - $targetEntity = $class->getFieldValue($entity, $assoc->fieldName); - - // If the association does not refer to another entity or that entity - // is not to be deleted, there is no ordering problem and we can - // skip this particular association. - if ($targetEntity === null || ! $stronglyConnectedComponents->hasNode($targetEntity)) { - continue; - } - - $stronglyConnectedComponents->addEdge($entity, $targetEntity); - } - } - - $stronglyConnectedComponents->findStronglyConnectedComponents(); - - // Now do the actual topological sorting to find the delete order. - foreach ($this->entityDeletions as $entity) { - $class = $this->em->getClassMetadata($entity::class); - - // Get the entities representing the SCC - $entityComponent = $stronglyConnectedComponents->getNodeRepresentingStronglyConnectedComponent($entity); - - // When $entity is part of a non-trivial strongly connected component group - // (a group containing not only those entities alone), make sure we process it _after_ the - // entity representing the group. - // The dependency direction implies that "$entity depends on $entityComponent - // being deleted first". The topological sort will output the depended-upon nodes first. - if ($entityComponent !== $entity) { - $sort->addEdge($entity, $entityComponent, false); - } - - foreach ($class->associationMappings as $assoc) { - // We only need to consider the owning sides of to-one associations, - // since many-to-many associations can always be (and have already been) - // deleted in a preceding step. - if (! $assoc->isToOneOwningSide()) { - continue; - } - - // For associations that implement a database-level set null operation, - // we do not have to follow a particular order: If the referred-to entity is - // deleted first, the DBMS will temporarily set the foreign key to NULL (SET NULL). - // So, we can skip it in the computation. - $joinColumns = reset($assoc->joinColumns); - if (isset($joinColumns->onDelete)) { - $onDeleteOption = strtolower($joinColumns->onDelete); - if ($onDeleteOption === 'set null') { - continue; - } - } - - $targetEntity = $class->getFieldValue($entity, $assoc->fieldName); - - // If the association does not refer to another entity or that entity - // is not to be deleted, there is no ordering problem and we can - // skip this particular association. - if ($targetEntity === null || ! $sort->hasNode($targetEntity)) { - continue; - } - - // Get the entities representing the SCC - $targetEntityComponent = $stronglyConnectedComponents->getNodeRepresentingStronglyConnectedComponent($targetEntity); - - // When we have a dependency between two different groups of strongly connected nodes, - // add it to the computation. - // The dependency direction implies that "$targetEntityComponent depends on $entityComponent - // being deleted first". The topological sort will output the depended-upon nodes first, - // so we can work through the result in the returned order. - if ($targetEntityComponent !== $entityComponent) { - $sort->addEdge($targetEntityComponent, $entityComponent, false); - } - } - } - - return $sort->sort(); - } - - /** - * Schedules an entity for insertion into the database. - * If the entity already has an identifier, it will be added to the identity map. - * - * @throws ORMInvalidArgumentException - * @throws InvalidArgumentException - */ - public function scheduleForInsert(object $entity): void - { - $oid = spl_object_id($entity); - - if (isset($this->entityUpdates[$oid])) { - throw new InvalidArgumentException('Dirty entity can not be scheduled for insertion.'); - } - - if (isset($this->entityDeletions[$oid])) { - throw ORMInvalidArgumentException::scheduleInsertForRemovedEntity($entity); - } - - if (isset($this->originalEntityData[$oid]) && ! isset($this->entityInsertions[$oid])) { - throw ORMInvalidArgumentException::scheduleInsertForManagedEntity($entity); - } - - if (isset($this->entityInsertions[$oid])) { - throw ORMInvalidArgumentException::scheduleInsertTwice($entity); - } - - $this->entityInsertions[$oid] = $entity; - - if (isset($this->entityIdentifiers[$oid])) { - $this->addToIdentityMap($entity); - } - } - - /** - * Checks whether an entity is scheduled for insertion. - */ - public function isScheduledForInsert(object $entity): bool - { - return isset($this->entityInsertions[spl_object_id($entity)]); - } - - /** - * Schedules an entity for being updated. - * - * @throws ORMInvalidArgumentException - */ - public function scheduleForUpdate(object $entity): void - { - $oid = spl_object_id($entity); - - if (! isset($this->entityIdentifiers[$oid])) { - throw ORMInvalidArgumentException::entityHasNoIdentity($entity, 'scheduling for update'); - } - - if (isset($this->entityDeletions[$oid])) { - throw ORMInvalidArgumentException::entityIsRemoved($entity, 'schedule for update'); - } - - if (! isset($this->entityUpdates[$oid]) && ! isset($this->entityInsertions[$oid])) { - $this->entityUpdates[$oid] = $entity; - } - } - - /** - * INTERNAL: - * Schedules an extra update that will be executed immediately after the - * regular entity updates within the currently running commit cycle. - * - * Extra updates for entities are stored as (entity, changeset) tuples. - * - * @psalm-param array $changeset The changeset of the entity (what to update). - * - * @ignore - */ - public function scheduleExtraUpdate(object $entity, array $changeset): void - { - $oid = spl_object_id($entity); - $extraUpdate = [$entity, $changeset]; - - if (isset($this->extraUpdates[$oid])) { - [, $changeset2] = $this->extraUpdates[$oid]; - - $extraUpdate = [$entity, $changeset + $changeset2]; - } - - $this->extraUpdates[$oid] = $extraUpdate; - } - - /** - * Checks whether an entity is registered as dirty in the unit of work. - * Note: Is not very useful currently as dirty entities are only registered - * at commit time. - */ - public function isScheduledForUpdate(object $entity): bool - { - return isset($this->entityUpdates[spl_object_id($entity)]); - } - - /** - * Checks whether an entity is registered to be checked in the unit of work. - */ - public function isScheduledForDirtyCheck(object $entity): bool - { - $rootEntityName = $this->em->getClassMetadata($entity::class)->rootEntityName; - - return isset($this->scheduledForSynchronization[$rootEntityName][spl_object_id($entity)]); - } - - /** - * INTERNAL: - * Schedules an entity for deletion. - */ - public function scheduleForDelete(object $entity): void - { - $oid = spl_object_id($entity); - - if (isset($this->entityInsertions[$oid])) { - if ($this->isInIdentityMap($entity)) { - $this->removeFromIdentityMap($entity); - } - - unset($this->entityInsertions[$oid], $this->entityStates[$oid]); - - return; // entity has not been persisted yet, so nothing more to do. - } - - if (! $this->isInIdentityMap($entity)) { - return; - } - - unset($this->entityUpdates[$oid]); - - if (! isset($this->entityDeletions[$oid])) { - $this->entityDeletions[$oid] = $entity; - $this->entityStates[$oid] = self::STATE_REMOVED; - } - } - - /** - * Checks whether an entity is registered as removed/deleted with the unit - * of work. - */ - public function isScheduledForDelete(object $entity): bool - { - return isset($this->entityDeletions[spl_object_id($entity)]); - } - - /** - * Checks whether an entity is scheduled for insertion, update or deletion. - */ - public function isEntityScheduled(object $entity): bool - { - $oid = spl_object_id($entity); - - return isset($this->entityInsertions[$oid]) - || isset($this->entityUpdates[$oid]) - || isset($this->entityDeletions[$oid]); - } - - /** - * INTERNAL: - * Registers an entity in the identity map. - * Note that entities in a hierarchy are registered with the class name of - * the root entity. - * - * @return bool TRUE if the registration was successful, FALSE if the identity of - * the entity in question is already managed. - * - * @throws ORMInvalidArgumentException - * @throws EntityIdentityCollisionException - * - * @ignore - */ - public function addToIdentityMap(object $entity): bool - { - $classMetadata = $this->em->getClassMetadata($entity::class); - $idHash = $this->getIdHashByEntity($entity); - $className = $classMetadata->rootEntityName; - - if (isset($this->identityMap[$className][$idHash])) { - if ($this->identityMap[$className][$idHash] !== $entity) { - throw EntityIdentityCollisionException::create($this->identityMap[$className][$idHash], $entity, $idHash); - } - - return false; - } - - $this->identityMap[$className][$idHash] = $entity; - - return true; - } - - /** - * Gets the id hash of an entity by its identifier. - * - * @param array $identifier The identifier of an entity - * - * @return string The entity id hash. - */ - final public static function getIdHashByIdentifier(array $identifier): string - { - foreach ($identifier as $k => $value) { - if ($value instanceof BackedEnum) { - $identifier[$k] = $value->value; - } - } - - return implode( - ' ', - $identifier, - ); - } - - /** - * Gets the id hash of an entity. - * - * @param object $entity The entity managed by Unit Of Work - * - * @return string The entity id hash. - */ - public function getIdHashByEntity(object $entity): string - { - $identifier = $this->entityIdentifiers[spl_object_id($entity)]; - - if (empty($identifier) || in_array(null, $identifier, true)) { - $classMetadata = $this->em->getClassMetadata($entity::class); - - throw ORMInvalidArgumentException::entityWithoutIdentity($classMetadata->name, $entity); - } - - return self::getIdHashByIdentifier($identifier); - } - - /** - * Gets the state of an entity with regard to the current unit of work. - * - * @param int|null $assume The state to assume if the state is not yet known (not MANAGED or REMOVED). - * This parameter can be set to improve performance of entity state detection - * by potentially avoiding a database lookup if the distinction between NEW and DETACHED - * is either known or does not matter for the caller of the method. - * @psalm-param self::STATE_*|null $assume - * - * @psalm-return self::STATE_* - */ - public function getEntityState(object $entity, int|null $assume = null): int - { - $oid = spl_object_id($entity); - - if (isset($this->entityStates[$oid])) { - return $this->entityStates[$oid]; - } - - if ($assume !== null) { - return $assume; - } - - // State can only be NEW or DETACHED, because MANAGED/REMOVED states are known. - // Note that you can not remember the NEW or DETACHED state in _entityStates since - // the UoW does not hold references to such objects and the object hash can be reused. - // More generally because the state may "change" between NEW/DETACHED without the UoW being aware of it. - $class = $this->em->getClassMetadata($entity::class); - $id = $class->getIdentifierValues($entity); - - if (! $id) { - return self::STATE_NEW; - } - - if ($class->containsForeignIdentifier || $class->containsEnumIdentifier) { - $id = $this->identifierFlattener->flattenIdentifier($class, $id); - } - - switch (true) { - case $class->isIdentifierNatural(): - // Check for a version field, if available, to avoid a db lookup. - if ($class->isVersioned) { - assert($class->versionField !== null); - - return $class->getFieldValue($entity, $class->versionField) - ? self::STATE_DETACHED - : self::STATE_NEW; - } - - // Last try before db lookup: check the identity map. - if ($this->tryGetById($id, $class->rootEntityName)) { - return self::STATE_DETACHED; - } - - // db lookup - if ($this->getEntityPersister($class->name)->exists($entity)) { - return self::STATE_DETACHED; - } - - return self::STATE_NEW; - - case ! $class->idGenerator->isPostInsertGenerator(): - // if we have a pre insert generator we can't be sure that having an id - // really means that the entity exists. We have to verify this through - // the last resort: a db lookup - - // Last try before db lookup: check the identity map. - if ($this->tryGetById($id, $class->rootEntityName)) { - return self::STATE_DETACHED; - } - - // db lookup - if ($this->getEntityPersister($class->name)->exists($entity)) { - return self::STATE_DETACHED; - } - - return self::STATE_NEW; - - default: - return self::STATE_DETACHED; - } - } - - /** - * INTERNAL: - * Removes an entity from the identity map. This effectively detaches the - * entity from the persistence management of Doctrine. - * - * @throws ORMInvalidArgumentException - * - * @ignore - */ - public function removeFromIdentityMap(object $entity): bool - { - $oid = spl_object_id($entity); - $classMetadata = $this->em->getClassMetadata($entity::class); - $idHash = self::getIdHashByIdentifier($this->entityIdentifiers[$oid]); - - if ($idHash === '') { - throw ORMInvalidArgumentException::entityHasNoIdentity($entity, 'remove from identity map'); - } - - $className = $classMetadata->rootEntityName; - - if (isset($this->identityMap[$className][$idHash])) { - unset($this->identityMap[$className][$idHash], $this->readOnlyObjects[$oid]); - - //$this->entityStates[$oid] = self::STATE_DETACHED; - - return true; - } - - return false; - } - - /** - * INTERNAL: - * Gets an entity in the identity map by its identifier hash. - * - * @ignore - */ - public function getByIdHash(string $idHash, string $rootClassName): object|null - { - return $this->identityMap[$rootClassName][$idHash]; - } - - /** - * INTERNAL: - * Tries to get an entity by its identifier hash. If no entity is found for - * the given hash, FALSE is returned. - * - * @param mixed $idHash (must be possible to cast it to string) - * - * @return false|object The found entity or FALSE. - * - * @ignore - */ - public function tryGetByIdHash(mixed $idHash, string $rootClassName): object|false - { - $stringIdHash = (string) $idHash; - - return $this->identityMap[$rootClassName][$stringIdHash] ?? false; - } - - /** - * Checks whether an entity is registered in the identity map of this UnitOfWork. - */ - public function isInIdentityMap(object $entity): bool - { - $oid = spl_object_id($entity); - - if (empty($this->entityIdentifiers[$oid])) { - return false; - } - - $classMetadata = $this->em->getClassMetadata($entity::class); - $idHash = self::getIdHashByIdentifier($this->entityIdentifiers[$oid]); - - return isset($this->identityMap[$classMetadata->rootEntityName][$idHash]); - } - - /** - * Persists an entity as part of the current unit of work. - */ - public function persist(object $entity): void - { - $visited = []; - - $this->doPersist($entity, $visited); - } - - /** - * Persists an entity as part of the current unit of work. - * - * This method is internally called during persist() cascades as it tracks - * the already visited entities to prevent infinite recursions. - * - * @psalm-param array $visited The already visited entities. - * - * @throws ORMInvalidArgumentException - * @throws UnexpectedValueException - */ - private function doPersist(object $entity, array &$visited): void - { - $oid = spl_object_id($entity); - - if (isset($visited[$oid])) { - return; // Prevent infinite recursion - } - - $visited[$oid] = $entity; // Mark visited - - $class = $this->em->getClassMetadata($entity::class); - - // We assume NEW, so DETACHED entities result in an exception on flush (constraint violation). - // If we would detect DETACHED here we would throw an exception anyway with the same - // consequences (not recoverable/programming error), so just assuming NEW here - // lets us avoid some database lookups for entities with natural identifiers. - $entityState = $this->getEntityState($entity, self::STATE_NEW); - - switch ($entityState) { - case self::STATE_MANAGED: - // Nothing to do, except if policy is "deferred explicit" - if ($class->isChangeTrackingDeferredExplicit()) { - $this->scheduleForDirtyCheck($entity); - } - - break; - - case self::STATE_NEW: - $this->persistNew($class, $entity); - break; - - case self::STATE_REMOVED: - // Entity becomes managed again - unset($this->entityDeletions[$oid]); - $this->addToIdentityMap($entity); - - $this->entityStates[$oid] = self::STATE_MANAGED; - - if ($class->isChangeTrackingDeferredExplicit()) { - $this->scheduleForDirtyCheck($entity); - } - - break; - - case self::STATE_DETACHED: - // Can actually not happen right now since we assume STATE_NEW. - throw ORMInvalidArgumentException::detachedEntityCannot($entity, 'persisted'); - - default: - throw new UnexpectedValueException(sprintf( - 'Unexpected entity state: %s. %s', - $entityState, - self::objToStr($entity), - )); - } - - $this->cascadePersist($entity, $visited); - } - - /** - * Deletes an entity as part of the current unit of work. - */ - public function remove(object $entity): void - { - $visited = []; - - $this->doRemove($entity, $visited); - } - - /** - * Deletes an entity as part of the current unit of work. - * - * This method is internally called during delete() cascades as it tracks - * the already visited entities to prevent infinite recursions. - * - * @psalm-param array $visited The map of the already visited entities. - * - * @throws ORMInvalidArgumentException If the instance is a detached entity. - * @throws UnexpectedValueException - */ - private function doRemove(object $entity, array &$visited): void - { - $oid = spl_object_id($entity); - - if (isset($visited[$oid])) { - return; // Prevent infinite recursion - } - - $visited[$oid] = $entity; // mark visited - - // Cascade first, because scheduleForDelete() removes the entity from the identity map, which - // can cause problems when a lazy proxy has to be initialized for the cascade operation. - $this->cascadeRemove($entity, $visited); - - $class = $this->em->getClassMetadata($entity::class); - $entityState = $this->getEntityState($entity); - - switch ($entityState) { - case self::STATE_NEW: - case self::STATE_REMOVED: - // nothing to do - break; - - case self::STATE_MANAGED: - $invoke = $this->listenersInvoker->getSubscribedSystems($class, Events::preRemove); - - if ($invoke !== ListenersInvoker::INVOKE_NONE) { - $this->listenersInvoker->invoke($class, Events::preRemove, $entity, new PreRemoveEventArgs($entity, $this->em), $invoke); - } - - $this->scheduleForDelete($entity); - break; - - case self::STATE_DETACHED: - throw ORMInvalidArgumentException::detachedEntityCannot($entity, 'removed'); - - default: - throw new UnexpectedValueException(sprintf( - 'Unexpected entity state: %s. %s', - $entityState, - self::objToStr($entity), - )); - } - } - - /** - * Detaches an entity from the persistence management. It's persistence will - * no longer be managed by Doctrine. - */ - public function detach(object $entity): void - { - $visited = []; - - $this->doDetach($entity, $visited); - } - - /** - * Executes a detach operation on the given entity. - * - * @param mixed[] $visited - * @param bool $noCascade if true, don't cascade detach operation. - */ - private function doDetach( - object $entity, - array &$visited, - bool $noCascade = false, - ): void { - $oid = spl_object_id($entity); - - if (isset($visited[$oid])) { - return; // Prevent infinite recursion - } - - $visited[$oid] = $entity; // mark visited - - switch ($this->getEntityState($entity, self::STATE_DETACHED)) { - case self::STATE_MANAGED: - if ($this->isInIdentityMap($entity)) { - $this->removeFromIdentityMap($entity); - } - - unset( - $this->entityInsertions[$oid], - $this->entityUpdates[$oid], - $this->entityDeletions[$oid], - $this->entityIdentifiers[$oid], - $this->entityStates[$oid], - $this->originalEntityData[$oid], - ); - break; - case self::STATE_NEW: - case self::STATE_DETACHED: - return; - } - - if (! $noCascade) { - $this->cascadeDetach($entity, $visited); - } - } - - /** - * Refreshes the state of the given entity from the database, overwriting - * any local, unpersisted changes. - * - * @psalm-param LockMode::*|null $lockMode - * - * @throws InvalidArgumentException If the entity is not MANAGED. - * @throws TransactionRequiredException - */ - public function refresh(object $entity, LockMode|int|null $lockMode = null): void - { - $visited = []; - - $this->doRefresh($entity, $visited, $lockMode); - } - - /** - * Executes a refresh operation on an entity. - * - * @psalm-param array $visited The already visited entities during cascades. - * @psalm-param LockMode::*|null $lockMode - * - * @throws ORMInvalidArgumentException If the entity is not MANAGED. - * @throws TransactionRequiredException - */ - private function doRefresh(object $entity, array &$visited, LockMode|int|null $lockMode = null): void - { - switch (true) { - case $lockMode === LockMode::PESSIMISTIC_READ: - case $lockMode === LockMode::PESSIMISTIC_WRITE: - if (! $this->em->getConnection()->isTransactionActive()) { - throw TransactionRequiredException::transactionRequired(); - } - } - - $oid = spl_object_id($entity); - - if (isset($visited[$oid])) { - return; // Prevent infinite recursion - } - - $visited[$oid] = $entity; // mark visited - - $class = $this->em->getClassMetadata($entity::class); - - if ($this->getEntityState($entity) !== self::STATE_MANAGED) { - throw ORMInvalidArgumentException::entityNotManaged($entity); - } - - $this->getEntityPersister($class->name)->refresh( - array_combine($class->getIdentifierFieldNames(), $this->entityIdentifiers[$oid]), - $entity, - $lockMode, - ); - - $this->cascadeRefresh($entity, $visited, $lockMode); - } - - /** - * Cascades a refresh operation to associated entities. - * - * @psalm-param array $visited - * @psalm-param LockMode::*|null $lockMode - */ - private function cascadeRefresh(object $entity, array &$visited, LockMode|int|null $lockMode = null): void - { - $class = $this->em->getClassMetadata($entity::class); - - $associationMappings = array_filter( - $class->associationMappings, - static fn (AssociationMapping $assoc): bool => $assoc->isCascadeRefresh() - ); - - foreach ($associationMappings as $assoc) { - $relatedEntities = $class->reflFields[$assoc->fieldName]->getValue($entity); - - switch (true) { - case $relatedEntities instanceof PersistentCollection: - // Unwrap so that foreach() does not initialize - $relatedEntities = $relatedEntities->unwrap(); - // break; is commented intentionally! - - case $relatedEntities instanceof Collection: - case is_array($relatedEntities): - foreach ($relatedEntities as $relatedEntity) { - $this->doRefresh($relatedEntity, $visited, $lockMode); - } - - break; - - case $relatedEntities !== null: - $this->doRefresh($relatedEntities, $visited, $lockMode); - break; - - default: - // Do nothing - } - } - } - - /** - * Cascades a detach operation to associated entities. - * - * @param array $visited - */ - private function cascadeDetach(object $entity, array &$visited): void - { - $class = $this->em->getClassMetadata($entity::class); - - $associationMappings = array_filter( - $class->associationMappings, - static fn (AssociationMapping $assoc): bool => $assoc->isCascadeDetach() - ); - - foreach ($associationMappings as $assoc) { - $relatedEntities = $class->reflFields[$assoc->fieldName]->getValue($entity); - - switch (true) { - case $relatedEntities instanceof PersistentCollection: - // Unwrap so that foreach() does not initialize - $relatedEntities = $relatedEntities->unwrap(); - // break; is commented intentionally! - - case $relatedEntities instanceof Collection: - case is_array($relatedEntities): - foreach ($relatedEntities as $relatedEntity) { - $this->doDetach($relatedEntity, $visited); - } - - break; - - case $relatedEntities !== null: - $this->doDetach($relatedEntities, $visited); - break; - - default: - // Do nothing - } - } - } - - /** - * Cascades the save operation to associated entities. - * - * @psalm-param array $visited - */ - private function cascadePersist(object $entity, array &$visited): void - { - if ($this->isUninitializedObject($entity)) { - // nothing to do - proxy is not initialized, therefore we don't do anything with it - return; - } - - $class = $this->em->getClassMetadata($entity::class); - - $associationMappings = array_filter( - $class->associationMappings, - static fn (AssociationMapping $assoc): bool => $assoc->isCascadePersist() - ); - - foreach ($associationMappings as $assoc) { - $relatedEntities = $class->reflFields[$assoc->fieldName]->getValue($entity); - - switch (true) { - case $relatedEntities instanceof PersistentCollection: - // Unwrap so that foreach() does not initialize - $relatedEntities = $relatedEntities->unwrap(); - // break; is commented intentionally! - - case $relatedEntities instanceof Collection: - case is_array($relatedEntities): - if ($assoc->isToMany() <= 0) { - throw ORMInvalidArgumentException::invalidAssociation( - $this->em->getClassMetadata($assoc->targetEntity), - $assoc, - $relatedEntities, - ); - } - - foreach ($relatedEntities as $relatedEntity) { - $this->doPersist($relatedEntity, $visited); - } - - break; - - case $relatedEntities !== null: - if (! $relatedEntities instanceof $assoc->targetEntity) { - throw ORMInvalidArgumentException::invalidAssociation( - $this->em->getClassMetadata($assoc->targetEntity), - $assoc, - $relatedEntities, - ); - } - - $this->doPersist($relatedEntities, $visited); - break; - - default: - // Do nothing - } - } - } - - /** - * Cascades the delete operation to associated entities. - * - * @psalm-param array $visited - */ - private function cascadeRemove(object $entity, array &$visited): void - { - $class = $this->em->getClassMetadata($entity::class); - - $associationMappings = array_filter( - $class->associationMappings, - static fn (AssociationMapping $assoc): bool => $assoc->isCascadeRemove() - ); - - if ($associationMappings) { - $this->initializeObject($entity); - } - - $entitiesToCascade = []; - - foreach ($associationMappings as $assoc) { - $relatedEntities = $class->reflFields[$assoc->fieldName]->getValue($entity); - - switch (true) { - case $relatedEntities instanceof Collection: - case is_array($relatedEntities): - // If its a PersistentCollection initialization is intended! No unwrap! - foreach ($relatedEntities as $relatedEntity) { - $entitiesToCascade[] = $relatedEntity; - } - - break; - - case $relatedEntities !== null: - $entitiesToCascade[] = $relatedEntities; - break; - - default: - // Do nothing - } - } - - foreach ($entitiesToCascade as $relatedEntity) { - $this->doRemove($relatedEntity, $visited); - } - } - - /** - * Acquire a lock on the given entity. - * - * @psalm-param LockMode::* $lockMode - * - * @throws ORMInvalidArgumentException - * @throws TransactionRequiredException - * @throws OptimisticLockException - */ - public function lock(object $entity, LockMode|int $lockMode, DateTimeInterface|int|null $lockVersion = null): void - { - if ($this->getEntityState($entity, self::STATE_DETACHED) !== self::STATE_MANAGED) { - throw ORMInvalidArgumentException::entityNotManaged($entity); - } - - $class = $this->em->getClassMetadata($entity::class); - - switch (true) { - case $lockMode === LockMode::OPTIMISTIC: - if (! $class->isVersioned) { - throw OptimisticLockException::notVersioned($class->name); - } - - if ($lockVersion === null) { - return; - } - - $this->initializeObject($entity); - - assert($class->versionField !== null); - $entityVersion = $class->reflFields[$class->versionField]->getValue($entity); - - // phpcs:ignore SlevomatCodingStandard.Operators.DisallowEqualOperators.DisallowedNotEqualOperator - if ($entityVersion != $lockVersion) { - throw OptimisticLockException::lockFailedVersionMismatch($entity, $lockVersion, $entityVersion); - } - - break; - - case $lockMode === LockMode::NONE: - case $lockMode === LockMode::PESSIMISTIC_READ: - case $lockMode === LockMode::PESSIMISTIC_WRITE: - if (! $this->em->getConnection()->isTransactionActive()) { - throw TransactionRequiredException::transactionRequired(); - } - - $oid = spl_object_id($entity); - - $this->getEntityPersister($class->name)->lock( - array_combine($class->getIdentifierFieldNames(), $this->entityIdentifiers[$oid]), - $lockMode, - ); - break; - - default: - // Do nothing - } - } - - /** - * Clears the UnitOfWork. - */ - public function clear(): void - { - $this->identityMap = - $this->entityIdentifiers = - $this->originalEntityData = - $this->entityChangeSets = - $this->entityStates = - $this->scheduledForSynchronization = - $this->entityInsertions = - $this->entityUpdates = - $this->entityDeletions = - $this->nonCascadedNewDetectedEntities = - $this->collectionDeletions = - $this->collectionUpdates = - $this->extraUpdates = - $this->readOnlyObjects = - $this->pendingCollectionElementRemovals = - $this->visitedCollections = - $this->eagerLoadingEntities = - $this->eagerLoadingCollections = - $this->orphanRemovals = []; - - if ($this->evm->hasListeners(Events::onClear)) { - $this->evm->dispatchEvent(Events::onClear, new OnClearEventArgs($this->em)); - } - } - - /** - * INTERNAL: - * Schedules an orphaned entity for removal. The remove() operation will be - * invoked on that entity at the beginning of the next commit of this - * UnitOfWork. - * - * @ignore - */ - public function scheduleOrphanRemoval(object $entity): void - { - $this->orphanRemovals[spl_object_id($entity)] = $entity; - } - - /** - * INTERNAL: - * Cancels a previously scheduled orphan removal. - * - * @ignore - */ - public function cancelOrphanRemoval(object $entity): void - { - unset($this->orphanRemovals[spl_object_id($entity)]); - } - - /** - * INTERNAL: - * Schedules a complete collection for removal when this UnitOfWork commits. - */ - public function scheduleCollectionDeletion(PersistentCollection $coll): void - { - $coid = spl_object_id($coll); - - // TODO: if $coll is already scheduled for recreation ... what to do? - // Just remove $coll from the scheduled recreations? - unset($this->collectionUpdates[$coid]); - - $this->collectionDeletions[$coid] = $coll; - } - - public function isCollectionScheduledForDeletion(PersistentCollection $coll): bool - { - return isset($this->collectionDeletions[spl_object_id($coll)]); - } - - /** - * INTERNAL: - * Creates an entity. Used for reconstitution of persistent entities. - * - * Internal note: Highly performance-sensitive method. - * - * @param string $className The name of the entity class. - * @param mixed[] $data The data for the entity. - * @param mixed[] $hints Any hints to account for during reconstitution/lookup of the entity. - * @psalm-param class-string $className - * @psalm-param array $hints - * - * @return object The managed entity instance. - * - * @ignore - * @todo Rename: getOrCreateEntity - */ - public function createEntity(string $className, array $data, array &$hints = []): object - { - $class = $this->em->getClassMetadata($className); - - $id = $this->identifierFlattener->flattenIdentifier($class, $data); - $idHash = self::getIdHashByIdentifier($id); - - if (isset($this->identityMap[$class->rootEntityName][$idHash])) { - $entity = $this->identityMap[$class->rootEntityName][$idHash]; - $oid = spl_object_id($entity); - - if ( - isset($hints[Query::HINT_REFRESH], $hints[Query::HINT_REFRESH_ENTITY]) - ) { - $unmanagedProxy = $hints[Query::HINT_REFRESH_ENTITY]; - if ( - $unmanagedProxy !== $entity - && $this->isIdentifierEquals($unmanagedProxy, $entity) - ) { - // We will hydrate the given un-managed proxy anyway: - // continue work, but consider it the entity from now on - $entity = $unmanagedProxy; - } - } - - if ($this->isUninitializedObject($entity)) { - $entity->__setInitialized(true); - } else { - if ( - ! isset($hints[Query::HINT_REFRESH]) - || (isset($hints[Query::HINT_REFRESH_ENTITY]) && $hints[Query::HINT_REFRESH_ENTITY] !== $entity) - ) { - return $entity; - } - } - - $this->originalEntityData[$oid] = $data; - } else { - $entity = $class->newInstance(); - $oid = spl_object_id($entity); - $this->registerManaged($entity, $id, $data); - - if (isset($hints[Query::HINT_READ_ONLY])) { - $this->readOnlyObjects[$oid] = true; - } - } - - foreach ($data as $field => $value) { - if (isset($class->fieldMappings[$field])) { - $class->reflFields[$field]->setValue($entity, $value); - } - } - - // Loading the entity right here, if its in the eager loading map get rid of it there. - unset($this->eagerLoadingEntities[$class->rootEntityName][$idHash]); - - if (isset($this->eagerLoadingEntities[$class->rootEntityName]) && ! $this->eagerLoadingEntities[$class->rootEntityName]) { - unset($this->eagerLoadingEntities[$class->rootEntityName]); - } - - foreach ($class->associationMappings as $field => $assoc) { - // Check if the association is not among the fetch-joined associations already. - if (isset($hints['fetchAlias'], $hints['fetched'][$hints['fetchAlias']][$field])) { - continue; - } - - if (! isset($hints['fetchMode'][$class->name][$field])) { - $hints['fetchMode'][$class->name][$field] = $assoc->fetch; - } - - $targetClass = $this->em->getClassMetadata($assoc->targetEntity); - - switch (true) { - case $assoc->isToOne(): - if (! $assoc->isOwningSide()) { - // use the given entity association - if (isset($data[$field]) && is_object($data[$field]) && isset($this->entityStates[spl_object_id($data[$field])])) { - $this->originalEntityData[$oid][$field] = $data[$field]; - - $class->reflFields[$field]->setValue($entity, $data[$field]); - $targetClass->reflFields[$assoc->mappedBy]->setValue($data[$field], $entity); - - continue 2; - } - - // Inverse side of x-to-one can never be lazy - $class->reflFields[$field]->setValue($entity, $this->getEntityPersister($assoc->targetEntity)->loadOneToOneEntity($assoc, $entity)); - - continue 2; - } - - // use the entity association - if (isset($data[$field]) && is_object($data[$field]) && isset($this->entityStates[spl_object_id($data[$field])])) { - $class->reflFields[$field]->setValue($entity, $data[$field]); - $this->originalEntityData[$oid][$field] = $data[$field]; - - break; - } - - $associatedId = []; - - assert($assoc->isToOneOwningSide()); - // TODO: Is this even computed right in all cases of composite keys? - foreach ($assoc->targetToSourceKeyColumns as $targetColumn => $srcColumn) { - $joinColumnValue = $data[$srcColumn] ?? null; - - if ($joinColumnValue !== null) { - if ($joinColumnValue instanceof BackedEnum) { - $joinColumnValue = $joinColumnValue->value; - } - - if ($targetClass->containsForeignIdentifier) { - $associatedId[$targetClass->getFieldForColumn($targetColumn)] = $joinColumnValue; - } else { - $associatedId[$targetClass->fieldNames[$targetColumn]] = $joinColumnValue; - } - } elseif (in_array($targetClass->getFieldForColumn($targetColumn), $targetClass->identifier, true)) { - // the missing key is part of target's entity primary key - $associatedId = []; - break; - } - } - - if (! $associatedId) { - // Foreign key is NULL - $class->reflFields[$field]->setValue($entity, null); - $this->originalEntityData[$oid][$field] = null; - - break; - } - - // Foreign key is set - // Check identity map first - // FIXME: Can break easily with composite keys if join column values are in - // wrong order. The correct order is the one in ClassMetadata#identifier. - $relatedIdHash = self::getIdHashByIdentifier($associatedId); - - switch (true) { - case isset($this->identityMap[$targetClass->rootEntityName][$relatedIdHash]): - $newValue = $this->identityMap[$targetClass->rootEntityName][$relatedIdHash]; - - // If this is an uninitialized proxy, we are deferring eager loads, - // this association is marked as eager fetch, and its an uninitialized proxy (wtf!) - // then we can append this entity for eager loading! - if ( - $hints['fetchMode'][$class->name][$field] === ClassMetadata::FETCH_EAGER && - isset($hints[self::HINT_DEFEREAGERLOAD]) && - ! $targetClass->isIdentifierComposite && - $this->isUninitializedObject($newValue) - ) { - $this->eagerLoadingEntities[$targetClass->rootEntityName][$relatedIdHash] = current($associatedId); - } - - break; - - case $targetClass->subClasses: - // If it might be a subtype, it can not be lazy. There isn't even - // a way to solve this with deferred eager loading, which means putting - // an entity with subclasses at a *-to-one location is really bad! (performance-wise) - $newValue = $this->getEntityPersister($assoc->targetEntity)->loadOneToOneEntity($assoc, $entity, $associatedId); - break; - - default: - $normalizedAssociatedId = $this->normalizeIdentifier($targetClass, $associatedId); - - switch (true) { - // We are negating the condition here. Other cases will assume it is valid! - case $hints['fetchMode'][$class->name][$field] !== ClassMetadata::FETCH_EAGER: - $newValue = $this->em->getProxyFactory()->getProxy($assoc->targetEntity, $normalizedAssociatedId); - $this->registerManaged($newValue, $associatedId, []); - break; - - // Deferred eager load only works for single identifier classes - case isset($hints[self::HINT_DEFEREAGERLOAD]) && - $hints[self::HINT_DEFEREAGERLOAD] && - ! $targetClass->isIdentifierComposite: - // TODO: Is there a faster approach? - $this->eagerLoadingEntities[$targetClass->rootEntityName][$relatedIdHash] = current($normalizedAssociatedId); - - $newValue = $this->em->getProxyFactory()->getProxy($assoc->targetEntity, $normalizedAssociatedId); - $this->registerManaged($newValue, $associatedId, []); - break; - - default: - // TODO: This is very imperformant, ignore it? - $newValue = $this->em->find($assoc->targetEntity, $normalizedAssociatedId); - break; - } - } - - $this->originalEntityData[$oid][$field] = $newValue; - $class->reflFields[$field]->setValue($entity, $newValue); - - if ($assoc->inversedBy !== null && $assoc->isOneToOne() && $newValue !== null) { - $inverseAssoc = $targetClass->associationMappings[$assoc->inversedBy]; - $targetClass->reflFields[$inverseAssoc->fieldName]->setValue($newValue, $entity); - } - - break; - - default: - assert($assoc->isToMany()); - // Ignore if its a cached collection - if (isset($hints[Query::HINT_CACHE_ENABLED]) && $class->getFieldValue($entity, $field) instanceof PersistentCollection) { - break; - } - - // use the given collection - if (isset($data[$field]) && $data[$field] instanceof PersistentCollection) { - $data[$field]->setOwner($entity, $assoc); - - $class->reflFields[$field]->setValue($entity, $data[$field]); - $this->originalEntityData[$oid][$field] = $data[$field]; - - break; - } - - // Inject collection - $pColl = new PersistentCollection($this->em, $targetClass, new ArrayCollection()); - $pColl->setOwner($entity, $assoc); - $pColl->setInitialized(false); - - $reflField = $class->reflFields[$field]; - $reflField->setValue($entity, $pColl); - - if ($hints['fetchMode'][$class->name][$field] === ClassMetadata::FETCH_EAGER) { - $isIteration = isset($hints[Query::HINT_INTERNAL_ITERATION]) && $hints[Query::HINT_INTERNAL_ITERATION]; - if (! $isIteration && $assoc->isOneToMany() && ! $targetClass->isIdentifierComposite && ! $assoc->isIndexed()) { - $this->scheduleCollectionForBatchLoading($pColl, $class); - } else { - $this->loadCollection($pColl); - $pColl->takeSnapshot(); - } - } - - $this->originalEntityData[$oid][$field] = $pColl; - break; - } - } - - // defer invoking of postLoad event to hydration complete step - $this->hydrationCompleteHandler->deferPostLoadInvoking($class, $entity); - - return $entity; - } - - public function triggerEagerLoads(): void - { - if (! $this->eagerLoadingEntities && ! $this->eagerLoadingCollections) { - return; - } - - // avoid infinite recursion - $eagerLoadingEntities = $this->eagerLoadingEntities; - $this->eagerLoadingEntities = []; - - foreach ($eagerLoadingEntities as $entityName => $ids) { - if (! $ids) { - continue; - } - - $class = $this->em->getClassMetadata($entityName); - $batches = array_chunk($ids, $this->em->getConfiguration()->getEagerFetchBatchSize()); - - foreach ($batches as $batchedIds) { - $this->getEntityPersister($entityName)->loadAll( - array_combine($class->identifier, [$batchedIds]), - ); - } - } - - $eagerLoadingCollections = $this->eagerLoadingCollections; // avoid recursion - $this->eagerLoadingCollections = []; - - foreach ($eagerLoadingCollections as $group) { - $this->eagerLoadCollections($group['items'], $group['mapping']); - } - } - - /** - * Load all data into the given collections, according to the specified mapping - * - * @param PersistentCollection[] $collections - */ - private function eagerLoadCollections(array $collections, ToManyInverseSideMapping $mapping): void - { - $targetEntity = $mapping->targetEntity; - $class = $this->em->getClassMetadata($mapping->sourceEntity); - $mappedBy = $mapping->mappedBy; - - $batches = array_chunk($collections, $this->em->getConfiguration()->getEagerFetchBatchSize(), true); - - foreach ($batches as $collectionBatch) { - $entities = []; - - foreach ($collectionBatch as $collection) { - $entities[] = $collection->getOwner(); - } - - $found = $this->getEntityPersister($targetEntity)->loadAll([$mappedBy => $entities], $mapping->orderBy); - - $targetClass = $this->em->getClassMetadata($targetEntity); - $targetProperty = $targetClass->getReflectionProperty($mappedBy); - assert($targetProperty !== null); - - foreach ($found as $targetValue) { - $sourceEntity = $targetProperty->getValue($targetValue); - - if ($sourceEntity === null && isset($targetClass->associationMappings[$mappedBy]->joinColumns)) { - // case where the hydration $targetValue itself has not yet fully completed, for example - // in case a bi-directional association is being hydrated and deferring eager loading is - // not possible due to subclassing. - $data = $this->getOriginalEntityData($targetValue); - $id = []; - foreach ($targetClass->associationMappings[$mappedBy]->joinColumns as $joinColumn) { - $id[] = $data[$joinColumn->name]; - } - } else { - $id = $this->identifierFlattener->flattenIdentifier($class, $class->getIdentifierValues($sourceEntity)); - } - - $idHash = implode(' ', $id); - - if ($mapping->indexBy !== null) { - $indexByProperty = $targetClass->getReflectionProperty($mapping->indexBy); - assert($indexByProperty !== null); - $collectionBatch[$idHash]->hydrateSet($indexByProperty->getValue($targetValue), $targetValue); - } else { - $collectionBatch[$idHash]->add($targetValue); - } - } - } - - foreach ($collections as $association) { - $association->setInitialized(true); - $association->takeSnapshot(); - } - } - - /** - * Initializes (loads) an uninitialized persistent collection of an entity. - * - * @todo Maybe later move to EntityManager#initialize($proxyOrCollection). See DDC-733. - */ - public function loadCollection(PersistentCollection $collection): void - { - $assoc = $collection->getMapping(); - $persister = $this->getEntityPersister($assoc->targetEntity); - - switch ($assoc->type()) { - case ClassMetadata::ONE_TO_MANY: - $persister->loadOneToManyCollection($assoc, $collection->getOwner(), $collection); - break; - - case ClassMetadata::MANY_TO_MANY: - $persister->loadManyToManyCollection($assoc, $collection->getOwner(), $collection); - break; - } - - $collection->setInitialized(true); - } - - /** - * Schedule this collection for batch loading at the end of the UnitOfWork - */ - private function scheduleCollectionForBatchLoading(PersistentCollection $collection, ClassMetadata $sourceClass): void - { - $mapping = $collection->getMapping(); - $name = $mapping->sourceEntity . '#' . $mapping->fieldName; - - if (! isset($this->eagerLoadingCollections[$name])) { - $this->eagerLoadingCollections[$name] = [ - 'items' => [], - 'mapping' => $mapping, - ]; - } - - $owner = $collection->getOwner(); - assert($owner !== null); - - $id = $this->identifierFlattener->flattenIdentifier( - $sourceClass, - $sourceClass->getIdentifierValues($owner), - ); - $idHash = implode(' ', $id); - - $this->eagerLoadingCollections[$name]['items'][$idHash] = $collection; - } - - /** - * Gets the identity map of the UnitOfWork. - * - * @psalm-return array> - */ - public function getIdentityMap(): array - { - return $this->identityMap; - } - - /** - * Gets the original data of an entity. The original data is the data that was - * present at the time the entity was reconstituted from the database. - * - * @psalm-return array - */ - public function getOriginalEntityData(object $entity): array - { - $oid = spl_object_id($entity); - - return $this->originalEntityData[$oid] ?? []; - } - - /** - * @param mixed[] $data - * - * @ignore - */ - public function setOriginalEntityData(object $entity, array $data): void - { - $this->originalEntityData[spl_object_id($entity)] = $data; - } - - /** - * INTERNAL: - * Sets a property value of the original data array of an entity. - * - * @ignore - */ - public function setOriginalEntityProperty(int $oid, string $property, mixed $value): void - { - $this->originalEntityData[$oid][$property] = $value; - } - - /** - * Gets the identifier of an entity. - * The returned value is always an array of identifier values. If the entity - * has a composite identifier then the identifier values are in the same - * order as the identifier field names as returned by ClassMetadata#getIdentifierFieldNames(). - * - * @return mixed[] The identifier values. - */ - public function getEntityIdentifier(object $entity): array - { - return $this->entityIdentifiers[spl_object_id($entity)] - ?? throw EntityNotFoundException::noIdentifierFound(get_debug_type($entity)); - } - - /** - * Processes an entity instance to extract their identifier values. - * - * @return mixed A scalar value. - * - * @throws ORMInvalidArgumentException - */ - public function getSingleIdentifierValue(object $entity): mixed - { - $class = $this->em->getClassMetadata($entity::class); - - if ($class->isIdentifierComposite) { - throw ORMInvalidArgumentException::invalidCompositeIdentifier(); - } - - $values = $this->isInIdentityMap($entity) - ? $this->getEntityIdentifier($entity) - : $class->getIdentifierValues($entity); - - return $values[$class->identifier[0]] ?? null; - } - - /** - * Tries to find an entity with the given identifier in the identity map of - * this UnitOfWork. - * - * @param mixed $id The entity identifier to look for. - * @param string $rootClassName The name of the root class of the mapped entity hierarchy. - * @psalm-param class-string $rootClassName - * - * @return object|false Returns the entity with the specified identifier if it exists in - * this UnitOfWork, FALSE otherwise. - */ - public function tryGetById(mixed $id, string $rootClassName): object|false - { - $idHash = self::getIdHashByIdentifier((array) $id); - - return $this->identityMap[$rootClassName][$idHash] ?? false; - } - - /** - * Schedules an entity for dirty-checking at commit-time. - * - * @todo Rename: scheduleForSynchronization - */ - public function scheduleForDirtyCheck(object $entity): void - { - $rootClassName = $this->em->getClassMetadata($entity::class)->rootEntityName; - - $this->scheduledForSynchronization[$rootClassName][spl_object_id($entity)] = $entity; - } - - /** - * Checks whether the UnitOfWork has any pending insertions. - */ - public function hasPendingInsertions(): bool - { - return ! empty($this->entityInsertions); - } - - /** - * Calculates the size of the UnitOfWork. The size of the UnitOfWork is the - * number of entities in the identity map. - */ - public function size(): int - { - return array_sum(array_map('count', $this->identityMap)); - } - - /** - * Gets the EntityPersister for an Entity. - * - * @psalm-param class-string $entityName - */ - public function getEntityPersister(string $entityName): EntityPersister - { - if (isset($this->persisters[$entityName])) { - return $this->persisters[$entityName]; - } - - $class = $this->em->getClassMetadata($entityName); - - $persister = match (true) { - $class->isInheritanceTypeNone() => new BasicEntityPersister($this->em, $class), - $class->isInheritanceTypeSingleTable() => new SingleTablePersister($this->em, $class), - $class->isInheritanceTypeJoined() => new JoinedSubclassPersister($this->em, $class), - default => throw new RuntimeException('No persister found for entity.'), - }; - - if ($this->hasCache && $class->cache !== null) { - $persister = $this->em->getConfiguration() - ->getSecondLevelCacheConfiguration() - ->getCacheFactory() - ->buildCachedEntityPersister($this->em, $persister, $class); - } - - $this->persisters[$entityName] = $persister; - - return $this->persisters[$entityName]; - } - - /** Gets a collection persister for a collection-valued association. */ - public function getCollectionPersister(AssociationMapping $association): CollectionPersister - { - $role = isset($association->cache) - ? $association->sourceEntity . '::' . $association->fieldName - : $association->type(); - - if (isset($this->collectionPersisters[$role])) { - return $this->collectionPersisters[$role]; - } - - $persister = $association->type() === ClassMetadata::ONE_TO_MANY - ? new OneToManyPersister($this->em) - : new ManyToManyPersister($this->em); - - if ($this->hasCache && isset($association->cache)) { - $persister = $this->em->getConfiguration() - ->getSecondLevelCacheConfiguration() - ->getCacheFactory() - ->buildCachedCollectionPersister($this->em, $persister, $association); - } - - $this->collectionPersisters[$role] = $persister; - - return $this->collectionPersisters[$role]; - } - - /** - * INTERNAL: - * Registers an entity as managed. - * - * @param mixed[] $id The identifier values. - * @param mixed[] $data The original entity data. - */ - public function registerManaged(object $entity, array $id, array $data): void - { - $oid = spl_object_id($entity); - - $this->entityIdentifiers[$oid] = $id; - $this->entityStates[$oid] = self::STATE_MANAGED; - $this->originalEntityData[$oid] = $data; - - $this->addToIdentityMap($entity); - } - - /* PropertyChangedListener implementation */ - - /** - * Notifies this UnitOfWork of a property change in an entity. - * - * {@inheritDoc} - */ - public function propertyChanged(object $sender, string $propertyName, mixed $oldValue, mixed $newValue): void - { - $oid = spl_object_id($sender); - $class = $this->em->getClassMetadata($sender::class); - - $isAssocField = isset($class->associationMappings[$propertyName]); - - if (! $isAssocField && ! isset($class->fieldMappings[$propertyName])) { - return; // ignore non-persistent fields - } - - // Update changeset and mark entity for synchronization - $this->entityChangeSets[$oid][$propertyName] = [$oldValue, $newValue]; - - if (! isset($this->scheduledForSynchronization[$class->rootEntityName][$oid])) { - $this->scheduleForDirtyCheck($sender); - } - } - - /** - * Gets the currently scheduled entity insertions in this UnitOfWork. - * - * @psalm-return array - */ - public function getScheduledEntityInsertions(): array - { - return $this->entityInsertions; - } - - /** - * Gets the currently scheduled entity updates in this UnitOfWork. - * - * @psalm-return array - */ - public function getScheduledEntityUpdates(): array - { - return $this->entityUpdates; - } - - /** - * Gets the currently scheduled entity deletions in this UnitOfWork. - * - * @psalm-return array - */ - public function getScheduledEntityDeletions(): array - { - return $this->entityDeletions; - } - - /** - * Gets the currently scheduled complete collection deletions - * - * @psalm-return array> - */ - public function getScheduledCollectionDeletions(): array - { - return $this->collectionDeletions; - } - - /** - * Gets the currently scheduled collection inserts, updates and deletes. - * - * @psalm-return array> - */ - public function getScheduledCollectionUpdates(): array - { - return $this->collectionUpdates; - } - - /** - * Helper method to initialize a lazy loading proxy or persistent collection. - */ - public function initializeObject(object $obj): void - { - if ($obj instanceof InternalProxy) { - $obj->__load(); - - return; - } - - if ($obj instanceof PersistentCollection) { - $obj->initialize(); - } - } - - /** - * Tests if a value is an uninitialized entity. - * - * @psalm-assert-if-true InternalProxy $obj - */ - public function isUninitializedObject(mixed $obj): bool - { - return $obj instanceof InternalProxy && ! $obj->__isInitialized(); - } - - /** - * Helper method to show an object as string. - */ - private static function objToStr(object $obj): string - { - return $obj instanceof Stringable ? (string) $obj : get_debug_type($obj) . '@' . spl_object_id($obj); - } - - /** - * Marks an entity as read-only so that it will not be considered for updates during UnitOfWork#commit(). - * - * This operation cannot be undone as some parts of the UnitOfWork now keep gathering information - * on this object that might be necessary to perform a correct update. - * - * @throws ORMInvalidArgumentException - */ - public function markReadOnly(object $object): void - { - if (! $this->isInIdentityMap($object)) { - throw ORMInvalidArgumentException::readOnlyRequiresManagedEntity($object); - } - - $this->readOnlyObjects[spl_object_id($object)] = true; - } - - /** - * Is this entity read only? - * - * @throws ORMInvalidArgumentException - */ - public function isReadOnly(object $object): bool - { - return isset($this->readOnlyObjects[spl_object_id($object)]); - } - - /** - * Perform whatever processing is encapsulated here after completion of the transaction. - */ - private function afterTransactionComplete(): void - { - $this->performCallbackOnCachedPersister(static function (CachedPersister $persister): void { - $persister->afterTransactionComplete(); - }); - } - - /** - * Perform whatever processing is encapsulated here after completion of the rolled-back. - */ - private function afterTransactionRolledBack(): void - { - $this->performCallbackOnCachedPersister(static function (CachedPersister $persister): void { - $persister->afterTransactionRolledBack(); - }); - } - - /** - * Performs an action after the transaction. - */ - private function performCallbackOnCachedPersister(callable $callback): void - { - if (! $this->hasCache) { - return; - } - - foreach ([...$this->persisters, ...$this->collectionPersisters] as $persister) { - if ($persister instanceof CachedPersister) { - $callback($persister); - } - } - } - - private function dispatchOnFlushEvent(): void - { - if ($this->evm->hasListeners(Events::onFlush)) { - $this->evm->dispatchEvent(Events::onFlush, new OnFlushEventArgs($this->em)); - } - } - - private function dispatchPostFlushEvent(): void - { - if ($this->evm->hasListeners(Events::postFlush)) { - $this->evm->dispatchEvent(Events::postFlush, new PostFlushEventArgs($this->em)); - } - } - - /** - * Verifies if two given entities actually are the same based on identifier comparison - */ - private function isIdentifierEquals(object $entity1, object $entity2): bool - { - if ($entity1 === $entity2) { - return true; - } - - $class = $this->em->getClassMetadata($entity1::class); - - if ($class !== $this->em->getClassMetadata($entity2::class)) { - return false; - } - - $oid1 = spl_object_id($entity1); - $oid2 = spl_object_id($entity2); - - $id1 = $this->entityIdentifiers[$oid1] ?? $this->identifierFlattener->flattenIdentifier($class, $class->getIdentifierValues($entity1)); - $id2 = $this->entityIdentifiers[$oid2] ?? $this->identifierFlattener->flattenIdentifier($class, $class->getIdentifierValues($entity2)); - - return $id1 === $id2 || self::getIdHashByIdentifier($id1) === self::getIdHashByIdentifier($id2); - } - - /** @throws ORMInvalidArgumentException */ - private function assertThatThereAreNoUnintentionallyNonPersistedAssociations(): void - { - $entitiesNeedingCascadePersist = array_diff_key($this->nonCascadedNewDetectedEntities, $this->entityInsertions); - - $this->nonCascadedNewDetectedEntities = []; - - if ($entitiesNeedingCascadePersist) { - throw ORMInvalidArgumentException::newEntitiesFoundThroughRelationships( - array_values($entitiesNeedingCascadePersist), - ); - } - } - - /** - * This method called by hydrators, and indicates that hydrator totally completed current hydration cycle. - * Unit of work able to fire deferred events, related to loading events here. - * - * @internal should be called internally from object hydrators - */ - public function hydrationComplete(): void - { - $this->hydrationCompleteHandler->hydrationComplete(); - } - - /** @throws MappingException if the entity has more than a single identifier. */ - private function convertSingleFieldIdentifierToPHPValue(ClassMetadata $class, mixed $identifierValue): mixed - { - return $this->em->getConnection()->convertToPHPValue( - $identifierValue, - $class->getTypeOfField($class->getSingleIdentifierFieldName()), - ); - } - - /** - * Given a flat identifier, this method will produce another flat identifier, but with all - * association fields that are mapped as identifiers replaced by entity references, recursively. - * - * @param mixed[] $flatIdentifier - * - * @return array - */ - private function normalizeIdentifier(ClassMetadata $targetClass, array $flatIdentifier): array - { - $normalizedAssociatedId = []; - - foreach ($targetClass->getIdentifierFieldNames() as $name) { - if (! array_key_exists($name, $flatIdentifier)) { - continue; - } - - if (! $targetClass->isSingleValuedAssociation($name)) { - $normalizedAssociatedId[$name] = $flatIdentifier[$name]; - continue; - } - - $targetIdMetadata = $this->em->getClassMetadata($targetClass->getAssociationTargetClass($name)); - - // Note: the ORM prevents using an entity with a composite identifier as an identifier association - // therefore, reset($targetIdMetadata->identifier) is always correct - $normalizedAssociatedId[$name] = $this->em->getReference( - $targetIdMetadata->getName(), - $this->normalizeIdentifier( - $targetIdMetadata, - [(string) reset($targetIdMetadata->identifier) => $flatIdentifier[$name]], - ), - ); - } - - return $normalizedAssociatedId; - } - - /** - * Assign a post-insert generated ID to an entity - * - * This is used by EntityPersisters after they inserted entities into the database. - * It will place the assigned ID values in the entity's fields and start tracking - * the entity in the identity map. - */ - final public function assignPostInsertId(object $entity, mixed $generatedId): void - { - $class = $this->em->getClassMetadata($entity::class); - $idField = $class->getSingleIdentifierFieldName(); - $idValue = $this->convertSingleFieldIdentifierToPHPValue($class, $generatedId); - $oid = spl_object_id($entity); - - $class->reflFields[$idField]->setValue($entity, $idValue); - - $this->entityIdentifiers[$oid] = [$idField => $idValue]; - $this->entityStates[$oid] = self::STATE_MANAGED; - $this->originalEntityData[$oid][$idField] = $idValue; - - $this->addToIdentityMap($entity); - } -} -- cgit v1.2.3