RetailCRM-Mirror/doctrine2
1
0
Fork 0
mirror of synced 2025-04-03 13:23:37 +03:00
Code Issues Projects Releases Wiki Activity

Fixes for merging bidirectional associations where both sides define cascade=merge as well as fixes for handling null values and proxies properly in single-valued associations.

Browse source
This commit is contained in:
Roman S. Borschel 2010-07-29 22:27:00 +02:00
parent 954a8c3935
commit 69073c4b37
5 changed files with 86 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
lib/Doctrine/ORM/Proxy/ProxyFactory.php
View file

@ -221,9 +221,9 @@ class ProxyFactory
$sleepImpl = ''; $sleepImpl = '';
if ($class->reflClass->hasMethod('__sleep')) { if ($class->reflClass->hasMethod('__sleep')) {
$sleepImpl .= 'return parent::__sleep();'; $sleepImpl .= "return array_merge(array('__isInitialized__'), parent::__sleep());";
} else { } else {
$sleepImpl .= 'return array('; $sleepImpl .= "return array('__isInitialized__', ";
$first = true; $first = true;
foreach ($class->getReflectionProperties() as $name => $prop) { foreach ($class->getReflectionProperties() as $name => $prop) {
@ -268,8 +268,7 @@ class <proxyClassName> extends \<className> implements \Doctrine\ORM\Proxy\Proxy
if ($this->_entityPersister->load($this->_identifier, $this) === null) { if ($this->_entityPersister->load($this->_identifier, $this) === null) {
throw new \Doctrine\ORM\EntityNotFoundException(); throw new \Doctrine\ORM\EntityNotFoundException();
} }
unset($this->_entityPersister); unset($this->_entityPersister, $this->_identifier);
unset($this->_identifier);
} }
} }
@ -277,9 +276,6 @@ class <proxyClassName> extends \<className> implements \Doctrine\ORM\Proxy\Proxy
public function __sleep() public function __sleep()
{ {
if (!$this->__isInitialized__) {
throw new \RuntimeException("Not fully loaded proxy can not be serialized.");
}
<sleepImpl> <sleepImpl>
} }
}'; }';

38
lib/Doctrine/ORM/UnitOfWork.php
View file

