Comment faire pour récupérer le total du nombre de lignes d'une requête avec le HAUT

J'ai une requête SQL Server 2008

SELECT TOP 10 *
FROM T
WHERE ...
ORDER BY ...

J'aimerais avoir aussi le nombre total de lignes. Le obious façon est de faire une deuxième requête

SELECT COUNT(*)
FROM T
WHERE ...
ORDER BY ...

Est-il une méthode efficace?

Grâce

OriginalL'auteur | 2009-03-04

4

Voulez-vous une deuxième requête?
```
SELECT TOP 10
    *, foo.bar
FROM
    T
    CROSS JOIN
    (SELECT COUNT(*) AS bar FROM T WHERE ...) foo
WHERE
    ...
ORDER BY
    ...
```
OU
```
DECLARE @bar int
SELECT @bar = COUNT(*) AS bar FROM T WHERE ...
SELECT TOP 10
    *, @bar
FROM
    T
    CROSS JOIN
    (SELECT COUNT(*) AS bar FROM T WHERE ...) foo
WHERE
    ...
ORDER BY
    ...
```
Ou (Edit: de l'utiliser AVEC)
```
WITH cTotal AS
(
    SELECT COUNT(*) AS bar FROM T WHERE ...)
)
SELECT TOP 10
    *, cTotal .bar
FROM
    T
WHERE
    ...
ORDER BY
    ...
```
Je voudrais éviter une deuxième requête. Peut-être avec d'instruction ou de tables temporaires? Je ne suis pas expert de sql server
Des exemples 1 et 3 sont de simples requêtes et fonctionnellement identiques.
Ok, je veux dire que je voudrais éviter un deuxième "analyse de la table". Je voudrais faire le moteur de scan seulement une fois que la table, afin de récupérer le nombre total et le n lignes.
Vous ne pouvez pas. Ils sont 2 différentes constructions de requête. Le COMTE va effectivement être très efficace, probablement plus que la requête principale, car il sera utiliser le plus efficace

OriginalL'auteur gbn
2

Qu'est-ce que dans cette réponse semble fonctionner:

https://stackoverflow.com/a/19125458/16241

Fondamentalement, vous faites un:
```
SELECT top 100 YourColumns, TotalCount = Count(*) Over()
From YourTable
Where SomeValue = 32
```
TotalCount aura le nombre total de lignes. Elle est inscrite sur chaque ligne.

Quand je l'ai testé ce le plan de requête a montré la table que d'être frappé une fois.

Le plan d'exécution ne montrons que cette requête frappe la table qu'une seule fois, mais il est beaucoup plus lent que l'une des options fournies dans le réponse par gbn, pour des raisons inconnues de moi. Votre code cependant semble plus simple, et est mieux adapté pour l'utilisation avec de grandes requêtes déjà existant dans le projet.

OriginalL'auteur Vaccano
1

Supprimer la clause ORDER BY à partir de la 2ème requête.

OriginalL'auteur Joel Coehoorn
1

Pas.

SQL Server permet de ne pas garder COUNT(*) dans les métadonnées comme MyISAM, il calcule à chaque fois.

Mise à JOUR: Si vous avez besoin d'une estimation, vous pouvez utiliser les statistiques de métadonnées:
```
SELECT  rows
FROM    dbo.sysindexes
WHERE   name = @primary_key,
```
où @primary_key est de votre table de clé primaire nom.

Ce sera le retour de la COUNT(*) de la dernière mise à jour des statistiques.

êtes-vous dire à mysql, vous pouvez faire "SELECT * from t_user OÙ...la LIMITE de 0,20" et il y a les méta-données pour le nombre total de lignes dans la mémoire? De sorte que je n'ai pas à faire une deuxième requête avec la fonction COUNT()?
OH, j'ai juste répondu à ma propre question...SQL_CALC_FOUND_ROWS et FOUND_ROWS() fait le travail..merci!

OriginalL'auteur Quassnoi
0
```
SELECT     TOP (2) *,
           (SELECT COUNT(*) AS Expr1 FROM T) AS C
FROM         T
```
Ne serait-ce pas faire "SELECT COUNT(*) Expr1 DE T" pour chaque ligne de sortie? Dans ce cas, 10 lignes
Je n'ai pas profilé cela, mais je pense que ce serait en fait plus lent, car il est dans une sous-requête et retourné dans chaque ligne. Je ne suis pas un gourou bien, le serveur est peut-être assez intelligent pour mettre en cache. Même encore, je ne pense pas qu'il serait tout rapide que les deux requêtes, car il est toujours en cours d'exécution.

OriginalL'auteur Learning

Vous devez vous connecter pour publier un commentaire.