Spring Data JPA – JPQL

JPQL : Introduction et concepts de base

Le cours sur JPQL (Java Persistence Query Language) aborde les requêtes utilisées dans le cadre de Spring Data JPA. JPQL est une version orientée objet de SQL, permettant de sélectionner des objets d'une entité en utilisant les noms des attributs et le nom de la classe de l’entité, plutôt que ceux de la table de base de données. Ce document présente les principales requêtes, y compris SELECT, UPDATE, DELETE et INSERT, ainsi que l'utilisation des annotations @Query, @Modifying et @Param.

Requêtes JPQL

Requêtes SELECT

Les requêtes SELECT en JPQL permettent de récupérer des objets d'entité. Par exemple, pour récupérer les clients ayant une profession donnée, on peut utiliser la requête suivante :

@Query("SELECT c FROM Client c WHERE c.profession= :profession")
List<Client> retrieveClientsByProfession(@Param("profession") Profession profession);

Cette requête est équivalente à :

@Query("SELECT c FROM Client c WHERE c.profession= ?1")
List<Client> retrieveClientsByProfession(Profession profession);

En utilisant une Native Query, la requête serait :

@Query(value = "SELECT * FROM T_Client c WHERE c.profession= :profession", nativeQuery = true)
List<Client> retrieveClientsByProfession(@Param("profession") Profession profession);

Requêtes UPDATE

Pour effectuer une mise à jour dans la base de données, il est nécessaire d'ajouter l'annotation @Modifying. Par exemple, pour mettre à jour la catégorie d'un client en fonction de sa profession, on peut utiliser la requête suivante :

@Modifying
@Query("update Client c set c.categorieClient = :categorie where c.profession = :profession")
int updateClientCategorieByProfession(@Param("categorie") CategorieClient categorieClient, @Param("profession") Profession profession);

Requêtes DELETE

Pour supprimer des clients ayant une profession et une catégorie spécifiques, la requête JPQL suivante peut être utilisée :

@Modifying
@Query("DELETE FROM Client c WHERE c.categorieClient= :categorie AND c.profession = :profession")
int deleteClientByCategorieClientAndProfession(@Param("categorie") CategorieClient categorieClient, @Param("profession") Profession profession);

Requêtes INSERT

Les requêtes INSERT ne sont pas prises en charge par JPQL, il est donc nécessaire d'utiliser des Native Queries. Voici un exemple d'insertion d'un client :

@Modifying
@Query(value = "INSERT INTO Client (nom, prenom, dateNaissance, email, password, profession, categorieClient) VALUES (:nom, :prenom, :dateN, :email, :password, :profession, :categorieClient)", nativeQuery = true)
void insertClient(@Param("nom") String nom, @Param("prenom") String prenom, @Param("dateN") Date dateNaissance, @Param("email") String email, @Param("password") String password, @Param("profession") Profession profession, @Param("categorieClient") CategorieClient categorieClient);

Exercice pratique

Pour mettre en pratique vos connaissances, essayez de créer une requête pour sélectionner tous les clients nés entre le 01/01/1995 et le 31/12/1995, d'abord en SQL, puis en JPQL.

Points clés à retenir

• JPQL est orienté objet et utilise des entités plutôt que des tables.
• Les annotations @Query et @Modifying sont essentielles pour manipuler les données.
• Les requêtes INSERT doivent être réalisées avec des Native Queries.

Glossaire des termes clés

• JPQL : Java Persistence Query Language, langage de requête orienté objet.
• Native Query : Requête SQL standard utilisée dans le contexte de JPA.
• @Query : Annotation utilisée pour définir une requête personnalisée.
• @Modifying : Annotation indiquant qu'une méthode modifie la base de données.
• @Param : Annotation utilisée pour lier des paramètres dans les requêtes.

Questions fréquentes

Quelle est la différence entre JPQL et SQL ?

JPQL est orienté objet et permet de travailler avec des entités, tandis que SQL est un langage de requête standard pour les bases de données relationnelles. JPQL utilise les noms des classes et des attributs, alors que SQL utilise les noms des tables et des colonnes.

Comment utiliser l'annotation @Query en JPQL ?

L'annotation @Query permet de définir des requêtes personnalisées dans les méthodes de repository. Par exemple, vous pouvez spécifier une requête JPQL pour récupérer des entités en fonction de certains critères.

Quelles méthodes sont utilisées pour mettre à jour des données avec JPQL ?

Pour mettre à jour des données, vous devez utiliser l'annotation @Modifying en conjonction avec @Query. Cela permet d'exécuter des requêtes de mise à jour, de suppression ou d'insertion dans la base de données.

Comment faire une requête INSERT en JPQL ?

JPQL ne prend pas en charge les requêtes INSERT. Vous devez utiliser une Native Query pour insérer des données dans la base de données.

Quels types de requêtes peut-on effectuer avec JPQL ?

Avec JPQL, vous pouvez effectuer des requêtes SELECT, UPDATE et DELETE. Cependant, pour les requêtes INSERT, vous devez utiliser des Native Queries.