@ -1349,11 +1349,13 @@ class UnitOfWork implements PropertyChangedListener
return; // Prevent infinite recursion return; // Prevent infinite recursion
} }
$visited[$oid] = $entity; // mark visited
$class = $this->em->getClassMetadata(get_class($entity)); $class = $this->em->getClassMetadata(get_class($entity));
// First we assume DETACHED, although it can still be NEW but we can avoid // First we assume DETACHED, although it can still be NEW but we can avoid
// an extra db-roundtrip this way. If it is DETACHED or NEW, we need to fetch // an extra db-roundtrip this way. If it is not MANAGED but has an identity,
// it from the db anyway in order to merge. // we need to fetch it from the db anyway in order to merge.
// MANAGED entities are ignored by the merge operation. // MANAGED entities are ignored by the merge operation.
if ($this->getEntityState($entity, self::STATE_DETACHED) == self::STATE_MANAGED) { if ($this->getEntityState($entity, self::STATE_DETACHED) == self::STATE_MANAGED) {
$managedCopy = $entity; $managedCopy = $entity;
@ -1407,23 +1409,27 @@ class UnitOfWork implements PropertyChangedListener
} else { } else {
$assoc2 = $class->associationMappings[$name]; $assoc2 = $class->associationMappings[$name];
if ($assoc2->isOneToOne()) { if ($assoc2->isOneToOne()) {
if ( ! $assoc2->isCascadeMerge) { $other = $prop->getValue($entity);
$other = $prop->getValue($entity); if ($other === null) {
if ($other !== null) { $prop->setValue($managedCopy, null);
if ($this->getEntityState($other, self::STATE_DETACHED) == self::STATE_MANAGED) { } else if ($other instanceof Proxy && !$other->__isInitialized__) {
$prop->setValue($managedCopy, $other); // do not merge fields marked lazy that have not been fetched.
} else { continue;
$targetClass = $this->em->getClassMetadata($assoc2->targetEntityName); } else if ( ! $assoc2->isCascadeMerge) {
$id = $targetClass->getIdentifierValues($other); if ($this->getEntityState($other, self::STATE_DETACHED) == self::STATE_MANAGED) {
$proxy = $this->em->getProxyFactory()->getProxy($assoc2->targetEntityName, $id); $prop->setValue($managedCopy, $other);
$prop->setValue($managedCopy, $proxy); } else {
$this->registerManaged($proxy, $id, array()); $targetClass = $this->em->getClassMetadata($assoc2->targetEntityName);
} $id = $targetClass->getIdentifierValues($other);
$proxy = $this->em->getProxyFactory()->getProxy($assoc2->targetEntityName, $id);
$prop->setValue($managedCopy, $proxy);
$this->registerManaged($proxy, $id, array());
} }
} }
} else { } else {
$mergeCol = $prop->getValue($entity); $mergeCol = $prop->getValue($entity);
if ($mergeCol instanceof PersistentCollection && !$mergeCol->isInitialized()) { if ($mergeCol instanceof PersistentCollection && !$mergeCol->isInitialized()) {
// do not merge fields marked lazy that have not been fetched.
// keep the lazy persistent collection of the managed copy. // keep the lazy persistent collection of the managed copy.
continue; continue;
} }
@ -1451,7 +1457,6 @@ class UnitOfWork implements PropertyChangedListener
$prevClass = $this->em->getClassMetadata(get_class($prevManagedCopy)); $prevClass = $this->em->getClassMetadata(get_class($prevManagedCopy));
if ($assoc->isOneToOne()) { if ($assoc->isOneToOne()) {
$prevClass->reflFields[$assocField]->setValue($prevManagedCopy, $managedCopy); $prevClass->reflFields[$assocField]->setValue($prevManagedCopy, $managedCopy);
//TODO: What about back-reference if bidirectional?
} else { } else {
$prevClass->reflFields[$assocField]->getValue($prevManagedCopy)->unwrap()->add($managedCopy); $prevClass->reflFields[$assocField]->getValue($prevManagedCopy)->unwrap()->add($managedCopy);
if ($assoc->isOneToMany()) { if ($assoc->isOneToMany()) {
@ -1460,6 +1465,9 @@ class UnitOfWork implements PropertyChangedListener
} }
} }
// Mark the managed copy visited as well
$visited[spl_object_hash($managedCopy)] = true;
$this->cascadeMerge($entity, $managedCopy, $visited); $this->cascadeMerge($entity, $managedCopy, $visited);
return $managedCopy; return $managedCopy;

2
tests/Doctrine/Tests/Models/CMS/CmsPhonenumber.php
View file

@ -13,7 +13,7 @@ class CmsPhonenumber
*/ */
public $phonenumber; public $phonenumber;
/** /**
* @ManyToOne(targetEntity="CmsUser", inversedBy="phonenumbers") * @ManyToOne(targetEntity="CmsUser", inversedBy="phonenumbers", cascade={"merge"})
* @JoinColumn(name="user_id", referencedColumnName="id") * @JoinColumn(name="user_id", referencedColumnName="id")
*/ */
public $user; public $user;

33
tests/Doctrine/Tests/ORM/Functional/BasicFunctionalTest.php
View file

@ -788,7 +788,8 @@ class BasicFunctionalTest extends \Doctrine\Tests\OrmFunctionalTestCase
$userId = $managedUser->id; $userId = $managedUser->id;
$this->_em->clear(); $this->_em->clear();
$this->assertTrue($this->_em->find(get_class($managedUser), $userId) instanceof CmsUser); $user2 = $this->_em->find(get_class($managedUser), $userId);
$this->assertTrue($user2 instanceof CmsUser);
} }
public function testMergeThrowsExceptionIfEntityWithGeneratedIdentifierDoesNotExist() public function testMergeThrowsExceptionIfEntityWithGeneratedIdentifierDoesNotExist()
@ -803,4 +804,34 @@ class BasicFunctionalTest extends \Doctrine\Tests\OrmFunctionalTestCase
$this->fail(); $this->fail();
} catch (\Doctrine\ORM\EntityNotFoundException $enfe) {} } catch (\Doctrine\ORM\EntityNotFoundException $enfe) {}
} }
/**
* @group DDC-634
*/
public function testOneToOneMergeSetNull()
{
//$this->_em->getConnection()->getConfiguration()->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger);
$user = new CmsUser();
$user->username = "beberlei";
$user->name = "Benjamin E.";
$user->status = 'active';
$ph = new CmsPhonenumber();
$ph->phonenumber = "12345";
$user->addPhonenumber($ph);
$this->_em->persist($user);
$this->_em->persist($ph);
$this->_em->flush();
$this->_em->clear();
$ph->user = null;
$managedPh = $this->_em->merge($ph);
$this->_em->flush();
$this->_em->clear();
$this->assertNull($this->_em->find(get_class($ph), $ph->phonenumber)->getUser());
}
} }

