Esta é uma pergunta conhecida, mas a melhor solução que encontrei é algo como:

SELECT TOP N *
FROM MyTable
ORDER BY Id DESC

Eu tenho uma mesa com muitas linhas. Não é possível usar essa consulta porque leva muito tempo. Então, como posso fazer para selecionar as últimas N linhas sem usar ORDER BY?

EDITAR

Desculpe pergunta duplicada deste

Você pode fazer isso usando o recurso ROW NUMBER BY PARTITION. Um ótimo exemplo pode ser encontrado aqui :

Estou usando a tabela Pedidos do banco de dados Northwind ... Agora, vamos recuperar os últimos 5 pedidos feitos pelo Funcionário 5:

SELECT ORDERID, CUSTOMERID, OrderDate
FROM
(
    SELECT ROW_NUMBER() OVER (PARTITION BY EmployeeID ORDER BY OrderDate DESC) AS OrderedDate,*
    FROM Orders
) as ordlist

WHERE ordlist.EmployeeID = 5
AND ordlist.OrderedDate <= 5

Você pode fazer com que o SQL server selecione as últimas N linhas usando este SQL:

select * from tbl_name order by id desc limit N;

Testei o código do JonVD, mas achei muito lento, 6s.

Este código levou 0s.

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

Se você deseja selecionar o último número de linhas de uma tabela.

Sintaxe será como

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

Essas declarações funcionam de maneiras diferentes. obrigado pessoal

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

Desta forma, você pode obter as últimas 10 linhas, mas a ordem mostrará o modo decrescente

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)

De uma maneira muito geral e para oferecer suporte ao SQL Server, aqui está

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

e para o desempenho, não é ruim (menos de um segundo para mais de 10.000 registros na máquina do servidor)

O "ID" está indexado? Caso contrário, isso é uma coisa importante a se fazer (suspeito que já esteja indexado).

Além disso, você precisa retornar TODAS as colunas? Você poderá obter uma melhoria substancial na velocidade se, na verdade, precisar apenas de um subconjunto menor de colunas que possa ser INTEGRALMENTE atendido pelo índice na coluna ID - por exemplo, se você tiver um índice NÃO EXCLUSIVO na coluna Id, sem outra campos incluídos no índice, seria necessário fazer uma pesquisa no índice clusterizado para que o restante das colunas retornasse e isso poderia estar compensando muito o custo da consulta. Se é um índice CLUSTERED ou NONCLUSTERED que inclui todos os outros campos que você deseja retornar na consulta, então você deve estar bem.

Primeiro, você obtém a contagem de registros mais

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

E depois :

No SQL Server 2012

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

No 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 

Aqui está algo que você pode tentar sem um, order bymas acho que exige que cada linha seja única. Né o número de linhas que você deseja, Lé o número de linhas na tabela.

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

Como observado anteriormente, quais linhas são retornadas são indefinidas.

EDIT: este é realmente cachorro lento. De nenhum valor realmente.

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

Essa consulta retorna as últimas N linhas na ordem correta, mas seu desempenho é ruim

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

use desc com orderby no final da consulta para obter os últimos valores.

Isso pode não ser o ajuste certo para a pergunta, mas…

Cláusula OFFSET

A OFFSET numbercláusula permite que você pule um número linhas e depois retorne as linhas.

Esse link de documento é para o Postgres; Não sei se isso se aplica ao 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

O MS não suporta LIMIT no t-sql. Na maioria das vezes, eu apenas recebo MAX (ID) e subtraio.

select * from ORDERS where ID >(select MAX(ID)-10 from ORDERS)

Isso retornará menos de 10 registros quando o ID não for seqüencial.

Uma técnica usada para consultar as linhas MAIS RECENTES em tabelas muito grandes (mais de 100 milhões ou mais de 1 bilhão de linhas) está limitando a consulta a "ler" apenas a porcentagem "N" mais recente de LINHAS RECENTES. São aplicativos do mundo real, por exemplo, faço isso para Dados Meteorológicos Recentes não históricos, ou pesquisas recentes de feeds de Notícias ou dados recentes de pontos de dados de localização GPS.

Essa é uma grande melhoria de desempenho se você tiver certeza de que suas linhas estão entre os TOP 5% mais recentes da tabela, por exemplo. De modo que, mesmo que existam índices nas Tabelas, ele limita ainda mais as possibilidades a apenas 5% das linhas em tabelas que possuem mais de 100 milhões ou mais de 1 bilhão de linhas. Esse é especialmente o caso quando Dados Antigos exigirão leituras de Disco Físico e não apenas Memória Lógica leituras da .

Isso é bem mais eficiente que o SELECT TOP | PERCENT | LIMIT, pois não seleciona as linhas, mas limita apenas a parte dos dados a serem pesquisados.

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'

Para exibir as últimas 3 linhas sem usar 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) 

Tente usar a EXCEPTsintaxe.
Algo assim:

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

Talvez um pouco tarde, mas aqui está uma seleção simples que resolve sua pergunta.

SELECT * FROM "TABLE" T ORDER BY "T.ID_TABLE" DESC LIMIT 5;