From 233b3cd0b927501e19666e7102073c6222a37b2b Mon Sep 17 00:00:00 2001
From: beberlei <kontakt@beberlei.de>
Date: Fri, 9 Jul 2010 22:55:30 +0200
Subject: [PATCH 1/4] DDC-130 - Add initial version of deleteJoinTableRecords
 code on the persisters, flanked by 4 tests.

---
 .../ORM/Persisters/BasicEntityPersister.php   | 57 +++++++++++++++++--
 .../Persisters/JoinedSubclassPersister.php    |  8 +--
 .../Functional/ClassTableInheritanceTest.php  | 29 ++++++++++
 .../ManyToManyBasicAssociationTest.php        | 31 ++++++++++
 .../Functional/SingleTableInheritanceTest.php | 14 +++++
 5 files changed, 131 insertions(+), 8 deletions(-)

diff --git a/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php b/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php
index cad7a2ab0..e62e8bbbf 100644
--- a/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php
+++ b/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php
@@ -335,6 +335,55 @@ class BasicEntityPersister
         }
     }
 
+    private $requiredJoinTableDeletions = null;
+
+    /**
+     * @todo Add check for platform if it supports foreign keys/cascading.
+     * @param array $identifier
+     * @return void
+     */
+    protected function deleteJoinTableRecords($identifier)
+    {
+        if ($this->requiredJoinTableDeletions === null) {
+            $this->requiredJoinTableDeletions = array();
+            foreach ($this->_class->associationMappings AS $mapping) {
+                /* @var $mapping \Doctrine\ORM\Mapping\AssociationMapping */
+                if ($mapping->isManyToMany()) {
+                    // TODO: Write test for composite keys
+                    if (!$mapping->isOwningSide) {
+                        $relatedClass = $this->_em->getClassMetadata($mapping->targetEntityName);
+                        $mapping = $relatedClass->associationMappings[$mapping->mappedBy];
+                        $keys = array_keys($mapping->relationToTargetKeyColumns);
+
+                        // this is not semantically correct, onDelete should be an option of the joinColumns
+                        // @todo optimize this (potentially in the validate association/metadata already)
+                        foreach ($mapping->joinTable['inverseJoinColumns'] AS $joinColumn) {
+                            if (strtoupper($joinColumn['onDelete']) == 'CASCADE') {
+                                continue;
+                            }
+                        }
+                    } else {
+                        // this is not semantically correct, onDelete should be an option of the joinColumns
+                        // @todo optimize this (potentially in the validate association/metadata already)
+                        foreach ($mapping->joinTable['joinColumns'] AS $joinColumn) {
+                            if (strtoupper($joinColumn['onDelete']) == 'CASCADE') {
+                                continue;
+                            }
+                        }
+
+                        $keys = array_keys($mapping->relationToSourceKeyColumns);
+                    }
+                    $this->requiredJoinTableDeletions[$mapping->joinTable['name']] = $keys;
+                }
+            }
+        }
+
+        foreach ($this->requiredJoinTableDeletions AS $table => $keys) {
+            $id = array_combine($keys, $identifier);
+            $this->_conn->delete($table, $id);
+        }
+    }
+
     /**
      * Deletes a managed entity.
      *
@@ -347,10 +396,10 @@ class BasicEntityPersister
      */
     public function delete($entity)
     {
-        $id = array_combine(
-            $this->_class->getIdentifierColumnNames(),
-            $this->_em->getUnitOfWork()->getEntityIdentifier($entity)
-        );
+        $identifier = $this->_em->getUnitOfWork()->getEntityIdentifier($entity);
+        $this->deleteJoinTableRecords($identifier);
+
+        $id = array_combine($this->_class->getIdentifierColumnNames(), $identifier);
         $this->_conn->delete($this->_class->table['name'], $id);
     }
 
