Doctrine 2 - ORM
  1. Doctrine 2 - ORM
  2. DDC-113

Cascaded persist avoids LifecycleCallbacks

    Details

    • Type: Bug Bug
    • Status: Closed
    • Priority: Critical Critical
    • Resolution: Fixed
    • Affects Version/s: 2.0-ALPHA3
    • Fix Version/s: 2.0-ALPHA4
    • Component/s: ORM
    • Security Level: All
    • Labels:
      None

      Description

      When an Entity is created by 'cascade=

      {"persist"}

      ', its LifecycleCallbacks (e.g. "PrePersist"!) are not invoked.

      When it is persisted explicitly, everything workes fine and the events are called...

        Activity

        Hide
        Roman S. Borschel added a comment -

        Should be fixed now.

        Show
        Roman S. Borschel added a comment - Should be fixed now.
        Hide
        Roman S. Borschel added a comment -

        I have a fix for this ready, however, I want to look into something else before committing. I'll address this over the weekend.

        Show
        Roman S. Borschel added a comment - I have a fix for this ready, however, I want to look into something else before committing. I'll address this over the weekend.
        Hide
        Nico Kaiser added a comment -

        From a technical point of view this is ok - but from an intuitive point of view I would think I can use persist whereever I want. So I can create an entity, persist it (so it gets written to the DB), make changes to it (like adding entities to its collection) and getting its saved (and the collection entities persisted) when I call flush().

        So I suspect lifecycle events to be called whenever an entity is persisted. And in this case LifecycleCallbackTestEntity's are persisted automatically by flush() (and this is after the Cascader is persisted!), so lifecycle events should fire here.

        Show
        Nico Kaiser added a comment - From a technical point of view this is ok - but from an intuitive point of view I would think I can use persist whereever I want. So I can create an entity, persist it (so it gets written to the DB), make changes to it (like adding entities to its collection) and getting its saved (and the collection entities persisted) when I call flush(). So I suspect lifecycle events to be called whenever an entity is persisted. And in this case LifecycleCallbackTestEntity's are persisted automatically by flush() (and this is after the Cascader is persisted!), so lifecycle events should fire here.
        Hide
        Benjamin Eberlei added a comment - - edited

        That is valid behaviour according to the lifecycle of an entity, persist gets cascaded right and only when ->persist() is called.

        In the case you show, the two entities are also not persisted, because the cascade was already executed.

        Show
        Benjamin Eberlei added a comment - - edited That is valid behaviour according to the lifecycle of an entity, persist gets cascaded right and only when ->persist() is called. In the case you show, the two entities are also not persisted, because the cascade was already executed.
        Hide
        Nico Kaiser added a comment -

        There is still an issue. You can reproduce it if you change the test case slightly to this:

            /**
             * @group DDC-113
             */
            public function testCascadedEntitiesCallsPrePersist()
            {
                $e1 = new LifecycleCallbackTestEntity;
                $e2 = new LifecycleCallbackTestEntity;
        
                $c = new LifecycleCallbackCascader();
                
                $this->_em->persist($c);
                
                $c->entities[] = $e1;
                $c->entities[] = $e2;
        
                //$this->_em->persist($c);
                $this->_em->flush();
        
                $this->assertTrue($e1->prePersistCallbackInvoked);
                $this->assertTrue($e2->prePersistCallbackInvoked);
            }
        

        The difference to the existing (and indeed working) test case is that the Cascader entity is persisted before the collection entries are added.

        Show
        Nico Kaiser added a comment - There is still an issue. You can reproduce it if you change the test case slightly to this: /** * @group DDC-113 */ public function testCascadedEntitiesCallsPrePersist() { $e1 = new LifecycleCallbackTestEntity; $e2 = new LifecycleCallbackTestEntity; $c = new LifecycleCallbackCascader(); $this->_em->persist($c); $c->entities[] = $e1; $c->entities[] = $e2; //$this->_em->persist($c); $this->_em->flush(); $this->assertTrue($e1->prePersistCallbackInvoked); $this->assertTrue($e2->prePersistCallbackInvoked); } The difference to the existing (and indeed working) test case is that the Cascader entity is persisted before the collection entries are added.
        Hide
        Benjamin Eberlei added a comment -

        Works for me on trunk, added test-case that proves it (Doctrine\Tests\ORM\Functional\LifecycleCallbackTest::testCascadedEntitiesCallsPrePersist())

        Show
        Benjamin Eberlei added a comment - Works for me on trunk, added test-case that proves it (Doctrine\Tests\ORM\Functional\LifecycleCallbackTest::testCascadedEntitiesCallsPrePersist())

          People

          • Assignee:
            Roman S. Borschel
            Reporter:
            Nico Kaiser
          • Votes:
            0 Vote for this issue
            Watchers:
            0 Start watching this issue

            Dates

            • Created:
              Updated:
              Resolved: