EF prend pour toujours générer cette requête

Question

J'ai une relation de parent-enfant. Dans un dépôt, je fais ceci:

return (from p in _ctx.Parents 
.Include("Children") 
select p).AsQueryable<Parent>(); 

Puis dans un filtre, je veux faire un filtrage du parent par une liste des enfants ids:

IQueryable<Parent> qry; // from above 
List<int> ids; // huge list (8500) 
var filtered = 
from p in qry.Where(p => p.Children.Any(c => ids.Contains(c.ChildId))) select s; 

Ma liste de ids est énorme. Cela génère une instruction SQL simple qui possède une énorme liste d'identifiants "in (1,2,3 ...)", mais cela ne prend pas beaucoup de temps pour s'exécuter tout seul. EF, cependant, prend environ une minute complète juste pour générer la déclaration. Je l'ai prouvé en fixant un point d'arrêt et d'appeler:

((ObjectQuery<Parent>)filtered).ToTraceString(); 

Cela prend tout le temps. Est-ce que le problème est dans ma dernière déclaration linq? Je ne connais pas d'autre moyen de faire l'équivalent de Child.ChildId dans (ids). Et même si ma déclaration de linq est mauvaise, comment dans le monde cela devrait-il prendre tant de temps?

Answer 1

Réécrivez votre requête dans la syntaxe Lambda et cela réduira le temps de 3 secondes (ou du moins pour mon projet EF).

return _ctx.Parents.Include("Children").AsQueryable<Parent>(); 

et

IQueryable<Parent> qry; // from above 
List<int> ids; // huge list (8500) 
var filtered = qry.Where(p => p.Children.Any(c => ids.Contains(c.ChildId))); 

Answer 2

Malheureusement, les requêtes de construction dans LINQ to Entities est un coup assez lourd, mais je l'ai trouvé enregistre habituellement le temps en raison de la capacité de construire des requêtes de leurs pièces constitutives avant en train de frapper la base de données.

Il est probable que la façon dont ils implémentent la méthode Contient utilise un algorithme qui suppose que Contient est généralement utilisé pour un ensemble de données relativement petit. Selon mes tests, le temps qu'il faut par ID dans la liste commence à monter en flèche à environ 8000.

Ainsi, il peut être utile de diviser votre requête en plusieurs parties. Regroupez-les en groupes de 1000 ou moins et concaténez un groupe d'expressions Where.

var idGroups = ids.GroupBy(i => i/1000); 
var q = Parents.Include("Children").AsQueryable(); 
var newQ = idGroups.Aggregate(q, 
    (s, g) => s.Concat(
        q.Where(w => w.Children.Any(wi => g.Contains(wi.ChildId))))); 

Cela accélère de manière significative, mais il pourrait ne pas être assez significative pour vos besoins, dans ce cas, vous devrez recourir à une procédure stockée. Malheureusement, ce cas d'utilisation ne correspond tout simplement pas à la "boîte" du comportement Entity Framework attendu. Si votre liste d'identifiants pouvait commencer comme une requête provenant du même contexte d'entité, Entity Framework aurait fonctionné correctement.