From fe8e1cb8ea1caf31fa24b7a70dad366559d8c331 Mon Sep 17 00:00:00 2001 From: Matthias Pigulla Date: Tue, 21 Feb 2023 22:26:57 +0000 Subject: [PATCH] Add test: Entity insertions must not happen table-wise Add tests for entity insertion and deletion that require writes to different tables in an interleaved fashion, and that have to re-visit a particular table. #### Background In #10531, I've given an example where it is necessary to compute the commit order on the entity (instead of table) level. Taking a closer look at the UoW to see how this could be achieved, I noticed that the current, table-level commit order manifests itself also in the API between the UoW and `EntityPersister`s. #### Current situation The UoW computes the commit order on the table level. All entity insertions for a particular table are passed through `EntityPersister::addInsert()` and finally written through `EntityPersister::executeInserts()`. #### Suggested change The test in this PR contains a carefully constructed set of four entities. Two of them are of the same class (are written to the same table), but require other entities to be processed first. In order to be able to insert this set of entities, the ORM must be able to perform inserts for a given table repeatedly, interleaved with writing other entities to their respective tables. --- .../ORM/Functional/Ticket/GH10532Test.php | 177 ++++++++++++++++++ 1 file changed, 177 insertions(+) create mode 100644 tests/Doctrine/Tests/ORM/Functional/Ticket/GH10532Test.php diff --git a/tests/Doctrine/Tests/ORM/Functional/Ticket/GH10532Test.php b/tests/Doctrine/Tests/ORM/Functional/Ticket/GH10532Test.php new file mode 100644 index 00000000000..3ed0cd04d95 --- /dev/null +++ b/tests/Doctrine/Tests/ORM/Functional/Ticket/GH10532Test.php @@ -0,0 +1,177 @@ +createSchemaForModels( + GH10532A::class, + GH10532B::class, + GH10532C::class, + GH10532X::class + ); + } + + public function testInserts(): void + { + // Dependencies are $a1 -> $b -> $a2 -> $c + + $a1 = new GH10532A(); + $b = new GH10532B(); + $a2 = new GH10532A(); + $c = new GH10532C(); + + $a1->x = $b; + $b->a = $a2; + $a2->x = $c; + + /* + * The following would force a working commit order, but that's not what + * we want (the ORM shall sort this out internally). + * + * $this->_em->persist($c); + * $this->_em->persist($a2); + * $this->_em->flush(); + * $this->_em->persist($b); + * $this->_em->persist($a1); + * $this->_em->flush(); + */ + + $this->_em->persist($a1); + $this->_em->persist($a2); + $this->_em->persist($b); + $this->_em->persist($c); + $this->_em->flush(); + + self::assertNotNull($a1->id); + self::assertNotNull($b->id); + self::assertNotNull($a2->id); + self::assertNotNull($c->id); + } + + public function testDeletes(): void + { + // Dependencies are $a1 -> $b -> $a2 -> $c + + $this->expectNotToPerformAssertions(); + $con = $this->_em->getConnection(); + + // The "c" entity + $con->insert('gh10532_x', ['id' => 1, 'discr' => 'C']); + $con->insert('gh10532_c', ['id' => 1]); + $c = $this->_em->find(GH10532C::class, 1); + + // The "a2" entity + $con->insert('gh10532_a', ['id' => 2, 'gh10532x_id' => 1]); + $a2 = $this->_em->find(GH10532A::class, 2); + + // The "b" entity + $con->insert('gh10532_x', ['id' => 3, 'discr' => 'B']); + $con->insert('gh10532_b', ['id' => 3, 'gh10532a_id' => 2]); + $b = $this->_em->find(GH10532B::class, 3); + + // The "a1" entity + $con->insert('gh10532_a', ['id' => 4, 'gh10532x_id' => 3]); + $a1 = $this->_em->find(GH10532A::class, 4); + + /* + * The following would make the deletions happen in an order + * where the not-nullable foreign key constraints would not be + * violated. But, we want the ORM to be able to sort this out + * internally. + * + * $this->_em->remove($a1); + * $this->_em->flush(); + * $this->_em->remove($b); + * $this->_em->flush(); + * $this->_em->remove($a2); + * $this->_em->remove($c); + * $this->_em->flush(); + */ + + $this->_em->remove($a1); + $this->_em->remove($a2); + $this->_em->remove($b); + $this->_em->remove($c); + + $this->_em->flush(); + } +} + +/** + * @ORM\Entity + * @ORM\Table(name="gh10532_x") + * @ORM\DiscriminatorColumn(name="discr", type="string") + * @ORM\DiscriminatorMap({ "B": "GH10532B", "C": "GH10532C" }) + * @ORM\InheritanceType("JOINED") + * + * We are using JTI here, since STI would relax the not-nullable constraint for the "parent" + * column. Causes another error, but not the constraint violation I'd like to point out. + */ +abstract class GH10532X +{ + /** + * @ORM\Id + * @ORM\GeneratedValue(strategy="AUTO") + * @ORM\Column(type="integer") + * + * @var int + */ + public $id; +} + +/** + * @ORM\Entity + * @ORM\Table(name="gh10532_b") + */ +class GH10532B extends GH10532X +{ + /** + * @ORM\ManyToOne(targetEntity="GH10532A") + * @ORM\JoinColumn(nullable=false, name="gh10532a_id") + * + * @var GH10532A + */ + public $a; +} + +/** + * @ORM\Entity + * @ORM\Table(name="gh10532_c") + */ +class GH10532C extends GH10532X +{ +} + +/** + * @ORM\Entity + * @ORM\Table(name="gh10532_a") + */ +class GH10532A +{ + /** + * @ORM\Id + * @ORM\GeneratedValue(strategy="AUTO") + * @ORM\Column(type="integer") + * + * @var int + */ + public $id; + + /** + * @ORM\ManyToOne(targetEntity="GH10532X") + * @ORM\JoinColumn(nullable=false, name="gh10532x_id") + * + * @var GH10532X + */ + public $x; +}