QueryWrapper dans MyBatis permet de construire des conditions SQL de manière fluide et dynamique. Il étend AbstractWrapper et intègre des fonctionnalités pour générer des clauses WHERE avancées, y compris le support de LambdaQueryWrapper via la méthode lambda().

1. Vérification d'égalité et d'inégalité

La méthode eq teste l'égalité avec une valeur donnée, tandis que ne vérifie l'inégalité.

@Test
public void verifierEgalite() {
    QueryWrapper<Utilisateur> criteria = new QueryWrapper<>();
    criteria.eq("nom_utilisateur", "jean_dupont");
    Utilisateur utilisateur = utilisateurService.getOne(criteria);
    System.out.println(utilisateur);
}

@Test
public void verifierInegalite() {
    QueryWrapper<Utilisateur> criteria = new QueryWrapper<>();
    criteria.ne("statut", 1);
    List<Utilisateur> liste = utilisateurService.list(criteria);
    System.out.println(liste);
}

2. Comparaisons numériques

Pour les comparaisons numériques, utilisez gt (strictement supérieur), ge (supérieur ou égal), lt (strictement inférieur) et le (inférieur ou égal).

@Test
public void comparerValeursNumeriques() {
    QueryWrapper<Produit> critereSuperieur = new QueryWrapper<>();
    critereSuperieur.gt("prix", 50.0);
    List<Produit> produitsChers = produitService.list(critereSuperieur);
    System.out.println(produitsChers);

    QueryWrapper<Produit> critereInferieur = new QueryWrapper<>();
    critereInferieur.le("stock", 10);
    List<Produit> produitsStockBas = produitService.list(critereInferieur);
    System.out.println(produitsStockBas);
}

3. Plages et intevralles

La méthode between sélectionne les valeurs dans un intervalle, et notBetween exclut cet intervalle.

@Test
public void filtrerParIntervalle() {
    QueryWrapper<Commande> critereIntervalle = new QueryWrapper<>();
    critereIntervalle.between("montant_total", 100, 500);
    List<Commande> commandes = commandeService.list(critereIntervalle);
    System.out.println(commandes);
}

4. Recherhces par motif

Pour les recherches floues, like applique '%valeur%', likeLeft '%valeur', et likeRight 'valeur%'. Utilisez notLike pour exclure des motifs.

@Test
public void rechercherParMotif() {
    QueryWrapper<Article> critereMotif = new QueryWrapper<>();
    critereMotif.like("titre", "technique");
    List<Article> articles = articleService.list(critereMotif);
    System.out.println(articles);
}

5. Gestion des valeurs nulles

isNull vérifie si un champ est NULL, et isNotNull s'assure qu'il ne l'est pas.

@Test
public void gererValeursNulles() {
    QueryWrapper<Client> critereNul = new QueryWrapper<>();
    critereNul.isNull("email");
    List<Client> clientsSansEmail = clientService.list(critereNul);
    System.out.println(clientsSansEmail);
}

6. Filtrage par liste de valeurs

Avec in, filtrez les enregistrements correspondant à une liste de valeurs, et notIn pour les exclure.

@Test
public void filtrerParListe() {
    QueryWrapper<Employe> critereListe = new QueryWrapper<>();
    critereListe.in("departement", "IT", "RH", "Finance");
    List<Employe> employes = employeService.list(critereListe);
    System.out.println(employes);
}

7. Combinaison de conditions

Utilisez or pour des conditions alternatives et and pour des conditions cumulatives. Par défaut, les conditions sont liées par AND.

@Test
public void combinerConditions() {
    QueryWrapper<Produit> critereCombine = new QueryWrapper<>();
    critereCombine.gt("prix", 100).or().eq("categorie", "Électronique");
    List<Produit> produits = produitService.list(critereCombine);
    System.out.println(produits);
}

8. Tri des résultats

Pour trier les données, utilisez orderByAsc pour un ordre croissant et orderByDesc pour un ordre décroissant.

@Test
public void trierResultats() {
    QueryWrapper<Transaction> critereTri = new QueryWrapper<>();
    critereTri.orderByDesc("date_transaction");
    List<Transaction> transactions = transactionService.list(critereTri);
    System.out.println(transactions);
}

9. Sous-requêtes SQL

Bien que moins courantes, inSql et notInSql permettent d'intégrer des sous-requêtes SQL pour des filtrages complexes.

@Test
public void utiliserSousRequetes() {
    QueryWrapper<Utilisateur> critereSousRequete = new QueryWrapper<>();
    critereSousRequete.inSql("id_utilisateur", "SELECT id FROM utilisateurs_actifs");
    List<Utilisateur> utilisateursActifs = utilisateurService.list(critereSousRequete);
    System.out.println(utilisateursActifs);
}

10. Existence de sous-requêtes

exists et notExists vérifient l'existecne de résultats dans une sous-requête SQL.

@Test
public void verifierExistenceSousRequete() {
    QueryWrapper<Commande> critereExistence = new QueryWrapper<>();
    critereExistence.exists("SELECT 1 FROM details_commande WHERE commande_id = id");
    List<Commande> commandesAvecDetails = commandeService.list(critereExistence);
    System.out.println(commandesAvecDetails);
}