diff --git a/lib/Doctrine/ORM/Persisters/JoinedSubclassPersister.php b/lib/Doctrine/ORM/Persisters/JoinedSubclassPersister.php
index ab413b604..dc7d802a2 100644
--- a/lib/Doctrine/ORM/Persisters/JoinedSubclassPersister.php
+++ b/lib/Doctrine/ORM/Persisters/JoinedSubclassPersister.php
@@ -206,10 +206,10 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
      */
     public function delete($entity)
     {
-        $id = array_combine(
-            $this->_class->getIdentifierColumnNames(),
-            $this->_em->getUnitOfWork()->getEntityIdentifier($entity)
-        );
+        $identifier = $this->_em->getUnitOfWork()->getEntityIdentifier($entity);
+        $this->deleteJoinTableRecords($identifier);
+
+        $id = array_combine($this->_class->getIdentifierColumnNames(), $identifier);
 
         // If the database platform supports FKs, just
         // delete the row from the root table. Cascades do the rest.
diff --git a/tests/Doctrine/Tests/ORM/Functional/ClassTableInheritanceTest.php b/tests/Doctrine/Tests/ORM/Functional/ClassTableInheritanceTest.php
index ea1ad15d8..78d5d7987 100644
--- a/tests/Doctrine/Tests/ORM/Functional/ClassTableInheritanceTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/ClassTableInheritanceTest.php
@@ -294,4 +294,33 @@ class ClassTableInheritanceTest extends \Doctrine\Tests\OrmFunctionalTestCase
             ->getResult()) > 0);
         
     }
+
+    /**
+     * @group DDC-130
+     */
+    public function testDeleteJoinTableRecords()
+    {
+        $this->markTestSkipped('Nightmare! friends adds both ID 6-7 and 7-6 into two rows of the join table. How to detect this?');
+
+        $employee1 = new CompanyEmployee();
+        $employee1->setName('gblanco');
+        $employee1->setSalary(0);
+        $employee1->setDepartment('IT');
+
+        $employee2 = new CompanyEmployee();
+        $employee2->setName('jwage');
+        $employee2->setSalary(0);
+        $employee2->setDepartment('IT');
+
+        $employee1->addFriend($employee2);
+
+        $this->_em->persist($employee1);
+        $this->_em->persist($employee2);
+        $this->_em->flush();
+
+        $this->_em->remove($employee1);
+        $this->_em->flush();
+
+        $this->assertNull($this->_em->find(get_class($employee1), $employee1->getId()));
+    }
 }
diff --git a/tests/Doctrine/Tests/ORM/Functional/ManyToManyBasicAssociationTest.php b/tests/Doctrine/Tests/ORM/Functional/ManyToManyBasicAssociationTest.php
index 752d11fb8..83a522eb1 100644
--- a/tests/Doctrine/Tests/ORM/Functional/ManyToManyBasicAssociationTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/ManyToManyBasicAssociationTest.php
@@ -203,6 +203,37 @@ class ManyToManyBasicAssociationTest extends \Doctrine\Tests\OrmFunctionalTestCa
         $this->assertEquals(3, count($freshUser->getGroups()));
     }
 
+    /**
+     * @group DDC-130
+     */
+    public function testRemoveUserWithManyGroups()
+    {
+        $user = $this->addCmsUserGblancoWithGroups(2);
+
+        $this->_em->remove($user);
+        $this->_em->flush();
+
+        $newUser = $this->_em->find(get_class($user), $user->getId());
+        $this->assertNull($newUser);
+    }
+
+    /**
+     * @group DDC-130
+     */
+    public function testRemoveGroupWithUser()
+    {
+        $user = $this->addCmsUserGblancoWithGroups(2);
+
+        foreach ($user->getGroups() AS $group) {
+            $this->_em->remove($group);
+        }
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $newUser = $this->_em->find(get_class($user), $user->getId());
+        $this->assertEquals(0, count($newUser->getGroups()));
+    }
+
     /**
      * @param  int $groupCount
      * @return CmsUser
diff --git a/tests/Doctrine/Tests/ORM/Functional/SingleTableInheritanceTest.php b/tests/Doctrine/Tests/ORM/Functional/SingleTableInheritanceTest.php
index b2bd382c6..fb9c93abf 100644
--- a/tests/Doctrine/Tests/ORM/Functional/SingleTableInheritanceTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/SingleTableInheritanceTest.php
@@ -294,4 +294,18 @@ class SingleTableInheritanceTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
         $this->assertFalse($contracts[0]->isCompleted(), "Only non completed contracts should be left.");
     }
+
+    /**
+     * @group DDC-130
+     */
+    public function testDeleteJoinTableRecords()
+    {
+        $this->loadFullFixture();
+
+        // remove managed copy of the fix contract
+        $this->_em->remove($this->_em->find(get_class($this->fix), $this->fix->getId()));
+        $this->_em->flush();
+
+        $this->assertNull($this->_em->find(get_class($this->fix), $this->fix->getId()), "Contract should not be present in the database anymore.");
+    }
 }

From 1794127d5150e23575b652fc613bae2396700b2f Mon Sep 17 00:00:00 2001
From: Benjamin Eberlei <kontakt@beberlei.de>
Date: Sat, 10 Jul 2010 12:04:02 +0200
Subject: [PATCH 2/4] DDC-130 - Refactored deleteJoinTableRecords() support

---
 .../ORM/Mapping/ManyToManyMapping.php         | 28 ++++++++++
 .../ORM/Persisters/BasicEntityPersister.php   | 51 ++++++-------------
 .../Tests/ORM/Mapping/ClassMetadataTest.php   | 19 +++++++
 3 files changed, 63 insertions(+), 35 deletions(-)

diff --git a/lib/Doctrine/ORM/Mapping/ManyToManyMapping.php b/lib/Doctrine/ORM/Mapping/ManyToManyMapping.php
index 21bdafe20..0a1aaa34e 100644
--- a/lib/Doctrine/ORM/Mapping/ManyToManyMapping.php
+++ b/lib/Doctrine/ORM/Mapping/ManyToManyMapping.php
@@ -68,6 +68,20 @@ class ManyToManyMapping extends AssociationMapping
      */
     public $orderBy;
 
+    /**
+     * READ-ONLY: Are entries on the owning side of this join-table deleted through a database onDelete="CASCADE" operation?
+     *
+     * @var bool
+     */
+    public $owningIsOnDeleteCascade = false;
+
+    /**
+     * READ-ONLY: Are entries on the inverse side of this join-table deleted through a database onDelete="CASCADE" operation?
+     *
+     * @var bool
+     */
+    public $inverseIsOnDeleteCascade = false;
+
     /**
      * {@inheritdoc}
      */
@@ -115,11 +129,19 @@ class ManyToManyMapping extends AssociationMapping
             }
             
             foreach ($mapping['joinTable']['joinColumns'] as $joinColumn) {
+                if (isset($joinColumn['onDelete']) && strtolower($joinColumn['onDelete']) == 'cascade') {
+                    $this->owningIsOnDeleteCascade = true;
+                }
+
                 $this->relationToSourceKeyColumns[$joinColumn['name']] = $joinColumn['referencedColumnName'];
                 $this->joinTableColumns[] = $joinColumn['name'];
             }
             
             foreach ($mapping['joinTable']['inverseJoinColumns'] as $inverseJoinColumn) {
+                if (isset($inverseJoinColumn['onDelete']) && strtolower($inverseJoinColumn['onDelete']) == 'cascade') {
+                    $this->inverseIsOnDeleteCascade = true;
+                }
+
                 $this->relationToTargetKeyColumns[$inverseJoinColumn['name']] = $inverseJoinColumn['referencedColumnName'];
                 $this->joinTableColumns[] = $inverseJoinColumn['name'];
             }
@@ -169,6 +191,12 @@ class ManyToManyMapping extends AssociationMapping
         $serialized[] = 'joinTableColumns';
         $serialized[] = 'relationToSourceKeyColumns';
         $serialized[] = 'relationToTargetKeyColumns';