58
tests/Doctrine/Tests/ORM/Functional/DetachedEntityTest.php
View file

@ -44,9 +44,10 @@ class DetachedEntityTest extends \Doctrine\Tests\OrmFunctionalTestCase
$this->assertTrue($this->_em->contains($user2)); $this->assertTrue($this->_em->contains($user2));
$this->assertEquals('Roman B.', $user2->name); $this->assertEquals('Roman B.', $user2->name);
} }
public function testSerializeUnserializeModifyMerge() public function testSerializeUnserializeModifyMerge()
{ {
//$this->_em->getConnection()->getConfiguration()->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger);
$user = new CmsUser; $user = new CmsUser;
$user->name = 'Guilherme'; $user->name = 'Guilherme';
$user->username = 'gblanco'; $user->username = 'gblanco';
@ -59,6 +60,7 @@ class DetachedEntityTest extends \Doctrine\Tests\OrmFunctionalTestCase
$this->_em->persist($user); $this->_em->persist($user);
$this->_em->flush(); $this->_em->flush();
$this->assertTrue($this->_em->contains($user)); $this->assertTrue($this->_em->contains($user));
$this->assertTrue($user->phonenumbers->isInitialized());
$serialized = serialize($user); $serialized = serialize($user);
$this->_em->clear(); $this->_em->clear();
@ -103,42 +105,36 @@ class DetachedEntityTest extends \Doctrine\Tests\OrmFunctionalTestCase
} catch (\Exception $expected) {} } catch (\Exception $expected) {}
} }
/** public function testUninitializedLazyAssociationsAreIgnoredOnMerge() {
* @group DDC-518
*/
/*public function testMergeDetachedEntityWithNewlyPersistentOneToOneAssoc()
{
//$this->_em->getConnection()->getConfiguration()->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger); //$this->_em->getConnection()->getConfiguration()->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger);
// Create a detached user
$user = new CmsUser; $user = new CmsUser;
$user->name = 'Roman'; $user->name = 'Guilherme';
$user->username = 'romanb'; $user->username = 'gblanco';
$user->status = 'dev'; $user->status = 'developer';
$address = new CmsAddress;
$address->city = 'Berlin';
$address->country = 'Germany';
$address->street = 'Sesamestreet';
$address->zip = 12345;
$address->setUser($user);
$this->_em->persist($address);
$this->_em->persist($user); $this->_em->persist($user);
$this->_em->flush(); $this->_em->flush();
$this->_em->clear(); $this->_em->clear();
//$address = new CmsAddress; $address2 = $this->_em->find(get_class($address), $address->id);
//$address->city = 'Berlin'; $this->assertTrue($address2->user instanceof \Doctrine\ORM\Proxy\Proxy);
//$address->country = 'Germany'; $this->assertFalse($address2->user->__isInitialized__);
//$address->street = 'Sesamestreet'; $detachedAddress2 = unserialize(serialize($address2));
//$address->zip = 12345; $this->assertTrue($detachedAddress2->user instanceof \Doctrine\ORM\Proxy\Proxy);
//$address->setUser($user); $this->assertFalse($detachedAddress2->user->__isInitialized__);
$phone = new CmsPhonenumber(); $managedAddress2 = $this->_em->merge($detachedAddress2);
$phone->phonenumber = '12345'; $this->assertTrue($managedAddress2->user instanceof \Doctrine\ORM\Proxy\Proxy);
$this->assertFalse($managedAddress2->user === $detachedAddress2->user);
$user2 = $this->_em->merge($user); $this->assertFalse($managedAddress2->user->__isInitialized__);
}
$user2->addPhonenumber($phone);
$this->_em->persist($phone);
//$address->setUser($user2);
//$this->_em->persist($address);
$this->_em->flush();
$this->assertEquals(1,1);
}*/
} }