C-Sharp Linq Left Join

Comment utiliser élégamment `Left Join` avec SQL Agrégé dans `LINQ`

Lorsqu’ils travaillent avec des bases de données, les développeurs se retrouvent souvent à devoir effectuer des requêtes complexes nécessitant une manipulation et une récupération efficaces des données. Une tâche courante est l’utilisation de LEFT JOIN dans des requêtes SQL combinées avec des fonctions d’agrégation. Comment pouvons-nous transformer de telles requêtes SQL en une expression LINQ élégante en C# ? Dans cet article, nous examinerons un exemple SQL puis nous plongerons dans son équivalent LINQ en décomposant le processus pour plus de clarté.

Comprendre la Requête SQL

Jetons un œil à l’instruction SQL que nous voulons traduire :

SELECT
   u.id,
   u.name,
   isnull(MAX(h.dateCol), '1900-01-01') dateColWithDefault
FROM universe u
LEFT JOIN history h 
   ON u.id = h.id 
   AND h.dateCol < GETDATE() - 1
GROUP BY u.Id, u.name

Décomposition de la Requête SQL

Sélection de Colonnes : La requête sélectionne l’ID de l’utilisateur (u.id), le nom de l’utilisateur (u.name), et la date maximale des enregistrements d’historique qui se rapportent à chaque utilisateur (MAX(h.dateCol)), par défaut à ‘1900-01-01’ si aucun enregistrement d’historique n’existe.
Jointure de Tables : Un LEFT JOIN est utilisé pour combiner les données de la table universe (u) et de la table history (h), avec une condition qui filtre les enregistrements d’historique où dateCol est plus ancienne d’un jour.
Groupement : Les résultats sont regroupés par l’ID et le nom de l’utilisateur, garantissant que chaque utilisateur n’apparaisse qu’une seule fois dans la sortie.

Traduire SQL en `LINQ`

Pour obtenir le même résultat que la requête SQL à l’aide de LINQ, nous pouvons structurer notre requête comme suit :

DateTime yesterday = DateTime.Now.Date.AddDays(-1);

var collection = 
    from u in db.Universe
    select new
    {
        u.id,
        u.name,
        MaxDate = (DateTime?)
        (
            from h in db.History
            where u.Id == h.Id
            && h.dateCol < yesterday
            select h.dateCol
        ).Max()
    };

Explication de la Requête `LINQ`

Déclaration de Variable : Nous créons une variable DateTime appelée yesterday, qui représente la date fixée à un jour avant la date actuelle. Cela reflète la logique SQL qui compare dateCol avec la date actuelle moins un jour.
Structure de la Requête :
- Clause From : Nous commençons par sélectionner les utilisateurs de la table Universe.
- Select New : Cela crée un objet anonyme pour chaque utilisateur qui inclut son id, name, et la date maximale de la table History.
Sous-Requête pour la Date Maximale :
- Nous initiions une sous-requête pour sélectionner dateCol de la table History où les ID correspondent et dateCol est antérieure à hier.
- Nous calculons ensuite la date maximale en utilisant la méthode .Max().

Remarques Supplémentaires

Gestion des Nulls : Puisque la date maximale peut potentiellement être nulle (aucun enregistrement d’historique n’existe), nous la castons en DateTime? pour permettre les valeurs nullables.
Différences d’Output : Bien que l’approche LINQ ne produise pas exactement le même SQL, elle fournit logiquement les mêmes résultats, démontrant que la traduction d’un SQL complexe en LINQ peut être nuancée.

Conclusion

Bien que traduire des requêtes SQL avec LEFT JOIN et des agrégats en LINQ puisse sembler initialement intimidant, comprendre les composants de l’instruction SQL permet une approche plus systématique pour la mapper en LINQ. En appliquant la même logique de manière claire dans des instructions LINQ, vous pouvez maintenir non seulement la fonctionnalité, mais aussi la clarté dans votre code.

Avec de la pratique, la gestion de requêtes complexes en LINQ deviendra une seconde nature, vous offrant un moyen efficace de garantir que votre récupération de données est aussi efficace que possible.

Comment utiliser élégamment Left Join avec SQL Agrégé dans LINQ