+        if ($this->owningIsOnDeleteCascade) {
+            $serialized[] = 'owningIsOnDeleteCascade';
+        }
+        if ($this->inverseIsOnDeleteCascade) {
+            $serialized[] = 'inverseIsOnDeleteCascade';
+        }
         if ($this->orderBy) {
             $serialized[] = 'orderBy';
         }
diff --git a/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php b/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php
index e62e8bbbf..f86128fff 100644
--- a/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php
+++ b/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php
@@ -335,8 +335,6 @@ class BasicEntityPersister
         }
     }
 
-    private $requiredJoinTableDeletions = null;
-
     /**
      * @todo Add check for platform if it supports foreign keys/cascading.
      * @param array $identifier
@@ -344,44 +342,27 @@ class BasicEntityPersister
      */
     protected function deleteJoinTableRecords($identifier)
     {
-        if ($this->requiredJoinTableDeletions === null) {
-            $this->requiredJoinTableDeletions = array();
-            foreach ($this->_class->associationMappings AS $mapping) {
-                /* @var $mapping \Doctrine\ORM\Mapping\AssociationMapping */
-                if ($mapping->isManyToMany()) {
-                    // TODO: Write test for composite keys
-                    if (!$mapping->isOwningSide) {
-                        $relatedClass = $this->_em->getClassMetadata($mapping->targetEntityName);
-                        $mapping = $relatedClass->associationMappings[$mapping->mappedBy];
-                        $keys = array_keys($mapping->relationToTargetKeyColumns);
+        foreach ($this->_class->associationMappings AS $mapping) {
+            /* @var $mapping \Doctrine\ORM\Mapping\AssociationMapping */
+            if ($mapping->isManyToMany()) {
+                if($mapping->isOwningSide && (!$mapping->owningIsOnDeleteCascade || !$this->_platform->supportsForeignKeyConstraints())) {
+                    $this->_conn->delete(
+                        $mapping->joinTable['name'],
+                        array_combine(array_keys($mapping->relationToSourceKeyColumns), $identifier)
+                    );
+                } else if (!$mapping->isOwningSide) {
+                    $relatedClass = $this->_em->getClassMetadata($mapping->targetEntityName);
+                    $relatedMapping = $relatedClass->associationMappings[$mapping->mappedBy];
 
-                        // this is not semantically correct, onDelete should be an option of the joinColumns
-                        // @todo optimize this (potentially in the validate association/metadata already)
-                        foreach ($mapping->joinTable['inverseJoinColumns'] AS $joinColumn) {
-                            if (strtoupper($joinColumn['onDelete']) == 'CASCADE') {
-                                continue;
-                            }
-                        }
-                    } else {
-                        // this is not semantically correct, onDelete should be an option of the joinColumns
-                        // @todo optimize this (potentially in the validate association/metadata already)
-                        foreach ($mapping->joinTable['joinColumns'] AS $joinColumn) {
-                            if (strtoupper($joinColumn['onDelete']) == 'CASCADE') {
-                                continue;
-                            }
-                        }
-
-                        $keys = array_keys($mapping->relationToSourceKeyColumns);
+                    if (!$relatedMapping->inverseIsOnDeleteCascade || !$this->_platform->supportsForeignKeyConstraints()) {
+                        $this->_conn->delete(
+                            $relatedMapping->joinTable['name'],
+                            array_combine(array_keys($relatedMapping->relationToTargetKeyColumns), $identifier)
+                        );
                     }
-                    $this->requiredJoinTableDeletions[$mapping->joinTable['name']] = $keys;
                 }
             }
         }
-
-        foreach ($this->requiredJoinTableDeletions AS $table => $keys) {
-            $id = array_combine($keys, $identifier);
-            $this->_conn->delete($table, $id);
-        }
     }
 
     /**
diff --git a/tests/Doctrine/Tests/ORM/Mapping/ClassMetadataTest.php b/tests/Doctrine/Tests/ORM/Mapping/ClassMetadataTest.php
index 96fc026f7..565826e9a 100644
--- a/tests/Doctrine/Tests/ORM/Mapping/ClassMetadataTest.php
+++ b/tests/Doctrine/Tests/ORM/Mapping/ClassMetadataTest.php
@@ -107,6 +107,25 @@ class ClassMetadataTest extends \Doctrine\Tests\OrmTestCase
             'joinColumns' => array(array('name' => 'CmsUser_id', 'referencedColumnName' => 'id', 'onDelete' => 'CASCADE')),
             'inverseJoinColumns' => array(array('name' => 'CmsGroup_id', 'referencedColumnName' => 'id', 'onDelete' => 'CASCADE'))
         ), $assoc->joinTable);
+        $this->assertTrue($assoc->owningIsOnDeleteCascade);
+        $this->assertTrue($assoc->inverseIsOnDeleteCascade);
+    }
+
+    public function testSerializeManyToManyJoinTableCascade()
+    {
+        $cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
+        $cm->mapManyToMany(
+            array(
+            'fieldName' => 'groups',
+            'targetEntity' => 'CmsGroup'
+        ));
+
+        /* @var $assoc \Doctrine\ORM\Mapping\ManyToManyMapping */
+        $assoc = $cm->associationMappings['groups'];
+        $assoc = unserialize(serialize($assoc));
+
+        $this->assertTrue($assoc->owningIsOnDeleteCascade);
+        $this->assertTrue($assoc->inverseIsOnDeleteCascade);
     }
 
     /**

From b0e4d06c405f82af3524f9021cd095104040eefe Mon Sep 17 00:00:00 2001
From: Benjamin Eberlei <kontakt@beberlei.de>
Date: Sat, 10 Jul 2010 13:12:33 +0200
Subject: [PATCH 3/4] DDC-130 - Refactored deleteJoinTableRecords() even more,
 simplified approach disfavouring evil legacy database schemas

---
 .../ORM/Mapping/ManyToManyMapping.php         | 22 +++++--------------
 .../ORM/Persisters/BasicEntityPersister.php   | 21 +++++++-----------
 .../Tests/ORM/Mapping/ClassMetadataTest.php   |  6 ++---
 3 files changed, 16 insertions(+), 33 deletions(-)

diff --git a/lib/Doctrine/ORM/Mapping/ManyToManyMapping.php b/lib/Doctrine/ORM/Mapping/ManyToManyMapping.php
index 0a1aaa34e..a308b4eb8 100644
--- a/lib/Doctrine/ORM/Mapping/ManyToManyMapping.php
+++ b/lib/Doctrine/ORM/Mapping/ManyToManyMapping.php
@@ -69,18 +69,11 @@ class ManyToManyMapping extends AssociationMapping
     public $orderBy;
 
     /**
-     * READ-ONLY: Are entries on the owning side of this join-table deleted through a database onDelete="CASCADE" operation?
+     * READ-ONLY: Are entries on the owning AND inverse side of this join-table deleted through a database onDelete="CASCADE" operation?
      *
      * @var bool
      */
-    public $owningIsOnDeleteCascade = false;
-
-    /**
-     * READ-ONLY: Are entries on the inverse side of this join-table deleted through a database onDelete="CASCADE" operation?
-     *
-     * @var bool
-     */
-    public $inverseIsOnDeleteCascade = false;
+    public $isOnDeleteCascade = false;
 
     /**
      * {@inheritdoc}
@@ -130,7 +123,7 @@ class ManyToManyMapping extends AssociationMapping
             
             foreach ($mapping['joinTable']['joinColumns'] as $joinColumn) {
                 if (isset($joinColumn['onDelete']) && strtolower($joinColumn['onDelete']) == 'cascade') {
-                    $this->owningIsOnDeleteCascade = true;
+                    $this->isOnDeleteCascade = true;
                 }
 
                 $this->relationToSourceKeyColumns[$joinColumn['name']] = $joinColumn['referencedColumnName'];
@@ -139,7 +132,7 @@ class ManyToManyMapping extends AssociationMapping
             
             foreach ($mapping['joinTable']['inverseJoinColumns'] as $inverseJoinColumn) {
                 if (isset($inverseJoinColumn['onDelete']) && strtolower($inverseJoinColumn['onDelete']) == 'cascade') {
-                    $this->inverseIsOnDeleteCascade = true;
+                    $this->isOnDeleteCascade = true;
                 }
 
                 $this->relationToTargetKeyColumns[$inverseJoinColumn['name']] = $inverseJoinColumn['referencedColumnName'];
@@ -191,11 +184,8 @@ class ManyToManyMapping extends AssociationMapping
         $serialized[] = 'joinTableColumns';
         $serialized[] = 'relationToSourceKeyColumns';
         $serialized[] = 'relationToTargetKeyColumns';
-        if ($this->owningIsOnDeleteCascade) {
-            $serialized[] = 'owningIsOnDeleteCascade';
-        }
-        if ($this->inverseIsOnDeleteCascade) {
-            $serialized[] = 'inverseIsOnDeleteCascade';
+        if ($this->isOnDeleteCascade) {
+            $serialized[] = 'isOnDeleteCascade';
         }
         if ($this->orderBy) {
             $serialized[] = 'orderBy';
diff --git a/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php b/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php
index f86128fff..dd5eee975 100644
--- a/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php
+++ b/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php
@@ -345,21 +345,16 @@ class BasicEntityPersister
         foreach ($this->_class->associationMappings AS $mapping) {
             /* @var $mapping \Doctrine\ORM\Mapping\AssociationMapping */
             if ($mapping->isManyToMany()) {
-                if($mapping->isOwningSide && (!$mapping->owningIsOnDeleteCascade || !$this->_platform->supportsForeignKeyConstraints())) {
-                    $this->_conn->delete(
-                        $mapping->joinTable['name'],
-                        array_combine(array_keys($mapping->relationToSourceKeyColumns), $identifier)
-                    );
-                } else if (!$mapping->isOwningSide) {
+                if (!$mapping->isOwningSide) {
                     $relatedClass = $this->_em->getClassMetadata($mapping->targetEntityName);
-                    $relatedMapping = $relatedClass->associationMappings[$mapping->mappedBy];
+                    $mapping = $relatedClass->associationMappings[$mapping->mappedBy];
+                    $keys = array_keys($mapping->relationToTargetKeyColumns);
+                } else {
+                    $keys = array_keys($mapping->relationToSourceKeyColumns);
+                }
 
-                    if (!$relatedMapping->inverseIsOnDeleteCascade || !$this->_platform->supportsForeignKeyConstraints()) {
-                        $this->_conn->delete(
-                            $relatedMapping->joinTable['name'],
-                            array_combine(array_keys($relatedMapping->relationToTargetKeyColumns), $identifier)
-                        );
-                    }
+                if(!$mapping->isOnDeleteCascade) {
+                    $this->_conn->delete($mapping->joinTable['name'], array_combine($keys, $identifier));
                 }
             }
         }
diff --git a/tests/Doctrine/Tests/ORM/Mapping/ClassMetadataTest.php b/tests/Doctrine/Tests/ORM/Mapping/ClassMetadataTest.php
index 565826e9a..620838a6b 100644
--- a/tests/Doctrine/Tests/ORM/Mapping/ClassMetadataTest.php
+++ b/tests/Doctrine/Tests/ORM/Mapping/ClassMetadataTest.php
@@ -107,8 +107,7 @@ class ClassMetadataTest extends \Doctrine\Tests\OrmTestCase
             'joinColumns' => array(array('name' => 'CmsUser_id', 'referencedColumnName' => 'id', 'onDelete' => 'CASCADE')),
             'inverseJoinColumns' => array(array('name' => 'CmsGroup_id', 'referencedColumnName' => 'id', 'onDelete' => 'CASCADE'))
         ), $assoc->joinTable);
-        $this->assertTrue($assoc->owningIsOnDeleteCascade);
-        $this->assertTrue($assoc->inverseIsOnDeleteCascade);
+        $this->assertTrue($assoc->isOnDeleteCascade);
     }
 
     public function testSerializeManyToManyJoinTableCascade()
