J'ai essayé de rassembler peu d'informations sur les méthodes suivantes pour supprimer automatiquement l'entité enfant lorsqu'une entité parent est supprimée. Il semble que le moyen le plus courant consiste à utiliser l'une de ces trois annotations: cascade = {"remove"} OR orphanRemoval = true OR ondelete = "CASCADE" .
Je suis un peu confus à propos du troisième: ondelete = "CASCADE", comme explication dans doctrine la documentation officielle à propos de celui-ci est très rare) et j'aimerais beaucoup que quelqu'un puisse me confirmer les informations suivantes que j'ai recueillies et que je comprends de mes recherches sur le net et expérience ...
cascade = {"remove"}
==> l'entité du côté inverse est supprimée lorsque l'entité du côté propriétaire est. Même si vous faites partie de nombreuses personnes avec une autre entité propriétaire.
- doit être utilisé lors de la collecte (donc dans les relations OneToMany ou ManyToMany)
- mise en œuvre dans l'ORM
orphanRemoval = true
==> l'entité du côté inverse est supprimée lorsque l'entité propriétaire est AND et elle n'est plus connectée à aucune autre entité propriétaire. (réf. doctrine official_doc - implémentation dans l'ORM
- peut être utilisé avec OneToOne, OnetoMany ou ManyToMany
onDelete = "CASCADE"
==> Ceci ajoutera On Delete Cascade à la colonne de clé étrangère de la base de données.
- Cette stratégie est un peu délicate à comprendre, mais elle peut être très puissante et rapide. (réf. doctrine official_doc ... mais je n'ai pas lu plus d'explications)
- ORM doit faire moins de travail (par rapport aux deux méthodes précédentes) et devrait donc avoir de meilleures performances.
autres informations
- toutes ces 3 façons de faire sont implémentées sur des entités relationnelles bidirectionnelles ( right ??? )
- using cascade = {"remove"} contourne complètement toute clé étrangère onDelete = CASCADE. (réf. doctrine_official_doc )
cascade = {"remove"}
/**
* @OneToMany(targetEntity="Phonenumber", mappedBy="contact", cascade={"remove"})
*/
protected $Phonenumbers
orphanRemoval = true
/**
* @OneToMany(targetEntity="Phonenumber", mappedBy="contact", orphanRemoval=true)
*/
protected $Phonenumbers
onDelete = "CASCADE"
/**
* @ManyToOne(targetEntity="Contact", inversedBy="phonenumbers")
* @JoinColumn(name="contact_id", referencedColumnName="contact_id", onDelete="CASCADE")
*/
protected $contact;
onDelete="CASCADE"
est géré par la base de données elle-même. cascade={"remove"}
est géré par la doctrine.
onDelete="CASCADE"
est plus rapide car les opérations sont effectuées au niveau de la base de données à la place par la doctrine. La suppression est effectuée par le serveur de base de données et non par Doctrine. Avec cascade={"remove"}
doctrine doit gérer l'entité elle-même et procédera à des vérifications supplémentaires pour voir si elle ne possède pas d'autres entités propriétaires. Si aucune autre n'existe, cela supprimera l'entité. Mais cela créera une surcharge .
cascade = {"remove"}
orphanRemoval = "true"
onDelete = "CASCADE"