1 <?php

     2 /*

     3  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

     4  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

     5  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

     6  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

     7  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

     8  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

     9  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

    10  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

    11  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    12  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    13  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    14  *

    15  * This software consists of voluntary contributions made by many individuals

    16  * and is licensed under the LGPL. For more information, see

    17  * <http://www.doctrine-project.org>.

    18  */

    19 

    20 namespace Doctrine\ORM;

    21 

    22 use Exception, InvalidArgumentException, UnexpectedValueException,

    23     Doctrine\Common\Collections\ArrayCollection,

    24     Doctrine\Common\Collections\Collection,

    25     Doctrine\Common\NotifyPropertyChanged,

    26     Doctrine\Common\PropertyChangedListener,

    27     Doctrine\ORM\Event\LifecycleEventArgs,

    28     Doctrine\ORM\Mapping\ClassMetadata,

    29     Doctrine\ORM\Proxy\Proxy;

    30 

    31 /**

    32  * The UnitOfWork is responsible for tracking changes to objects during an

    33  * "object-level" transaction and for writing out changes to the database

    34  * in the correct order.

    35  *

    36  * @since       2.0

    37  * @author      Benjamin Eberlei <kontakt@beberlei.de>

    38  * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>

    39  * @author      Jonathan Wage <jonwage@gmail.com>

    40  * @author      Roman Borschel <roman@code-factory.org>

    41  * @internal    This class contains highly performance-sensitive code.

    42  */

    43 class UnitOfWork implements PropertyChangedListener

    44 {

    45     /**

    46      * An entity is in MANAGED state when its persistence is managed by an EntityManager.

    47      */

    48     const STATE_MANAGED = 1;

    49 

    50     /**

    51      * An entity is new if it has just been instantiated (i.e. using the "new" operator)

    52      * and is not (yet) managed by an EntityManager.

    53      */

    54     const STATE_NEW = 2;

    55 

    56     /**

    57      * A detached entity is an instance with persistent state and identity that is not

    58      * (or no longer) associated with an EntityManager (and a UnitOfWork).

    59      */

    60     const STATE_DETACHED = 3;

    61 

    62     /**

    63      * A removed entity instance is an instance with a persistent identity,

    64      * associated with an EntityManager, whose persistent state will be deleted

    65      * on commit.

    66      */

    67     const STATE_REMOVED = 4;

    68 

    69     /**

    70      * The identity map that holds references to all managed entities that have

    71      * an identity. The entities are grouped by their class name.

    72      * Since all classes in a hierarchy must share the same identifier set,

    73      * we always take the root class name of the hierarchy.

    74      *

    75      * @var array

    76      */

    77     private $identityMap = array();

    78 

    79     /**

    80      * Map of all identifiers of managed entities.

    81      * Keys are object ids (spl_object_hash).

    82      *

    83      * @var array

    84      */

    85     private $entityIdentifiers = array();

    86 

    87     /**

    88      * Map of the original entity data of managed entities.

    89      * Keys are object ids (spl_object_hash). This is used for calculating changesets

    90      * at commit time.

    91      *

    92      * @var array

    93      * @internal Note that PHPs "copy-on-write" behavior helps a lot with memory usage.

    94      *           A value will only really be copied if the value in the entity is modified

    95      *           by the user.

    96      */

    97     private $originalEntityData = array();

    98 

    99     /**

   100      * Map of entity changes. Keys are object ids (spl_object_hash).

   101      * Filled at the beginning of a commit of the UnitOfWork and cleaned at the end.

   102      *

   103      * @var array

   104      */

   105     private $entityChangeSets = array();

   106 

   107     /**

   108      * The (cached) states of any known entities.

   109      * Keys are object ids (spl_object_hash).

   110      *

   111      * @var array

   112      */

   113     private $entityStates = array();

   114 

   115     /**

   116      * Map of entities that are scheduled for dirty checking at commit time.

   117      * This is only used for entities with a change tracking policy of DEFERRED_EXPLICIT.

   118      * Keys are object ids (spl_object_hash).

   119      * 

   120      * @var array

   121      * @todo rename: scheduledForSynchronization

   122      */

   123     private $scheduledForDirtyCheck = array();

   124 

   125     /**

   126      * A list of all pending entity insertions.

   127      *

   128      * @var array

   129      */

   130     private $entityInsertions = array();

   131 

   132     /**

   133      * A list of all pending entity updates.

   134      *

   135      * @var array

   136      */

   137     private $entityUpdates = array();

   138     

   139     /**

   140      * Any pending extra updates that have been scheduled by persisters.

   141      * 

   142      * @var array

   143      */

   144     private $extraUpdates = array();

   145 

   146     /**

   147      * A list of all pending entity deletions.

   148      *

   149      * @var array

   150      */

   151     private $entityDeletions = array();

   152 

   153     /**

   154      * All pending collection deletions.

   155      *

   156      * @var array

   157      */

   158     private $collectionDeletions = array();

   159 

   160     /**

   161      * All pending collection updates.

   162      *

   163      * @var array

   164      */

   165     private $collectionUpdates = array();

   166 

   167     /**

   168      * List of collections visited during changeset calculation on a commit-phase of a UnitOfWork.

   169      * At the end of the UnitOfWork all these collections will make new snapshots

   170      * of their data.

   171      *

   172      * @var array

   173      */

   174     private $visitedCollections = array();

   175 

   176     /**

   177      * The EntityManager that "owns" this UnitOfWork instance.

   178      *

   179      * @var Doctrine\ORM\EntityManager

   180      */

   181     private $em;

   182 

   183     /**

   184      * The calculator used to calculate the order in which changes to

   185      * entities need to be written to the database.

   186      *

   187      * @var Doctrine\ORM\Internal\CommitOrderCalculator

   188      */

   189     private $commitOrderCalculator;

   190 

   191     /**

   192      * The entity persister instances used to persist entity instances.

   193      *

   194      * @var array

   195      */

   196     private $persisters = array();

   197 

   198     /**

   199      * The collection persister instances used to persist collections.

   200      *

   201      * @var array

   202      */

   203     private $collectionPersisters = array();

   204     

   205     /**

   206      * The EventManager used for dispatching events.

   207      * 

   208      * @var EventManager

   209      */

   210     private $evm;

   211     

   212     /**

   213      * Orphaned entities that are scheduled for removal.

   214      * 

   215      * @var array

   216      */

   217     private $orphanRemovals = array();

   218     

   219     //private $_readOnlyObjects = array();

   220 

   221     /**

   222      * Map of Entity Class-Names and corresponding IDs that should eager loaded when requested.

   223      * 

   224      * @var array

   225      */

   226     private $eagerLoadingEntities = array();

   227 

   228     /**

   229      * Initializes a new UnitOfWork instance, bound to the given EntityManager.

   230      *

   231      * @param Doctrine\ORM\EntityManager $em

   232      */

   233     public function __construct(EntityManager $em)

   234     {

   235         $this->em = $em;

   236         $this->evm = $em->getEventManager();

   237     }

   238 

   239     /**

   240      * Commits the UnitOfWork, executing all operations that have been postponed

   241      * up to this point. The state of all managed entities will be synchronized with

   242      * the database.

   243      * 

   244      * The operations are executed in the following order:

   245      * 

   246      * 1) All entity insertions

   247      * 2) All entity updates

   248      * 3) All collection deletions

   249      * 4) All collection updates

   250      * 5) All entity deletions

   251      * 

   252      */

   253     public function commit()

   254     {

   255         // Compute changes done since last commit.

   256         $this->computeChangeSets();

   257 

   258         if ( ! ($this->entityInsertions ||

   259                 $this->entityDeletions ||

   260                 $this->entityUpdates ||

   261                 $this->collectionUpdates ||

   262                 $this->collectionDeletions ||

   263                 $this->orphanRemovals)) {

   264             return; // Nothing to do.

   265         }

   266 

   267         if ($this->orphanRemovals) {

   268             foreach ($this->orphanRemovals as $orphan) {

   269                 $this->remove($orphan);

   270             }

   271         }

   272         

   273         // Raise onFlush

   274         if ($this->evm->hasListeners(Events::onFlush)) {

   275             $this->evm->dispatchEvent(Events::onFlush, new Event\OnFlushEventArgs($this->em));

   276         }

   277         

   278         // Now we need a commit order to maintain referential integrity

   279         $commitOrder = $this->getCommitOrder();

   280 

   281         $conn = $this->em->getConnection();

   282 

   283         $conn->beginTransaction();

   284         try {

   285             if ($this->entityInsertions) {

   286                 foreach ($commitOrder as $class) {

   287                     $this->executeInserts($class);

   288                 }

   289             }

   290 

   291             if ($this->entityUpdates) {

   292                 foreach ($commitOrder as $class) {

   293                     $this->executeUpdates($class);

   294                 }

   295             }

   296 

   297             // Extra updates that were requested by persisters.

   298             if ($this->extraUpdates) {

   299                 $this->executeExtraUpdates();

   300             }

   301 

   302             // Collection deletions (deletions of complete collections)

   303             foreach ($this->collectionDeletions as $collectionToDelete) {

   304                 $this->getCollectionPersister($collectionToDelete->getMapping())

   305                         ->delete($collectionToDelete);

   306             }

   307             // Collection updates (deleteRows, updateRows, insertRows)

   308             foreach ($this->collectionUpdates as $collectionToUpdate) {

   309                 $this->getCollectionPersister($collectionToUpdate->getMapping())

   310                         ->update($collectionToUpdate);

   311             }

   312 

   313             // Entity deletions come last and need to be in reverse commit order

   314             if ($this->entityDeletions) {

   315                 for ($count = count($commitOrder), $i = $count - 1; $i >= 0; --$i) {

   316                     $this->executeDeletions($commitOrder[$i]);

   317                 }

   318             }

   319 

   320             $conn->commit();

   321         } catch (Exception $e) {

   322             $this->em->close();

   323             $conn->rollback();

   324             throw $e;

   325         }

   326 

   327         // Take new snapshots from visited collections

   328         foreach ($this->visitedCollections as $coll) {

   329             $coll->takeSnapshot();

   330         }

   331 

   332         // Clear up

   333         $this->entityInsertions =

   334         $this->entityUpdates =

   335         $this->entityDeletions =

   336         $this->extraUpdates =

   337         $this->entityChangeSets =

   338         $this->collectionUpdates =

   339         $this->collectionDeletions =

   340         $this->visitedCollections =

   341         $this->scheduledForDirtyCheck =

   342         $this->orphanRemovals = array();

   343     }

   344     

   345     /**

   346      * Executes any extra updates that have been scheduled.

   347      */

   348     private function executeExtraUpdates()

   349     {

   350         foreach ($this->extraUpdates as $oid => $update) {

   351             list ($entity, $changeset) = $update;

   352             $this->entityChangeSets[$oid] = $changeset;

   353             $this->getEntityPersister(get_class($entity))->update($entity);

   354         }

   355     }

   356 

   357     /**

   358      * Gets the changeset for an entity.

   359      *

   360      * @return array

   361      */

   362     public function getEntityChangeSet($entity)

   363     {

   364         $oid = spl_object_hash($entity);

   365         if (isset($this->entityChangeSets[$oid])) {

   366             return $this->entityChangeSets[$oid];

   367         }

   368         return array();

   369     }

   370 

   371     /**

   372      * Computes the changes that happened to a single entity.

   373      *

   374      * Modifies/populates the following properties:

   375      *

   376      * {@link _originalEntityData}

   377      * If the entity is NEW or MANAGED but not yet fully persisted (only has an id)

   378      * then it was not fetched from the database and therefore we have no original

   379      * entity data yet. All of the current entity data is stored as the original entity data.

   380      *

   381      * {@link _entityChangeSets}

   382      * The changes detected on all properties of the entity are stored there.

   383      * A change is a tuple array where the first entry is the old value and the second

   384      * entry is the new value of the property. Changesets are used by persisters

   385      * to INSERT/UPDATE the persistent entity state.

   386      *

   387      * {@link _entityUpdates}

   388      * If the entity is already fully MANAGED (has been fetched from the database before)

   389      * and any changes to its properties are detected, then a reference to the entity is stored

   390      * there to mark it for an update.

   391      *

   392      * {@link _collectionDeletions}

   393      * If a PersistentCollection has been de-referenced in a fully MANAGED entity,

   394      * then this collection is marked for deletion.

   395      *

   396      * @param ClassMetadata $class The class descriptor of the entity.

   397      * @param object $entity The entity for which to compute the changes.

   398      */

   399     public function computeChangeSet(ClassMetadata $class, $entity)

   400     {

   401         if ( ! $class->isInheritanceTypeNone()) {

   402             $class = $this->em->getClassMetadata(get_class($entity));

   403         }

   404         

   405         $oid = spl_object_hash($entity);

   406         $actualData = array();

   407         foreach ($class->reflFields as $name => $refProp) {

   408             $value = $refProp->getValue($entity);

   409             if (isset($class->associationMappings[$name])

   410                     && ($class->associationMappings[$name]['type'] & ClassMetadata::TO_MANY)

   411                     && $value !== null

   412                     && ! ($value instanceof PersistentCollection)) {

   413 

   414                 // If $value is not a Collection then use an ArrayCollection.

   415                 if ( ! $value instanceof Collection) {

   416                     $value = new ArrayCollection($value);

   417                 }

   418                 

   419                 $assoc = $class->associationMappings[$name];

   420                 

   421                 // Inject PersistentCollection

   422                 $coll = new PersistentCollection(

   423                     $this->em,

   424                     $this->em->getClassMetadata($assoc['targetEntity']),

   425                     $value

   426                 );

   427                 

   428                 $coll->setOwner($entity, $assoc);

   429                 $coll->setDirty( ! $coll->isEmpty());

   430                 $class->reflFields[$name]->setValue($entity, $coll);

   431                 $actualData[$name] = $coll;

   432             } else if ( (! $class->isIdentifier($name) || ! $class->isIdGeneratorIdentity()) && ($name !== $class->versionField) ) {

   433                 $actualData[$name] = $value;

   434             }

   435         }

   436 

   437         if ( ! isset($this->originalEntityData[$oid])) {

   438             // Entity is either NEW or MANAGED but not yet fully persisted (only has an id).

   439             // These result in an INSERT.

   440             $this->originalEntityData[$oid] = $actualData;

   441             $changeSet = array();

   442             foreach ($actualData as $propName => $actualValue) {

   443                 if (isset($class->associationMappings[$propName])) {

   444                     $assoc = $class->associationMappings[$propName];

   445                     if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {

   446                         $changeSet[$propName] = array(null, $actualValue);

   447                     }

   448                 } else {

   449                     $changeSet[$propName] = array(null, $actualValue);

   450                 }

   451             }

   452             $this->entityChangeSets[$oid] = $changeSet;

   453         } else {

   454             // Entity is "fully" MANAGED: it was already fully persisted before

   455             // and we have a copy of the original data

   456             $originalData = $this->originalEntityData[$oid];

   457             $isChangeTrackingNotify = $class->isChangeTrackingNotify();

   458             $changeSet = ($isChangeTrackingNotify && isset($this->entityChangeSets[$oid])) ? $this->entityChangeSets[$oid] : array();

   459 

   460             foreach ($actualData as $propName => $actualValue) {

   461                 $orgValue = isset($originalData[$propName]) ? $originalData[$propName] : null;

   462                 if (isset($class->associationMappings[$propName])) {

   463                     $assoc = $class->associationMappings[$propName];

   464                     if ($assoc['type'] & ClassMetadata::TO_ONE && $orgValue !== $actualValue) {

   465                         if ($assoc['isOwningSide']) {

   466                             $changeSet[$propName] = array($orgValue, $actualValue);

   467                         }

   468                         if ($orgValue !== null && $assoc['orphanRemoval']) {

   469                             $this->scheduleOrphanRemoval($orgValue);

   470                         }

   471                     } else if ($orgValue instanceof PersistentCollection && $orgValue !== $actualValue) {

   472                         // A PersistentCollection was de-referenced, so delete it.

   473                         if  ( ! in_array($orgValue, $this->collectionDeletions, true)) {

   474                             $this->collectionDeletions[] = $orgValue;

   475                             $changeSet[$propName] = $orgValue; // Signal changeset, to-many assocs will be ignored.

   476                         }

   477                     }

   478                 } else if ($isChangeTrackingNotify) {

   479                     continue;

   480                 } else if ($orgValue !== $actualValue) {

   481                     $changeSet[$propName] = array($orgValue, $actualValue);

   482                 }

   483             }

   484             if ($changeSet) {

   485                 $this->entityChangeSets[$oid] = $changeSet;

   486                 $this->originalEntityData[$oid] = $actualData;

   487                 $this->entityUpdates[$oid] = $entity;

   488             }

   489         }

   490 

   491         // Look for changes in associations of the entity

   492         foreach ($class->associationMappings as $field => $assoc) {

   493             $val = $class->reflFields[$field]->getValue($entity);

   494             if ($val !== null) {

   495                 $this->computeAssociationChanges($assoc, $val);

   496             }

   497         }

   498     }

   499 

   500     /**

   501      * Computes all the changes that have been done to entities and collections

   502      * since the last commit and stores these changes in the _entityChangeSet map

   503      * temporarily for access by the persisters, until the UoW commit is finished.

   504      */

   505     public function computeChangeSets()

   506     {

   507         // Compute changes for INSERTed entities first. This must always happen.

   508         foreach ($this->entityInsertions as $entity) {

   509             $class = $this->em->getClassMetadata(get_class($entity));

   510             $this->computeChangeSet($class, $entity);

   511         }

   512 

   513         // Compute changes for other MANAGED entities. Change tracking policies take effect here.

   514         foreach ($this->identityMap as $className => $entities) {

   515             $class = $this->em->getClassMetadata($className);

   516 

   517             // Skip class if instances are read-only

   518             if ($class->isReadOnly) {

   519                 continue;

   520             }

   521 

   522             // If change tracking is explicit or happens through notification, then only compute

   523             // changes on entities of that type that are explicitly marked for synchronization.

   524             $entitiesToProcess = ! $class->isChangeTrackingDeferredImplicit() ?

   525                     (isset($this->scheduledForDirtyCheck[$className]) ?

   526                         $this->scheduledForDirtyCheck[$className] : array())

   527                     : $entities;

   528 

   529             foreach ($entitiesToProcess as $entity) {

   530                 // Ignore uninitialized proxy objects

   531                 if (/* $entity is readOnly || */ $entity instanceof Proxy && ! $entity->__isInitialized__) {

   532                     continue;

   533                 }

   534                 // Only MANAGED entities that are NOT SCHEDULED FOR INSERTION are processed here.

   535                 $oid = spl_object_hash($entity);

   536                 if ( ! isset($this->entityInsertions[$oid]) && isset($this->entityStates[$oid])) {

   537                     $this->computeChangeSet($class, $entity);

   538                 }

   539             }

   540         }

   541     }

   542 

   543     /**

   544      * Computes the changes of an association.

   545      *

   546      * @param AssociationMapping $assoc

   547      * @param mixed $value The value of the association.

   548      */

   549     private function computeAssociationChanges($assoc, $value)

   550     {

   551         if ($value instanceof PersistentCollection && $value->isDirty()) {

   552             if ($assoc['isOwningSide']) {

   553                 $this->collectionUpdates[] = $value;

   554             }

   555             $this->visitedCollections[] = $value;

   556         }

   557 

   558         // Look through the entities, and in any of their associations, for transient (new)

   559         // enities, recursively. ("Persistence by reachability")

   560         if ($assoc['type'] & ClassMetadata::TO_ONE) {

   561             if ($value instanceof Proxy && ! $value->__isInitialized__) {

   562                 return; // Ignore uninitialized proxy objects

   563             }

   564             $value = array($value);

   565         } else if ($value instanceof PersistentCollection) {

   566             // Unwrap. Uninitialized collections will simply be empty.

   567             $value = $value->unwrap();

   568         }

   569 

   570         $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);

   571         foreach ($value as $entry) {

   572             $state = $this->getEntityState($entry, self::STATE_NEW);

   573             $oid = spl_object_hash($entry);

   574             if ($state == self::STATE_NEW) {

   575                 if ( ! $assoc['isCascadePersist']) {

   576                     throw new InvalidArgumentException("A new entity was found through the relationship '"

   577                             . $assoc['sourceEntity'] . "#" . $assoc['fieldName'] . "' that was not"

   578                             . " configured to cascade persist operations for entity: " . self::objToStr($entry) . "."

   579                             . " Explicitly persist the new entity or configure cascading persist operations"

   580                             . " on the relationship. If you cannot find out which entity causes the problem"

   581                             . " implement '" . $assoc['targetEntity'] . "#__toString()' to get a clue.");

   582                 }

   583                 $this->persistNew($targetClass, $entry);

   584                 $this->computeChangeSet($targetClass, $entry);

   585             } else if ($state == self::STATE_REMOVED) {

   586                 return new InvalidArgumentException("Removed entity detected during flush: "

   587                         . self::objToStr($entry).". Remove deleted entities from associations.");

   588             } else if ($state == self::STATE_DETACHED) {

   589                 // Can actually not happen right now as we assume STATE_NEW,

   590                 // so the exception will be raised from the DBAL layer (constraint violation).

   591                 throw new InvalidArgumentException("A detached entity was found through a "

   592                         . "relationship during cascading a persist operation.");

   593             }

   594             // MANAGED associated entities are already taken into account

   595             // during changeset calculation anyway, since they are in the identity map.

   596         }

   597     }

   598 

   599     private function persistNew($class, $entity)

   600     {

   601         $oid = spl_object_hash($entity);

   602         if (isset($class->lifecycleCallbacks[Events::prePersist])) {

   603             $class->invokeLifecycleCallbacks(Events::prePersist, $entity);

   604         }

   605         if ($this->evm->hasListeners(Events::prePersist)) {

   606             $this->evm->dispatchEvent(Events::prePersist, new LifecycleEventArgs($entity, $this->em));

   607         }

   608 

   609         $idGen = $class->idGenerator;

   610         if ( ! $idGen->isPostInsertGenerator()) {

   611             $idValue = $idGen->generate($this->em, $entity);

   612             if ( ! $idGen instanceof \Doctrine\ORM\Id\AssignedGenerator) {

   613                 $this->entityIdentifiers[$oid] = array($class->identifier[0] => $idValue);

   614                 $class->setIdentifierValues($entity, $this->entityIdentifiers[$oid]);

   615             } else {

   616                 $this->entityIdentifiers[$oid] = $idValue;

   617             }

   618         }

   619         $this->entityStates[$oid] = self::STATE_MANAGED;

   620 

   621         $this->scheduleForInsert($entity);

   622     }

   623     

   624     /**

   625      * INTERNAL:

   626      * Computes the changeset of an individual entity, independently of the

   627      * computeChangeSets() routine that is used at the beginning of a UnitOfWork#commit().

   628      * 

   629      * The passed entity must be a managed entity. If the entity already has a change set

   630      * because this method is invoked during a commit cycle then the change sets are added.

   631      * whereby changes detected in this method prevail.

   632      * 

   633      * @ignore

   634      * @param ClassMetadata $class The class descriptor of the entity.

   635      * @param object $entity The entity for which to (re)calculate the change set.

   636      * @throws InvalidArgumentException If the passed entity is not MANAGED.

   637      */

   638     public function recomputeSingleEntityChangeSet($class, $entity)

   639     {

   640         $oid = spl_object_hash($entity);

   641         

   642         if ( ! isset($this->entityStates[$oid]) || $this->entityStates[$oid] != self::STATE_MANAGED) {

   643             throw new InvalidArgumentException('Entity must be managed.');

   644         }

   645         

   646         /* TODO: Just return if changetracking policy is NOTIFY?

   647         if ($class->isChangeTrackingNotify()) {

   648             return;

   649         }*/

   650 

   651         if ( ! $class->isInheritanceTypeNone()) {

   652             $class = $this->em->getClassMetadata(get_class($entity));

   653         }

   654 

   655         $actualData = array();

   656         foreach ($class->reflFields as $name => $refProp) {

   657             if ( ! $class->isIdentifier($name) || ! $class->isIdGeneratorIdentity()) {

   658                 $actualData[$name] = $refProp->getValue($entity);

   659             }

   660         }

   661 

   662         $originalData = $this->originalEntityData[$oid];

   663         $changeSet = array();

   664 

   665         foreach ($actualData as $propName => $actualValue) {

   666             $orgValue = isset($originalData[$propName]) ? $originalData[$propName] : null;

   667             if (is_object($orgValue) && $orgValue !== $actualValue) {

   668                 $changeSet[$propName] = array($orgValue, $actualValue);

   669             } else if ($orgValue != $actualValue || ($orgValue === null ^ $actualValue === null)) {

   670                 $changeSet[$propName] = array($orgValue, $actualValue);

   671             }

   672         }

   673 

   674         if ($changeSet) {

   675             if (isset($this->entityChangeSets[$oid])) {

   676                 $this->entityChangeSets[$oid] = array_merge($this->entityChangeSets[$oid], $changeSet);

   677             }

   678             $this->originalEntityData[$oid] = $actualData;

   679         }

   680     }

   681 

   682     /**

   683      * Executes all entity insertions for entities of the specified type.

   684      *

   685      * @param Doctrine\ORM\Mapping\ClassMetadata $class

   686      */

   687     private function executeInserts($class)

   688     {

   689         $className = $class->name;

   690         $persister = $this->getEntityPersister($className);

   691         

   692         $hasLifecycleCallbacks = isset($class->lifecycleCallbacks[Events::postPersist]);

   693         $hasListeners = $this->evm->hasListeners(Events::postPersist);

   694         if ($hasLifecycleCallbacks || $hasListeners) {

   695             $entities = array();

   696         }

   697         

   698         foreach ($this->entityInsertions as $oid => $entity) {

   699             if (get_class($entity) === $className) {

   700                 $persister->addInsert($entity);

   701                 unset($this->entityInsertions[$oid]);

   702                 if ($hasLifecycleCallbacks || $hasListeners) {

   703                     $entities[] = $entity;

   704                 }

   705             }

   706         }

   707 

   708         $postInsertIds = $persister->executeInserts();

   709 

   710         if ($postInsertIds) {

   711             // Persister returned post-insert IDs

   712             foreach ($postInsertIds as $id => $entity) {

   713                 $oid = spl_object_hash($entity);

   714                 $idField = $class->identifier[0];

   715                 $class->reflFields[$idField]->setValue($entity, $id);

   716                 $this->entityIdentifiers[$oid] = array($idField => $id);

   717                 $this->entityStates[$oid] = self::STATE_MANAGED;

   718                 $this->originalEntityData[$oid][$idField] = $id;

   719                 $this->addToIdentityMap($entity);

   720             }

   721         }

   722         

   723         if ($hasLifecycleCallbacks || $hasListeners) {

   724             foreach ($entities as $entity) {

   725                 if ($hasLifecycleCallbacks) {

   726                     $class->invokeLifecycleCallbacks(Events::postPersist, $entity);

   727                 }

   728                 if ($hasListeners) {

   729                     $this->evm->dispatchEvent(Events::postPersist, new LifecycleEventArgs($entity, $this->em));

   730                 }

   731             }

   732         }

   733     }

   734 

   735     /**

   736      * Executes all entity updates for entities of the specified type.

   737      *

   738      * @param Doctrine\ORM\Mapping\ClassMetadata $class

   739      */

   740     private function executeUpdates($class)

   741     {

   742         $className = $class->name;

   743         $persister = $this->getEntityPersister($className);

   744 

   745         $hasPreUpdateLifecycleCallbacks = isset($class->lifecycleCallbacks[Events::preUpdate]);

   746         $hasPreUpdateListeners = $this->evm->hasListeners(Events::preUpdate);

   747         $hasPostUpdateLifecycleCallbacks = isset($class->lifecycleCallbacks[Events::postUpdate]);

   748         $hasPostUpdateListeners = $this->evm->hasListeners(Events::postUpdate);

   749         

   750         foreach ($this->entityUpdates as $oid => $entity) {

   751             if (get_class($entity) == $className || $entity instanceof Proxy && get_parent_class($entity) == $className) {

   752                 

   753                 if ($hasPreUpdateLifecycleCallbacks) {

   754                     $class->invokeLifecycleCallbacks(Events::preUpdate, $entity);

   755                     $this->recomputeSingleEntityChangeSet($class, $entity);

   756                 }

   757                 

   758                 if ($hasPreUpdateListeners) {

   759                     $this->evm->dispatchEvent(Events::preUpdate, new Event\PreUpdateEventArgs(

   760                         $entity, $this->em, $this->entityChangeSets[$oid])

   761                     );

   762                 }

   763 

   764                 if ($this->entityChangeSets[$oid]) {

   765                     $persister->update($entity);

   766                 }

   767                 unset($this->entityUpdates[$oid]);

   768                 

   769                 if ($hasPostUpdateLifecycleCallbacks) {

   770                     $class->invokeLifecycleCallbacks(Events::postUpdate, $entity);

   771                 }

   772                 if ($hasPostUpdateListeners) {

   773                     $this->evm->dispatchEvent(Events::postUpdate, new LifecycleEventArgs($entity, $this->em));

   774                 }

   775             }

   776         }

   777     }

   778 

   779     /**

   780      * Executes all entity deletions for entities of the specified type.

   781      *

   782      * @param Doctrine\ORM\Mapping\ClassMetadata $class

   783      */

   784     private function executeDeletions($class)

   785     {

   786         $className = $class->name;

   787         $persister = $this->getEntityPersister($className);

   788                 

   789         $hasLifecycleCallbacks = isset($class->lifecycleCallbacks[Events::postRemove]);

   790         $hasListeners = $this->evm->hasListeners(Events::postRemove);

   791         

   792         foreach ($this->entityDeletions as $oid => $entity) {

   793             if (get_class($entity) == $className || $entity instanceof Proxy && get_parent_class($entity) == $className) {

   794                 $persister->delete($entity);

   795                 unset(

   796                     $this->entityDeletions[$oid],

   797                     $this->entityIdentifiers[$oid],

   798                     $this->originalEntityData[$oid],

   799                     $this->entityStates[$oid]

   800                     );

   801                 // Entity with this $oid after deletion treated as NEW, even if the $oid

   802                 // is obtained by a new entity because the old one went out of scope.

   803                 //$this->entityStates[$oid] = self::STATE_NEW;

   804                 if ( ! $class->isIdentifierNatural()) {

   805                     $class->reflFields[$class->identifier[0]]->setValue($entity, null);

   806                 }

   807 

   808                 if ($hasLifecycleCallbacks) {

   809                     $class->invokeLifecycleCallbacks(Events::postRemove, $entity);

   810                 }

   811                 if ($hasListeners) {

   812                     $this->evm->dispatchEvent(Events::postRemove, new LifecycleEventArgs($entity, $this->em));

   813                 }

   814             }

   815         }

   816     }

   817 

   818     /**

   819      * Gets the commit order.

   820      *

   821      * @return array

   822      */

   823     private function getCommitOrder(array $entityChangeSet = null)

   824     {

   825         if ($entityChangeSet === null) {

   826             $entityChangeSet = array_merge(

   827                     $this->entityInsertions,

   828                     $this->entityUpdates,

   829                     $this->entityDeletions

   830                     );

   831         }

   832         

   833         $calc = $this->getCommitOrderCalculator();

   834         

   835         // See if there are any new classes in the changeset, that are not in the

   836         // commit order graph yet (dont have a node).

   837         $newNodes = array();

   838         foreach ($entityChangeSet as $oid => $entity) {

   839             $className = get_class($entity);         

   840             if ( ! $calc->hasClass($className)) {

   841                 $class = $this->em->getClassMetadata($className);

   842                 $calc->addClass($class);

   843                 $newNodes[] = $class;

   844             }

   845         }

   846 

   847         // Calculate dependencies for new nodes

   848         foreach ($newNodes as $class) {

   849             foreach ($class->associationMappings as $assoc) {

   850                 if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {

   851                     $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);

   852                     if ( ! $calc->hasClass($targetClass->name)) {

   853                         $calc->addClass($targetClass);

   854                     }

   855                     $calc->addDependency($targetClass, $class);

   856                     // If the target class has mapped subclasses,

   857                     // these share the same dependency.

   858                     if ($targetClass->subClasses) {

   859                         foreach ($targetClass->subClasses as $subClassName) {

   860                             $targetSubClass = $this->em->getClassMetadata($subClassName);

   861                             if ( ! $calc->hasClass($subClassName)) {

   862                                 $calc->addClass($targetSubClass);

   863                             }

   864                             $calc->addDependency($targetSubClass, $class);

   865                         }

   866                     }

   867                 }

   868             }

   869         }

   870 

   871         return $calc->getCommitOrder();

   872     }

   873 

   874     /**

   875      * Schedules an entity for insertion into the database.

   876      * If the entity already has an identifier, it will be added to the identity map.

   877      *

   878      * @param object $entity The entity to schedule for insertion.

   879      */

   880     public function scheduleForInsert($entity)

   881     {

   882         $oid = spl_object_hash($entity);

   883 

   884         if (isset($this->entityUpdates[$oid])) {

   885             throw new InvalidArgumentException("Dirty entity can not be scheduled for insertion.");

   886         }

   887         if (isset($this->entityDeletions[$oid])) {

   888             throw new InvalidArgumentException("Removed entity can not be scheduled for insertion.");

   889         }

   890         if (isset($this->entityInsertions[$oid])) {

   891             throw new InvalidArgumentException("Entity can not be scheduled for insertion twice.");

   892         }

   893 

   894         $this->entityInsertions[$oid] = $entity;

   895 

   896         if (isset($this->entityIdentifiers[$oid])) {

   897             $this->addToIdentityMap($entity);

   898         }

   899     }

   900 

   901     /**

   902      * Checks whether an entity is scheduled for insertion.

   903      *

   904      * @param object $entity

   905      * @return boolean

   906      */

   907     public function isScheduledForInsert($entity)

   908     {

   909         return isset($this->entityInsertions[spl_object_hash($entity)]);

   910     }

   911 

   912     /**

   913      * Schedules an entity for being updated.

   914      *

   915      * @param object $entity The entity to schedule for being updated.

   916      */

   917     public function scheduleForUpdate($entity)

   918     {

   919         $oid = spl_object_hash($entity);

   920         if ( ! isset($this->entityIdentifiers[$oid])) {

   921             throw new InvalidArgumentException("Entity has no identity.");

   922         }

   923         if (isset($this->entityDeletions[$oid])) {

   924             throw new InvalidArgumentException("Entity is removed.");

   925         }

   926 

   927         if ( ! isset($this->entityUpdates[$oid]) && ! isset($this->entityInsertions[$oid])) {

   928             $this->entityUpdates[$oid] = $entity;

   929         }

   930     }

   931     

   932     /**

   933      * INTERNAL:

   934      * Schedules an extra update that will be executed immediately after the

   935      * regular entity updates within the currently running commit cycle.

   936      * 

   937      * Extra updates for entities are stored as (entity, changeset) tuples.

   938      * 

   939      * @ignore

   940      * @param object $entity The entity for which to schedule an extra update.

   941      * @param array $changeset The changeset of the entity (what to update).

   942      */

   943     public function scheduleExtraUpdate($entity, array $changeset)

   944     {

   945         $oid = spl_object_hash($entity);

   946         if (isset($this->extraUpdates[$oid])) {

   947             list($ignored, $changeset2) = $this->extraUpdates[$oid];

   948             $this->extraUpdates[$oid] = array($entity, $changeset + $changeset2);

   949         } else {

   950             $this->extraUpdates[$oid] = array($entity, $changeset);

   951         }

   952     }

   953 

   954     /**

   955      * Checks whether an entity is registered as dirty in the unit of work.

   956      * Note: Is not very useful currently as dirty entities are only registered

   957      * at commit time.

   958      *

   959      * @param object $entity

   960      * @return boolean

   961      */

   962     public function isScheduledForUpdate($entity)

   963     {

   964         return isset($this->entityUpdates[spl_object_hash($entity)]);

   965     }

   966 

   967     public function isScheduledForDirtyCheck($entity)

   968     {

   969         $rootEntityName = $this->em->getClassMetadata(get_class($entity))->rootEntityName;

   970         return isset($this->scheduledForDirtyCheck[$rootEntityName][spl_object_hash($entity)]);

   971     }

   972 

   973     /**

   974      * INTERNAL:

   975      * Schedules an entity for deletion.

   976      * 

   977      * @param object $entity

   978      */

   979     public function scheduleForDelete($entity)

   980     {

   981         $oid = spl_object_hash($entity);

   982         

   983         if (isset($this->entityInsertions[$oid])) {

   984             if ($this->isInIdentityMap($entity)) {

   985                 $this->removeFromIdentityMap($entity);

   986             }

   987             unset($this->entityInsertions[$oid], $this->entityStates[$oid]);

   988             return; // entity has not been persisted yet, so nothing more to do.

   989         }

   990 

   991         if ( ! $this->isInIdentityMap($entity)) {

   992             return; // ignore

   993         }

   994 

   995         $this->removeFromIdentityMap($entity);

   996 

   997         if (isset($this->entityUpdates[$oid])) {

   998             unset($this->entityUpdates[$oid]);

   999         }

  1000         if ( ! isset($this->entityDeletions[$oid])) {

  1001             $this->entityDeletions[$oid] = $entity;

  1002             $this->entityStates[$oid] = self::STATE_REMOVED;

  1003         }

  1004     }

  1005 

  1006     /**

  1007      * Checks whether an entity is registered as removed/deleted with the unit

  1008      * of work.

  1009      *

  1010      * @param object $entity

  1011      * @return boolean

  1012      */

  1013     public function isScheduledForDelete($entity)

  1014     {

  1015         return isset($this->entityDeletions[spl_object_hash($entity)]);

  1016     }

  1017 

  1018     /**

  1019      * Checks whether an entity is scheduled for insertion, update or deletion.

  1020      * 

  1021      * @param $entity

  1022      * @return boolean

  1023      */

  1024     public function isEntityScheduled($entity)

  1025     {

  1026         $oid = spl_object_hash($entity);

  1027         return isset($this->entityInsertions[$oid]) ||

  1028                 isset($this->entityUpdates[$oid]) ||

  1029                 isset($this->entityDeletions[$oid]);

  1030     }

  1031 

  1032     /**

  1033      * INTERNAL:

  1034      * Registers an entity in the identity map.

  1035      * Note that entities in a hierarchy are registered with the class name of

  1036      * the root entity.

  1037      *

  1038      * @ignore

  1039      * @param object $entity  The entity to register.

  1040      * @return boolean  TRUE if the registration was successful, FALSE if the identity of

  1041      *                  the entity in question is already managed.

  1042      */

  1043     public function addToIdentityMap($entity)

  1044     {

  1045         $classMetadata = $this->em->getClassMetadata(get_class($entity));

  1046         $idHash = implode(' ', $this->entityIdentifiers[spl_object_hash($entity)]);

  1047         if ($idHash === '') {

  1048             throw new InvalidArgumentException("The given entity has no identity.");

  1049         }

  1050         $className = $classMetadata->rootEntityName;

  1051         if (isset($this->identityMap[$className][$idHash])) {

  1052             return false;

  1053         }

  1054         $this->identityMap[$className][$idHash] = $entity;

  1055         if ($entity instanceof NotifyPropertyChanged) {

  1056             $entity->addPropertyChangedListener($this);

  1057         }

  1058         return true;

  1059     }

  1060 

  1061     /**

  1062      * Gets the state of an entity with regard to the current unit of work.

  1063      *

  1064      * @param object $entity

  1065      * @param integer $assume The state to assume if the state is not yet known (not MANAGED or REMOVED).

  1066      *                        This parameter can be set to improve performance of entity state detection

  1067      *                        by potentially avoiding a database lookup if the distinction between NEW and DETACHED

  1068      *                        is either known or does not matter for the caller of the method.

  1069      * @return int The entity state.

  1070      */

  1071     public function getEntityState($entity, $assume = null)

  1072     {

  1073         $oid = spl_object_hash($entity);

  1074         if ( ! isset($this->entityStates[$oid])) {

  1075             // State can only be NEW or DETACHED, because MANAGED/REMOVED states are known.

  1076             // Note that you can not remember the NEW or DETACHED state in _entityStates since

  1077             // the UoW does not hold references to such objects and the object hash can be reused.

  1078             // More generally because the state may "change" between NEW/DETACHED without the UoW being aware of it.

  1079             if ($assume === null) {

  1080                 $class = $this->em->getClassMetadata(get_class($entity));

  1081                 $id = $class->getIdentifierValues($entity);

  1082                 if ( ! $id) {

  1083                     return self::STATE_NEW;

  1084                 } else if ($class->isIdentifierNatural()) {

  1085                     // Check for a version field, if available, to avoid a db lookup.

  1086                     if ($class->isVersioned) {

  1087                         if ($class->getFieldValue($entity, $class->versionField)) {

  1088                             return self::STATE_DETACHED;

  1089                         } else {

  1090                             return self::STATE_NEW;

  1091                         }

  1092                     } else {

  1093                         // Last try before db lookup: check the identity map.

  1094                         if ($this->tryGetById($id, $class->rootEntityName)) {

  1095                             return self::STATE_DETACHED;

  1096                         } else {

  1097                             // db lookup

  1098                             if ($this->getEntityPersister(get_class($entity))->exists($entity)) {

  1099                                 return self::STATE_DETACHED;

  1100                             } else {

  1101                                 return self::STATE_NEW;

  1102                             }

  1103                         }

  1104                     }

  1105                 } else {

  1106                     return self::STATE_DETACHED;

  1107                 }

  1108             } else {

  1109                 return $assume;

  1110             }

  1111         }

  1112         return $this->entityStates[$oid];

  1113     }

  1114 

  1115     /**

  1116      * INTERNAL:

  1117      * Removes an entity from the identity map. This effectively detaches the

  1118      * entity from the persistence management of Doctrine.

  1119      *

  1120      * @ignore

  1121      * @param object $entity

  1122      * @return boolean

  1123      */

  1124     public function removeFromIdentityMap($entity)

  1125     {

  1126         $oid = spl_object_hash($entity);

  1127         $classMetadata = $this->em->getClassMetadata(get_class($entity));

  1128         $idHash = implode(' ', $this->entityIdentifiers[$oid]);

  1129         if ($idHash === '') {

  1130             throw new InvalidArgumentException("The given entity has no identity.");

  1131         }

  1132         $className = $classMetadata->rootEntityName;

  1133         if (isset($this->identityMap[$className][$idHash])) {

  1134             unset($this->identityMap[$className][$idHash]);

  1135             //$this->entityStates[$oid] = self::STATE_DETACHED;

  1136             return true;