web-dev-qa-db-fra.com

Requête nommée ou requête native ou requête Quel est le meilleur en termes de performances?

Lequel est le meilleur parmi les suivants (EJB 3 JPA)

//Question

une). getEntityManager (). createQuery ("sélectionnez o dans Utilisateur o");

// Requête nommée où findAllUser est défini au niveau de l'entité

b) getEntityManager (). createNamedQuery ("User.findAllUser"); **

// Requête native

c) getEntityManager (). createNativeQuery ("SELECT * FROM TBLMUSER");

Veuillez m'expliquer quelle approche est la meilleure dans quel cas?.

javaejb-3.0
12
Jekin Kalariya

  1. createQuery ()

    Il devrait être utilisé pour la création de requêtes dynamiques.

    //Example dynamic query
StringBuilder builder = new StringBuilder("select e from Employee e");
if (empName != null) {
    builder.append(" where e.name = ?");
}
getEntityManager().createQuery(builder.toString());

  2. createNamedQuery ()

    C'est comme variable constante et réutilisable, et vous devriez l'utiliser dans les appels de base de données communs comme; rechercher tous les utilisateurs, rechercher par identifiant, etc.

  3. createNativeQuery ()

    Cela dépend totalement du script SQL supporté par la base de données sous-jacente. 

    C'est utile lorsqu'une requête complexe est requise et que la syntaxe JPQL ne la prend pas en charge.

    Mais cela peut avoir un impact sur votre application et nécessiter plus de travail si la base de données sous-jacente est modifiée de l'une à l'autre. Exemple, par exemple, si votre environnement de développement utilise MySQL et que votre environnement de production utilise Oracle. + Et la liaison de résultat renvoyée peut être complexe si plusieurs résultats sont obtenus.

22
Wundwin Born

Le SQL natif n'est pas nécessairement plus rapide que Hibernate/JPA Query. Hibernate/JPA Query est enfin traduit en SQL. Dans certains cas, cela peut arriver. Hibernate/JPA ne génère pas les instructions les plus efficaces. Le SQL natif peut donc être plus rapide. Toutefois, avec le SQL natif, votre application perd la portabilité d'une base de données à une autre. Il est donc préférable de régler Hibernate/JPA. Mappage des requêtes et instruction HQL pour générer des instructions SQL plus efficaces. De l'autre côté avec le SQL natif, il manque le cache Hibernate - en conséquence, dans certains cas, le SQL natif peut être plus lent que Hibernate/JPA Query.

Je ne suis pas avec la performance, dans la plupart des cas pour la performance, il est sans importance si vous chargez toutes les colonnes ou seulement les colonnes nécessaires. Dans l'accès à la base de données, le temps est perdu lors de la recherche dans la ligne et non lors du transfert des données dans votre application. Lorsque vous ne lisez que les colonnes nécessaires.

1
Kirtan Patel

Les requêtes nommées sont les mêmes que les requêtes. Ils sont nommés uniquement pour qu'ils soient réutilisables + ils peuvent être déclarés à divers endroits, par exemple. dans les mappages de classe, les fichiers de configuration, etc. (vous pouvez donc changer de requête sans changer de code actaul)

Les requêtes natives ne sont que des requêtes natives, vous devez faire tout ce que les requêtes JPA font pour vous, par exemple. Reliant et citant des valeurs, etc. + ils utilisent une syntaxe indépendante DBMP (JPQL dans votre cas) afin de changer de système de base de données (permet à saq de MySQL de devenir Postgresql ou H2) nécessitera moins de travail car il ne nécessite pas (pas toujours) de réécrire les requêtes natives.

0
Antoniossss

Pour moi, le mieux est évidemment les deux premiers, c'est-à-dire Requêtes JPQL - le second signifie que le gestionnaire d'entités compilera les requêtes (et les validera) tout en chargeant l'unité de persistance, tandis que le premier ne produira que des erreurs au moment de l'exécution.

Vous pouvez également obtenir une assistance dans certains IDE, qui prennent en charge la notation objet (par exemple: select b from EntityA a left join a.entityB b) et certaines autres bizarreries introduites par le mappage objet-relationnel (comme les collections, les index, etc.).

D'autre part, utilisez les requêtes natives en dernier recours dans le cas de JPQL (comme la fonction window, telle que select id, partition by (group_id) from table)

0
NoDataFound