Techniques pour vérifier si une relation existe dans Doctrine2

Je n'arrive pas à trouver de mention dans la Doctrine de la documentation sur la façon de vérifier si une entité a un lien à une autre entité:

http://www.doctrine-project.org/docs/orm/2.0/en/reference/working-with-associations.html

Dans La Doctrine 1.x il existe une méthode appelée exists qui pourrait être appelé une entité à vérifier:

http://www.doctrine-project.org/documentation/manual/1_2/en/working-with-models#dealing-with-relations:clearing-related-records

Dans la Doctrine 2.0 c'est ce que j'ai eu tendance à le faire. Quelles techniques sont d'autres personnes à l'aide?

<?php

class Group    {
    private $id;
    protected $name;
    protected $users;

    public function __construct()
    {
        $this->colorgroups = new ArrayCollection();
    }

    public function hasUsers() {
        return count($this->users) > 0;
    } 
}
+1 pour le allusive nom de profil 🙂
L'amour que le commentaire de quelqu'un qui a choisi d'y aller par @Bastardo -.-

OriginalL'auteur calumbrodie | 2011-06-03

  1. 8

    Bien - en fait, je suis tombé sur la bonne réponse aujourd'hui, tout en regardant si le type arraycollection classe. Vous devez utiliser le "vide".

    À partir du code (les commentaires sont eux, pas le mien)

    /**
 * Checks whether the collection is empty.
 * 
 * Note: This is preferrable over count() == 0.
 *
 * @return boolean TRUE if the collection is empty, FALSE otherwise.
 */
public function isEmpty()
{
    return ! $this->_elements;
}

    Donc, à partir de mon exemple

    public function hasUsers() {
        return !$this->users->isEmpty();
}

    OriginalL'auteur calumbrodie

  2. 6

    Doctrine2 utilisations différentes de l'architecture que de la Doctrine1.2. Si vous voulez vérifier si un groupe a un certain utilisateur associé avec elle, vous devez écrire une méthode hasUser(User $user) qui permettra de la déterminer:

    public function hasUser(User $user) {
    foreach ($this->users as $u) {
        if ($u->equals($user)) {
            return true;
        }
    }

    return false;
}

    Si vous voulez vérifier si une relation est conservée dans la base de données, vous devez exécuter une à la suite de requête DQL:

    SELECT 1 FROM MyProject\Entity\Group g WHERE :user MEMBER OF g.users;

    Où :user est User objet.

    Cela semble beaucoup plus détaillé que celui de ma propre méthode (1 ligne vs 6 lignes). Est-ce que votre méthode offre aucun avantage par rapport à la mienne? Merci pour la réponse.
    Super pédant mais HQL != DQL
    Ops... je l'ai fait sortir de l'habitude. 😉 Fixe. Quant à l'avantage... il n'y a aucun. Il n'y a pas plus court de solution pour vérifier si un objet appartient à la collection (en option vous pouvez utiliser type arraycollection::contains() qui fait faire tout à fait une chose semblable). Votre hasUsers() faire quelque chose d'autre et doivent être inclus juste avant ma méthode en application du monde réel par la voie.
    Bien que cette question est mort d'une mort - j'ai été intéressé de voir les différentes approches, mais la vérité est que c'est probablement pas assez compliqué de justifier plus d'une approche 🙂 Marquée comme étant correcte
    Crozin l'approche est différente car il a la capacité de vérifier si une relation existe dans un préexistante de la collection alors que kissmyface de l'vérifie uniquement si la collection existe ou pas. Je suis en train de mettre en oeuvre votre approche Crozin mais j'obtiens une erreur dictons equals() est une méthode non définie qui n'est pas surprenant étant donné que je ne peux pas trouver aucune mention nulle part dans la documentation. Pourriez-vous revenir sur votre réponse Crozin?

    OriginalL'auteur Crozin

  3. 5

    Vous pouvez utiliser la méthode Exists http://www.doctrine-project.org/api/common/2.4/class-Doctrine.Common.Collections.ArrayCollection.html#_exists quelque chose comme cela

    $someId = 123;
$p = function($key, $element) use ($someId){
     return $element->getId() == $someId;
};

$u->exists($p); //here is your result
    Nice - bien que vous devez être prudent au sujet de votre consommation de mémoire sur l'utilisation de fermetures à l'intérieur des entités. php.net/manual/en/function.create-function.php#70691
    non, vous devez être prudent au sujet de votre mémoire 😀 vous avez dit "j'ai été intéressé de voir les différentes approches" donc, ce que je... dans mon choix de cette solution est préférable, je pense, SÉLECTIONNEZ 1 DE Monprojet\Entity\Groupe g OÙ :MEMBRE utilisateur.g.utilisateurs;
    J'apprécie l'entrée - c'est toujours agréable de voir d'autres alternatives. Vous aussi m'a encouragé à consulter la requête de la classe de manière plus approfondie qui comprend toutes sortes de choses qui sont utiles mais pas entièrement documentées. Merci!

    OriginalL'auteur PayteR

  4. -1

    Alternativement, vous pouvez utiliser la gestion des exceptions

    try {

$entity = $entity->getAnotherEntity() ; //OneToOne Mapping 

}catch(\Exception $e) {

$entity = null ;

}

    P. S Plus spécifiques exception peut être utilisé pour le rendre encore meilleur .

    Êtes-vous sûr que O-O de la cartographie dans la Doctrine de lever une exception si il n'y a pas d'Entité liée? Supposons qu'il n'y aurait nulle.

    OriginalL'auteur Mr Coder

  5. -2

    Je sais que c'est une vieille question, mais il pourrait être utile à quelqu'un d'autre ou peut-être même pour vous.
    Je pense que ce que vous cherchez à la relatedExists() méthode que vous pouvez trouver ici:
    http://docs.doctrine-project.org/projects/doctrine1/en/latest/en/manual/working-with-models.html#clearing-related-records

    Espère qu'il sera utile!

    Le relatedExists fonction est pour la Doctrine1, cette question a été pour Doctrine2.

    OriginalL'auteur mattemod