@@ -124,8 +123,7 @@ class ClassMetadataTest extends \Doctrine\Tests\OrmTestCase
         $assoc = $cm->associationMappings['groups'];
         $assoc = unserialize(serialize($assoc));
 
-        $this->assertTrue($assoc->owningIsOnDeleteCascade);
-        $this->assertTrue($assoc->inverseIsOnDeleteCascade);
+        $this->assertTrue($assoc->isOnDeleteCascade);
     }
 
     /**

From ede62052045ac23e62b604f140743e9bab98a74d Mon Sep 17 00:00:00 2001
From: Benjamin Eberlei <kontakt@beberlei.de>
Date: Sat, 10 Jul 2010 13:35:58 +0200
Subject: [PATCH 4/4] DDC-130 - Make self-referential relationsships work by
 deleting both the owning and the inverse pair of keys

---
 .../ORM/Persisters/BasicEntityPersister.php        | 14 ++++++++++++++
 .../ORM/Functional/ClassTableInheritanceTest.php   |  2 +-
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php b/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php
index dd5eee975..8fba4d000 100644
--- a/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php
+++ b/lib/Doctrine/ORM/Persisters/BasicEntityPersister.php
@@ -345,16 +345,30 @@ class BasicEntityPersister
         foreach ($this->_class->associationMappings AS $mapping) {
             /* @var $mapping \Doctrine\ORM\Mapping\AssociationMapping */
             if ($mapping->isManyToMany()) {
+                // @Todo this only covers scenarios with no inheritance or of the same level. Is there something
+                // like self-referential relationship between different levels of an inheritance hierachy? I hope not!
+                $selfReferential = ($mapping->targetEntityName == $mapping->sourceEntityName);
+                
                 if (!$mapping->isOwningSide) {
                     $relatedClass = $this->_em->getClassMetadata($mapping->targetEntityName);
                     $mapping = $relatedClass->associationMappings[$mapping->mappedBy];
                     $keys = array_keys($mapping->relationToTargetKeyColumns);
+                    if ($selfReferential) {
+                        $otherKeys = array_keys($mapping->relationToSourceKeyColumns);
+                    }
                 } else {
                     $keys = array_keys($mapping->relationToSourceKeyColumns);
+                    if ($selfReferential) {
+                        $otherKeys = array_keys($mapping->relationToTargetKeyColumns);
+                    }
                 }
 
                 if(!$mapping->isOnDeleteCascade) {
                     $this->_conn->delete($mapping->joinTable['name'], array_combine($keys, $identifier));
+
+                    if ($selfReferential) {
+                        $this->_conn->delete($mapping->joinTable['name'], array_combine($otherKeys, $identifier));
+                    }
                 }
             }
         }
diff --git a/tests/Doctrine/Tests/ORM/Functional/ClassTableInheritanceTest.php b/tests/Doctrine/Tests/ORM/Functional/ClassTableInheritanceTest.php
index 78d5d7987..5ba6b2aa7 100644
--- a/tests/Doctrine/Tests/ORM/Functional/ClassTableInheritanceTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/ClassTableInheritanceTest.php
@@ -300,7 +300,7 @@ class ClassTableInheritanceTest extends \Doctrine\Tests\OrmFunctionalTestCase
      */
     public function testDeleteJoinTableRecords()
     {
-        $this->markTestSkipped('Nightmare! friends adds both ID 6-7 and 7-6 into two rows of the join table. How to detect this?');
+        #$this->markTestSkipped('Nightmare! friends adds both ID 6-7 and 7-6 into two rows of the join table. How to detect this?');
 
         $employee1 = new CompanyEmployee();
         $employee1->setName('gblanco');