web-dev-qa-db-fra.com

doctrine: QueryBuilder vs createQuery?

Dans Doctrine vous pouvez créer DQL de 2 manières:

EntityManager :: createQuery:

$query = $em->createQuery('SELECT u FROM MyProject\Model\User u WHERE u.id = ?1');

QueryBuilder:

$qb->add('select', 'u')
   ->add('from', 'User u')
   ->add('where', 'u.id = ?1')
   ->add('orderBy', 'u.name ASC');

Je me demande quelle est la différence et laquelle dois-je utiliser?

doctrine-orm
67
never_had_a_name

  1. DQL est plus facile à lire car il est très similaire à SQL. Si vous n'avez pas besoin de modifier la requête en fonction d'un ensemble de paramètres, c'est probablement le meilleur choix.

  2. Query Builder est une API pour construire des requêtes, il est donc plus facile si vous avez besoin de construire une requête dynamiquement comme l'itération sur un ensemble de paramètres ou de filtres. Vous n'avez pas besoin de faire d'opérations de chaîne pour construire votre requête comme join, split ou autre.

64
jackbravo

Le générateur de requêtes est juste, disons, une interface pour créer une requête ... Il devrait être plus confortable à utiliser, il n'a pas seulement la méthode add (), mais aussi des méthodes comme where (), etWhere (), from (), etc. Mais au final, il compose simplement une requête comme celle que vous utilisez dans la méthode createQuery ().

Exemple d'utilisation plus avancée du générateur de requêtes:

$em->createQueryBuilder()
            ->from('Project\Entities\Item', 'i')
            ->select("i, e")
            ->join("i.entity", 'e')
            ->where("i.lang = :lang AND e.album = :album")
            ->setParameter('lang', $lang)
            ->setParameter('album', $album);
32
Martin Kočička

Ils ont des objectifs différents:

  • DQL est plus facile à utiliser lorsque vous connaissez votre requête complète.
  • Le générateur de requêtes est plus intelligent lorsque vous devez créer votre requête en fonction de certaines conditions, boucles, etc.
13
Vincent Pazeller

La principale différence est la surcharge de l'appel des méthodes. Votre premier exemple de code (createQuery) juste pour la simplicité fait un appel de méthode, tandis que le queryBuilder en fait 4. À la fin de tout, ils se résument à une chaîne qui doit être exécutée, premier exemple vous lui donnez la chaîne, et l'autre vous le construisez avec plusieurs appels de méthode chaînés.

Si vous cherchez une raison d'utiliser l'un sur l'autre, c'est une question de style et de ce qui semble plus lisible. Pour moi, j'aime le queryBuider la plupart du temps, il fournit des sections bien définies pour la requête. En outre, dans le passé, il était plus facile d'ajouter de la logique conditionnelle lorsque vous en aviez besoin.

4
NiteRain

Il peut être plus facile de tester les unités lors de l'utilisation du générateur de requêtes. Supposons que vous ayez un référentiel qui interroge certaines données en se basant sur la liste compliquée de conditions. Et vous voulez vous assurer que si une condition particulière est passée dans le référentiel, d'autres conditions sont ajoutées dans la requête. En cas de DQL, vous avez deux options:

1) Pour utiliser des appareils et tester l'interaction réelle avec DB. Ce que je trouve un peu gênant et non unitaire.

2) Pour vérifier le code DQL généré. Ce qui peut rendre votre test trop fragile.

Avec QueryBuilder, vous pouvez le remplacer par mock et vérifier que la méthode "andWhere" avec le paramètre nécessaire est appelée. Bien entendu, ces considérations ne s'appliquent pas si votre requête est simple et ne dépend d'aucun paramètre.

1
Dienow