vous pouvez faire SQL server pour sélectionner les dernières N lignes en utilisant ce SQL:

select * from tbl_name order by id desc limit N;

j'ai testé le code de JonVD, mais j'ai trouvé qu'il était très lent, 6s.

ce code a pris 0s.

SELECT TOP(5) ORDERID, CUSTOMERID, OrderDate    
FROM Orders where EmployeeID=5    
Order By OrderDate DESC

si vous voulez sélectionner les derniers nombres de lignes d'une table.

syntaxe sera comme

 select * from table_name except select top 
 (numbers of rows - how many rows you want)* from table_name

ces déclarations fonctionnent mais de manière différente. merci les gars.

 select * from Products except select top (77-10) * from Products

de cette façon, vous pouvez obtenir les 10 dernières lignes mais l'ordre montrera la manière de descendre

select top 10 * from products
 order by productId desc 

 select * from products
 where productid in (select top 10 productID from products)
 order by productID desc

 select * from products where productID not in 
 (select top((select COUNT(*) from products ) -10 )productID from products)

est-ce que " Id " est indexé? Si non, c'est une chose importante à faire (je soupçonne que c'est déjà indexé).

aussi, devez-vous retourner toutes les colonnes? Vous pouvez être en mesure d'obtenir une amélioration substantielle de la vitesse si vous avez seulement réellement besoin d'un plus petit sous - ensemble de colonnes qui peuvent être entièrement couverts par l'index sur la colonne ID-par exemple, si vous avez un index non corrigé sur la colonne Id, sans autres champs inclus dans l'index, alors il devrait faire une recherche sur le index cluster pour obtenir effectivement le reste des colonnes de retour et qui pourrait être de faire beaucoup du coût de la requête. Si c'est un index CLUSTERED, ou un index non clustered qui inclut tous les autres champs que vous voulez retourner dans la requête, alors vous devriez être bien.

D'abord, vous obtenez le plus grand nombre de disques de

 Declare @TableRowsCount Int
 select @TableRowsCount= COUNT(*) from <Your_Table>

et ensuite:

in SQL Server 2012

SELECT *
FROM  <Your_Table> As L
ORDER BY L.<your Field>
OFFSET <@TableRowsCount-@N> ROWS
FETCH NEXT @N ROWS ONLY;

in SQL Server 2008

SELECT *
FROM 
(
SELECT ROW_NUMBER() OVER(ORDER BY ID) AS sequencenumber, *
FROM  <Your_Table>
    Order By <your Field>
) AS TempTable
WHERE sequencenumber > @TableRowsCount-@N 

de manière très générale et pour supporter SQL server voici

SELECT TOP(N) *
FROM tbl_name
ORDER BY tbl_id DESC

et pour la performance, il n'est pas mauvais (moins d'une seconde pour plus de 10.000 enregistrements sur la machine serveur)

Voici quelque chose que vous pouvez essayer sans un order by mais je pense qu'il exige que chaque ligne est unique. N est le nombre de lignes que vous voulez, L est le nombre de lignes dans la table.

select * from tbl_name except select top L-N * from tbl_name

comme indiqué ci-dessus, les lignes qui sont retournées ne sont pas définies.

EDIT: c'est en fait chien lent. Aucune valeur vraiment.

select * from (select top 6 * from vwTable order by Hours desc) T order by Hours

cette requête renvoie les N dernières lignes dans le bon ordre, mais sa performance est médiocre""

select *
from (
    select top N *
    from TableName t
    order by t.[Id] desc
) as temp
order by temp.[Id]

ce n'est peut-être pas tout à fait la bonne réponse à la question, mais ...

OFFSET clause

la clause OFFSET number vous permet de sauter un nombre de lignes et ensuite retourner les lignes.

que doc link est à Postgres; Je ne sais pas si cela s'applique à Sybase/MS SQL Server.

DECLARE @MYVAR  NVARCHAR(100)
DECLARE @step  int
SET @step = 0;


DECLARE MYTESTCURSOR CURSOR
DYNAMIC 
FOR
SELECT col FROM [dbo].[table]
OPEN MYTESTCURSOR
FETCH LAST FROM MYTESTCURSOR INTO @MYVAR
print @MYVAR;


WHILE @step < 10
BEGIN   
    FETCH PRIOR FROM MYTESTCURSOR INTO @MYVAR
        print @MYVAR;
        SET @step = @step + 1;
END   
CLOSE MYTESTCURSOR
DEALLOCATE MYTESTCURSOR

Une technique que j'utilise pour interroger le les PLUS RÉCENTES lignes dans les très grandes tables (+de 100 millions de dollars, ou 1+ milliards de lignes) est la limitation de la requête à la "lecture" d'un seul "N" pourcentage de ces DERNIÈRES LIGNES. Ce sont des applications du monde réel, par exemple je le fais pour des données météorologiques récentes non historiques, ou des recherches récentes de flux de nouvelles ou des données de localisation GPS récentes.

C'est un énorme amélioration de la performance si vous savez avec certitude que vos lignes sont dans le TOP 5% Le plus récent du tableau par exemple. Ainsi, même s'il y a des indices sur les tableaux, cela limite encore les possibilités à seulement 5% des lignes dans les tableaux qui ont 100+ millions ou 1+ milliards de lignes. C'est particulièrement le cas lorsque des données plus anciennes nécessiteront disque physique lit et non seulement logique en mémoire lit.

This est bien plus efficace que SELECT TOP | PERCENT / LIMIT car il ne sélectionne pas les lignes, mais limite simplement la partie des données à rechercher.

DECLARE @RowIdTableA BIGINT
DECLARE @RowIdTableB BIGINT
DECLARE @TopPercent FLOAT

-- Given that there is an Sequential Identity Column
-- Limit query to only rows in the most recent TOP 5% of rows
SET @TopPercent = .05
SELECT @RowIdTableA = (MAX(TableAId) - (MAX(TableAId) * @TopPercent)) FROM TableA
SELECT @RowIdTableB = (MAX(TableBId) - (MAX(TableBId) * @TopPercent)) FROM TableB

SELECT *
FROM TableA a
INNER JOIN TableB b ON a.KeyId = b.KeyId
WHERE a.Id > @RowIdTableA AND b.Id > @RowIdTableB AND
      a.SomeOtherCriteria = 'Whatever'

pour afficher les 3 dernières lignes sans utiliser order by :

select * from Lms_Books_Details where Book_Code not in 
 (select top((select COUNT(*) from Lms_Books_Details ) -3 ) book_code from Lms_Books_Details) 

essayez la syntaxe EXCEPT .

Quelque chose comme ceci:

   SELECT * 
    FROM   clientDetails 
    EXCEPT 
    (SELECT TOP (numbers of rows - how many rows you want) * 
     FROM   clientDetails)