Pourquoi LINQ JOIN est-il tellement plus rapide que la liaison avec WHERE?

J'ai récemment mis à niveau vers VS 2010 et je joue avec LINQ to Dataset. J'ai un ensemble de données fortement typé pour l'autorisation qui se trouve dans HttpCache d'une application Web ASP.NET.

Je voulais donc savoir quel est en fait le moyen le plus rapide de vérifier si un utilisateur est autorisé à faire quelque chose. Voici mon datamodel et quelques autres informations si quelqu'un est intéressé.

J'ai vérifié 3 façons:

1. base de données directe
2. Requête LINQ avec des conditions Where comme "Join" - Syntaxe
3. Requête LINQ avec Join - Syntaxe

Voici les résultats avec 1000 appels sur chaque fonction:

1. itération:

1. 4,2841519 sec.
2. 115,7796925 sec.
3. 2,024749 sec.

2. itération:

1. 3,1954857 sec.
2. 84 97047 sec.
3. 1,5783397 sec.

3. itération:

1. 2,7922143 sec.
2. 97,8713267 sec.
3. 1,8432163 sec.

Moyenne:

1. Base de données: 3,4239506333 sec.
2. Où: 99,5404964 sec.
3. Rejoindre: 1,815435 sec.

Pourquoi la version Join est-elle tellement plus rapide que la syntaxe where, ce qui la rend inutile alors qu'en tant que débutant LINQ, elle semble être la plus lisible. Ou ai-je manqué quelque chose dans mes requêtes?

Voici les requêtes LINQ, je saute la base de données:

Où :

Public Function hasAccessDS_Where(ByVal accessRule As String) As Boolean
    Dim userID As Guid = DirectCast(Membership.GetUser.ProviderUserKey, Guid)
    Dim query = From accRule In Authorization.dsAuth.aspnet_AccessRule, _
                roleAccRule In Authorization.dsAuth.aspnet_RoleAccessRule, _
                role In Authorization.dsAuth.aspnet_Roles, _
                userRole In Authorization.dsAuth.aspnet_UsersInRoles _
                Where accRule.idAccessRule = roleAccRule.fiAccessRule _
                And roleAccRule.fiRole = role.RoleId _
                And userRole.RoleId = role.RoleId _
                And userRole.UserId = userID And accRule.RuleName.Contains(accessRule)
                Select accRule.idAccessRule
    Return query.Any
End Function

Joindre:

Public Function hasAccessDS_Join(ByVal accessRule As String) As Boolean
    Dim userID As Guid = DirectCast(Membership.GetUser.ProviderUserKey, Guid)
    Dim query = From accRule In Authorization.dsAuth.aspnet_AccessRule _
                Join roleAccRule In Authorization.dsAuth.aspnet_RoleAccessRule _
                On accRule.idAccessRule Equals roleAccRule.fiAccessRule _
                Join role In Authorization.dsAuth.aspnet_Roles _
                On role.RoleId Equals roleAccRule.fiRole _
                Join userRole In Authorization.dsAuth.aspnet_UsersInRoles _
                On userRole.RoleId Equals role.RoleId _
                Where userRole.UserId = userID And accRule.RuleName.Contains(accessRule)
                Select accRule.idAccessRule
    Return query.Any
End Function

Merci d'avance.

Edit : après quelques améliorations sur les deux requêtes pour obtenir des valeurs de performance plus significatives, l'avantage du JOIN est même plusieurs fois plus important qu'avant:

Rejoindre :

Public Overloads Shared Function hasAccessDS_Join(ByVal userID As Guid, ByVal idAccessRule As Int32) As Boolean
    Dim query = From accRule In Authorization.dsAuth.aspnet_AccessRule _
                   Join roleAccRule In Authorization.dsAuth.aspnet_RoleAccessRule _
                   On accRule.idAccessRule Equals roleAccRule.fiAccessRule _
                   Join role In Authorization.dsAuth.aspnet_Roles _
                   On role.RoleId Equals roleAccRule.fiRole _
                   Join userRole In Authorization.dsAuth.aspnet_UsersInRoles _
                   On userRole.RoleId Equals role.RoleId _
                   Where accRule.idAccessRule = idAccessRule And userRole.UserId = userID
             Select role.RoleId
    Return query.Any
End Function

Où :

Public Overloads Shared Function hasAccessDS_Where(ByVal userID As Guid, ByVal idAccessRule As Int32) As Boolean
    Dim query = From accRule In Authorization.dsAuth.aspnet_AccessRule, _
           roleAccRule In Authorization.dsAuth.aspnet_RoleAccessRule, _
           role In Authorization.dsAuth.aspnet_Roles, _
           userRole In Authorization.dsAuth.aspnet_UsersInRoles _
           Where accRule.idAccessRule = roleAccRule.fiAccessRule _
           And roleAccRule.fiRole = role.RoleId _
           And userRole.RoleId = role.RoleId _
           And accRule.idAccessRule = idAccessRule And userRole.UserId = userID
           Select role.RoleId
    Return query.Any
End Function

Résultat pour 1000 appels (sur un ordinateur plus rapide)

1. Rejoindre | 2. Où

1. itération:

1. 0,0713669 sec.
2. 12,7395299 sec.

2. itération:

1. 0,0492458 sec.
2. 12,3885925 sec.

3. itération:

1. 0,0501982 sec.
2. 13,3474216 sec.

Moyenne:

1. Joindre: 0,0569367 sec.
2. Où: 12,8251813 sec.

L'adhésion est 225 fois plus rapide

Conclusion: évitez WHERE de spécifier des relations et utilisez JOIN dans la mesure du possible (certainement dans LINQ to DataSet et Linq-To-Objectsen général).

1. Votre première approche (requête SQL dans la base de données) est assez efficace car la base de données sait comment effectuer une jointure. Mais cela n'a pas vraiment de sens de le comparer avec les autres approches, car ils fonctionnent directement en mémoire (Linq to DataSet)

2. La requête avec plusieurs tables et une Wherecondition effectue en fait un produit cartésien de toutes les tables, puis filtre les lignes qui satisfont à la condition. Cela signifie que la Wherecondition est évaluée pour chaque combinaison de lignes (n1 * n2 * n3 * n4)

3. L' Joinopérateur prend les lignes des premières tables, puis prend uniquement les lignes avec une clé correspondante de la deuxième table, puis uniquement les lignes avec une clé correspondante de la troisième table, et ainsi de suite. C'est beaucoup plus efficace, car il n'est pas nécessaire d'effectuer autant d'opérations

Le Joinest beaucoup plus rapide, car la méthode sait combiner les tableaux pour réduire le résultat aux combinaisons pertinentes. Lorsque vous utilisez Wherepour spécifier la relation, il doit créer toutes les combinaisons possibles, puis tester la condition pour voir quelles combinaisons sont pertinentes.

La Joinméthode peut configurer une table de hachage à utiliser comme index pour compresser rapidement deux tables ensemble, tandis que la Whereméthode s'exécute une fois que toutes les combinaisons sont déjà créées, de sorte qu'elle ne peut utiliser aucune astuce pour réduire les combinaisons au préalable.

ce que vous devez vraiment savoir, c'est le SQL qui a été créé pour les deux instructions. Il existe plusieurs moyens d'y parvenir, mais le plus simple est d'utiliser LinqPad. Il y a plusieurs boutons juste au-dessus des résultats de la requête qui changeront en sql. Cela vous donnera beaucoup plus d'informations qu'autre chose.

Excellente information que vous avez partagée là-bas.