All'eliminazione della cascata con doctrine2

Sto cercando di fare un semplice esempio per imparare come eliminare una riga da una tabella padre ed eliminare automaticamente le righe corrispondenti nella tabella figlio usando Doctrine2.

Ecco le due entità che sto usando:

Child.php:

<?php

namespace Acme\CascadeBundle\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 * @ORM\Table(name="child")
 */
class Child {

    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;
    /**
     * @ORM\ManyToOne(targetEntity="Father", cascade={"remove"})
     *
     * @ORM\JoinColumns({
     *   @ORM\JoinColumn(name="father_id", referencedColumnName="id")
     * })
     *
     * @var father
     */
    private $father;
}

Father.php

<?php
namespace Acme\CascadeBundle\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 * @ORM\Table(name="father")
 */
class Father
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;
}

Le tabelle sono state create correttamente nel database, ma l'opzione On Elimina cascata non è stata creata. Che cosa sto facendo di sbagliato?

Ci sono due tipi di cascate in Dottrina:

1) Livello ORM - utilizza cascade={"remove"}nell'associazione - questo è un calcolo che viene eseguito in UnitOfWork e non influisce sulla struttura del database. Quando rimuovi un oggetto, UnitOfWork eseguirà l'iterazione su tutti gli oggetti dell'associazione e li rimuoverà.

2) Livello database - utilizza onDelete="CASCADE"su joinColumn dell'associazione - questo aggiungerà Su Elimina Cascade alla colonna chiave esterna nel database:

@ORM\JoinColumn(name="father_id", referencedColumnName="id", onDelete="CASCADE")

Voglio anche sottolineare che il modo in cui hai il tuo cascade = {"remove"} in questo momento, se elimini un oggetto Child, questa cascata rimuoverà l'oggetto Parent. Chiaramente non quello che vuoi.

Ecco un semplice esempio. Un contatto ha uno o più numeri di telefono associati. Quando un contatto viene eliminato, voglio che vengano eliminati anche tutti i numeri di telefono associati, quindi utilizzo ON DELETE CASCADE. La relazione uno-a-molti / molti-a-uno è implementata dalla chiave esterna nei numeri di telefono.

CREATE TABLE contacts
 (contact_id BIGINT AUTO_INCREMENT NOT NULL,
 name VARCHAR(75) NOT NULL,
 PRIMARY KEY(contact_id)) ENGINE = InnoDB;

CREATE TABLE phone_numbers
 (phone_id BIGINT AUTO_INCREMENT NOT NULL,
  phone_number CHAR(10) NOT NULL,
 contact_id BIGINT NOT NULL,
 PRIMARY KEY(phone_id),
 UNIQUE(phone_number)) ENGINE = InnoDB;

ALTER TABLE phone_numbers ADD FOREIGN KEY (contact_id) REFERENCES \
contacts(contact_id) ) ON DELETE CASCADE;

Aggiungendo "ON DELETE CASCADE" al vincolo di chiave esterna, i numeri di telefono verranno automaticamente eliminati quando viene eliminato il loro contatto associato.

INSERT INTO table contacts(name) VALUES('Robert Smith');
INSERT INTO table phone_numbers(phone_number, contact_id) VALUES('8963333333', 1);
INSERT INTO table phone_numbers(phone_number, contact_id) VALUES('8964444444', 1);

Ora, quando una riga nella tabella dei contatti viene eliminata, tutte le righe dei numeri di telefono associati verranno automaticamente eliminate.

DELETE TABLE contacts as c WHERE c.id=1; /* delete cascades to phone_numbers */

Per ottenere lo stesso risultato in Doctrine, per ottenere lo stesso comportamento "ON DELETE CASCADE" a livello di DB, devi configurare @JoinColumn con l' opzione onDelete = "CASCADE" .

<?php
namespace Entities;

use Doctrine\Common\Collections\ArrayCollection;

/**
 * @Entity
 * @Table(name="contacts")
 */
class Contact 
{

    /**
     *  @Id
     *  @Column(type="integer", name="contact_id") 
     *  @GeneratedValue
     */
    protected $id;  

    /** 
     * @Column(type="string", length="75", unique="true") 
     */ 
    protected $name; 

    /** 
     * @OneToMany(targetEntity="Phonenumber", mappedBy="contact")
     */ 
    protected $phonenumbers; 

    public function __construct($name=null)
    {
        $this->phonenumbers = new ArrayCollection();

        if (!is_null($name)) {

            $this->name = $name;
        }
    }

    public function getId()
    {
        return $this->id;
    }

    public function setName($name)
    {
        $this->name = $name;
    }

    public function addPhonenumber(Phonenumber $p)
    {
        if (!$this->phonenumbers->contains($p)) {

            $this->phonenumbers[] = $p;
            $p->setContact($this);
        }
    }

    public function removePhonenumber(Phonenumber $p)
    {
        $this->phonenumbers->remove($p);
    }
}

<?php
namespace Entities;

/**
 * @Entity
 * @Table(name="phonenumbers")
 */
class Phonenumber 
{

    /**
    * @Id
    * @Column(type="integer", name="phone_id") 
    * @GeneratedValue
    */
    protected $id; 

    /**
     * @Column(type="string", length="10", unique="true") 
     */  
    protected $number;

    /** 
     * @ManyToOne(targetEntity="Contact", inversedBy="phonenumbers")
     * @JoinColumn(name="contact_id", referencedColumnName="contact_id", onDelete="CASCADE")
     */ 
    protected $contact; 

    public function __construct($number=null)
    {
        if (!is_null($number)) {

            $this->number = $number;
        }
    }

    public function setPhonenumber($number)
    {
        $this->number = $number;
    }

    public function setContact(Contact $c)
    {
        $this->contact = $c;
    }
} 
?>

<?php

$em = \Doctrine\ORM\EntityManager::create($connectionOptions, $config);

$contact = new Contact("John Doe"); 

$phone1 = new Phonenumber("8173333333");
$phone2 = new Phonenumber("8174444444");
$em->persist($phone1);
$em->persist($phone2);
$contact->addPhonenumber($phone1); 
$contact->addPhonenumber($phone2); 

$em->persist($contact);
try {

    $em->flush();
} catch(Exception $e) {

    $m = $e->getMessage();
    echo $m . "<br />\n";
}

Se adesso lo fai

# doctrine orm:schema-tool:create --dump-sql

vedrai che lo stesso SQL verrà generato come nel primo esempio raw-SQL