Możesz sprawić, że SQL server wybierze Ostatnie n wierszy używając tego SQL:

select * from tbl_name order by id desc limit N;

Przetestowałem Kod JonVD, ale okazało się, że był bardzo powolny, 6s.

Ten kod zajął 0s.

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

Jeśli chcesz wybrać ostatnie liczby wierszy z tabeli.

Składnia będzie jak

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

Te stwierdzenia działają, ale w inny sposób. dziękuję.

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

W ten sposób możesz uzyskać ostatnie 10 wierszy, ale kolejność pokaże sposób descndingu

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)

Czy" Id " jest indeksowane? Jeśli nie, to jest to ważna rzecz do zrobienia (podejrzewam, że jest już zindeksowana).

Również, czy trzeba zwracać wszystkie kolumny? Możesz być w stanie uzyskać znaczną poprawę szybkości, jeśli potrzebujesz tylko mniejszego podzbioru kolumn, który może być w pełni zaspokajany przez indeks w kolumnie ID - np. jeśli masz NIEZAKLUSTROWANY indeks w kolumnie Id, bez innych pól zawartych w indeksie, to będzie musiał wykonać wyszukiwanie na indeksie klastrowym, aby faktycznie uzyskać reszta kolumn do powrotu i to może stanowić dużo kosztów zapytania. Jeśli jest to indeks klastrowy lub indeks NIEZAKLUSTROWANY, który zawiera wszystkie inne pola, które chcesz zwrócić w zapytaniu, to powinno być dobrze.

Najpierw najczęściej otrzymujesz liczbę rekordów z

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

A następnie:

W SQL Server 2012

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

W 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 

W bardzo ogólny sposób i do obsługi SQL server tutaj jest

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

I jak na wydajność, nie jest źle (mniej niż jedna sekunda dla ponad 10 000 rekordów na maszynie serwerowej)

Oto coś, czego możesz spróbować Bez order by, ale myślę, że wymaga to, aby każdy wiersz był wyjątkowy. N to żądana liczba wierszy, {[3] } to liczba wierszy w tabeli.

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

Jak wspomniano wcześniej, które wiersze są zwracane jest niezdefiniowane.

EDIT: to jest naprawdę dog slow. Nie ma żadnej wartości.

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

To zapytanie zwraca Ostatnie n wierszy w prawidłowej kolejności, ale jego wydajność jest słaba

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

Może to nie pasuje do pytania, ale ... ]}

Klauzula offsetowa

The OFFSET number klauzula umożliwia pominięcie liczby wierszy, a następnie zwrócenie wierszy.

Ten link doc jest do Postgres; Nie wiem czy dotyczy to 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

Technika, której używam do odpytywania ostatnich wierszy w bardzo dużych tabelach (100+ milion lub 1 + miliard wierszy) ogranicza zapytanie do "odczytu" tylko najnowszego " N " procentu ostatnich wierszy. Jest to aplikacja w świecie rzeczywistym, na przykład robię to dla niehistorycznych ostatnich danych pogodowych lub ostatnich wyszukiwań kanałów informacyjnych lub ostatnich danych lokalizacji GPS.

Jest to ogromna poprawa wydajności jeśli wiesz na pewno, że Twoje rzędy są w najnowsze TOP 5% tabeli na przykład. Takie, że nawet jeśli istnieją indeksy na tabelach, to dodatkowo ogranicza możliwości tylko do 5% wierszy w tabelach, które mają 100+ milionów lub 1 + miliardów wierszy. Dzieje się tak zwłaszcza wtedy, gdy starsze dane wymagają odczytu dysku fizycznego, a nie tylko odczytu logicznego w pamięci.

Jest to znacznie bardziej wydajne niż SELECT TOP / procent / LIMIT, ponieważ nie wybiera wierszy, a jedynie ogranicza część danych, które mają być / align = "left" /

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'

Aby wyświetlić ostatnie 3 wiersze bez użycia 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) 

Spróbuj użyć składni EXCEPT.
Coś takiego:

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