Supprimer OrderBy à partir d'un IQueryable <T>

Question

J'ai une API de pagination qui renvoie les lignes demandées par un utilisateur, mais seulement en même temps, et non pas la totalité de la collection. L'API fonctionne comme prévu, mais je dois calculer le nombre total d'enregistrements disponibles (pour les calculs de page appropriés). Dans l'API, j'utilise Linq2Sql et je travaille beaucoup avec le IQueryable avant de faire mes demandes. Quand je vais obtenir le compte, j'appelle quelque chose comme: totalRecordCount = queryable.Count();

Le SQL qui en résulte n'en est pas moins intéressant, mais il ajoute également un ordre inutile qui rend la requête très coûteuse.

exec sp_executesql N'SELECT COUNT(*) AS [value] 
FROM (
    SELECT TOP (1) NULL AS [EMPTY] 
    FROM [dbo].[JournalEventsView] AS [t0] 
    WHERE [t0].[DataOwnerID] = @p0 
    ORDER BY [t0].[DataTimeStamp] DESC 
    ) AS [t1]',N'@p0 int',@p0=1 

Parce que je suis en utilisant le IQueryable, je peux manipuler le IQueryable avant qu'il fait sur le serveur SQL.

Ma question est, si j'ai déjà un IQueryable avec un OrderBy, est-il possible de supprimer ce OrderBy avant d'appeler le Count()?

comme: totalRecordCount = interrogeable. NoOrder .Count();

Sinon, pas de biggie. Je vois beaucoup de questions sur OrderBy, mais pas sur la suppression d'une OrderBy de l'expression Linq.

Merci!

Answer 1

Il n'y a pas qu'un ORDER BY inutile, il y a aussi un TOP parasite (1).

SELECT TOP (1) NULL AS [EMPTY] ... 

Cette sous-sélection ne retournera que 0 ou 1 lignes. En fait, sans le TOP, il ne serait pas légal d'avoir un ORDER BY dans une sous-sélection.

La clause ORDER BY est invalide dans les vues, fonctions en ligne, les tables dérivées, les sous-requêtes et expressions de table commune, à moins que TOP ou FOR XML est également spécifié .: SELECT COUNT (*) FROM (SELECT * FROM ORDER Tableau 1 foo)

sqlfiddle

Je pense que vous avez probablement fait quelque chose de mal dans votre LINQ. Etes-vous sûr de ne pas avoir écrit .Take(1) ou similaire quelque part dans votre requête, avant d'appeler .Count()?

Ceci est faux:

IQueryable<Foo> foo = (...).OrderBy(x => x.Foo).Take(1); 
int count = foo.Count(); 

Vous devriez faire à la place:

IQueryable<Foo> foo = (...); 
Iqueryable<Foo> topOne = foo.OrderBy(x => x.Foo).Take(1); 
int count = foo.Count(); 

Answer 2

Si vous ne pouvez pas éliminer la cause racine, voici une solution:

totalRecordCount = queryable.OrderBy(x => 0).Count(); 

L'optimiseur de requêtes de SQL Server supprimera cette commande inutile. Il n'aura pas de coût d'exécution.

Answer 3

Je crains qu'il n'y ait aucun moyen facile de supprimer l'opérateur OrderBy de queryable.

Ce que vous pouvez faire, cependant, est de recréer le IQueryable en fonction de la nouvelle expression obtenue à partir de réécriture queryable.Expression (see here) en omettant l'appel OrderBy.

Answer 4

Je pense que vous avez mal implémenté votre code de pagination. Vous devez en fait interroger la base de données deux fois, une fois pour la source de données paginée et une fois pour le nombre total de lignes. C'est ainsi que l'installation devrait ressembler.

public IList<MyObj> GetPagedData(string filter, string sort, int skip, int take) 
{ 
    using(var db = new DataContext()) 
    { 
     var q = GetDataInternal(db); 
     if(!String.IsNullOrEmpty(filter)) 
     q = q.Where(filter); //Using Dynamic linq 

     if(!String.IsNullOrEmpty(sort)) 
     q = q.OrderBy(sort); //And here 

     return q.Skip(skip).Take(take).ToList(); 
    } 
} 

public int GetTotalCount(string filter) 
{ 
    using(var db = new DataContext()) 
    { 
     var q = GetDataInternal(db); 
     if(!String.IsNullOrEmpty(filter)) 
     q = q.Where(filter); //Using Dynamic linq 

     return q.Count(); //Without ordering and paging. 
    } 
} 

private static IQuerable<MyObj> GetDataInternal(DataContext db) 
{ 
    return 
     from x in db.JournalEventsView 
     where ... 
     select new ...; 
} 

Le filtrage et le tri est effectué en utilisant la Dynamic linq library

Answer 5

Ainsi, le code ci-dessous est une pointe contre une matrice en mémoire. Il peut y avoir quelques obstacles pour que cela fonctionne avec Entity Framework (ou une autre implémentation arbitraire IQueryProvider). Fondamentalement, ce que nous allons faire est de visiter l'arbre d'expression et de chercher n'importe quel appel de méthode d'ordre et simplement le retirer de l'arbre. J'espère que cela vous indique la bonne direction.

class Program 
{ 
    static void Main(string[] args) 
    { 
     var seq = new[] { 1, 3, 5, 7, 9, 2, 4, 6, 8 }; 

     var query = seq.OrderBy(x => x); 

     Console.WriteLine("Print out in reverse order."); 
     foreach (var item in query) 
     { 
      Console.WriteLine(item); 
     } 

     Console.WriteLine("Prints out in original order"); 
     var queryExpression = seq.AsQueryable().OrderBy(x => x).ThenByDescending(x => x).Expression; 

     var queryDelegate = Expression.Lambda<Func<IEnumerable<int>>>(new OrderByRemover().Visit(queryExpression)).Compile(); 

     foreach (var item in queryDelegate()) 
     { 
      Console.WriteLine(item); 
     } 


     Console.ReadLine(); 
    } 
} 

public class OrderByRemover : ExpressionVisitor 
{ 
    protected override Expression VisitMethodCall(MethodCallExpression node) 
    { 
     if (node.Method.DeclaringType != typeof(Enumerable) && node.Method.DeclaringType != typeof(Queryable)) 
      return base.VisitMethodCall(node); 

     if (node.Method.Name != "OrderBy" && node.Method.Name != "OrderByDescending" && node.Method.Name != "ThenBy" && node.Method.Name != "ThenByDescending") 
      return base.VisitMethodCall(node); 

     //eliminate the method call from the expression tree by returning the object of the call. 
     return base.Visit(node.Arguments[0]); 
    } 
} 

Answer 6

Je sais que ce n'est pas tout à fait ce que vous recherchez, mais index sur [DataOwnerID] avec l'inclusion de DataTimeStamp pourrait rendre votre requête moins cher.