Come selezionare l'ennesima riga in una tabella del database SQL?

Sono interessato a imparare alcune (idealmente) di database agnostico modi per selezionare il n ° fila da una tabella del database. Sarebbe anche interessante vedere come questo può essere ottenuto utilizzando la funzionalità nativa dei seguenti database:

• server SQL
• MySQL
• PostgreSQL
• SQLite
• Oracolo

Attualmente sto facendo qualcosa di simile al seguente in SQL Server 2005, ma sarei interessato a vedere altri approcci più agnostici:

WITH Ordered AS (
SELECT ROW_NUMBER() OVER (ORDER BY OrderID) AS RowNumber, OrderID, OrderDate
FROM Orders)
SELECT *
FROM Ordered
WHERE RowNumber = 1000000

Ringraziamo l'SQL sopra: il blog di Firoz Ansari

Aggiornamento: vedi la risposta di Troels Arvin in merito allo standard SQL. Troels, hai qualche link che possiamo citare?

Esistono modi per farlo in parti opzionali dello standard, ma molti database supportano il proprio modo di farlo.

Un sito davvero buono che parla di questo e di altre cose è http://troels.arvin.dk/db/rdbms/#select-limit .

Fondamentalmente, PostgreSQL e MySQL supporta non standard:

SELECT...
LIMIT y OFFSET x 

Oracle, DB2 e MSSQL supporta le funzioni di windowing standard:

SELECT * FROM (
  SELECT
    ROW_NUMBER() OVER (ORDER BY key ASC) AS rownumber,
    columns
  FROM tablename
) AS foo
WHERE rownumber <= n

(che ho appena copiato dal sito collegato in precedenza poiché non uso mai quei DB)

Aggiornamento: a partire da PostgreSQL 8.4 sono supportate le funzioni di windowing standard, quindi aspettatevi che il secondo esempio funzioni anche per PostgreSQL.

Aggiornamento: SQLite ha aggiunto il supporto delle funzioni della finestra nella versione 3.25.0 del 15-09-2018, quindi entrambi i moduli funzionano anche in SQLite.

PostgreSQL supporta le funzioni di windowing definite dallo standard SQL, ma sono scomode, quindi la maggior parte delle persone usa (non standard) LIMIT/OFFSET :

SELECT
    *
FROM
    mytable
ORDER BY
    somefield
LIMIT 1 OFFSET 20;

Questo esempio seleziona la 21a riga. OFFSET 20sta dicendo a Postgres di saltare i primi 20 record. Se non specifichi una ORDER BYclausola, non esiste alcuna garanzia su quale record otterrai, il che è raramente utile.

Non sono sicuro di tutto il resto, ma so che SQLite e MySQL non hanno alcun ordine di riga "predefinito". In quei due dialetti, almeno, il frammento seguente prende la 15a voce da the_table, ordinandola per data / ora in cui è stata aggiunta:

SELECT * FROM the_table ORDER BY added DESC LIMIT 1,15

(ovviamente, dovresti avere un campo DATETIME aggiunto e impostarlo sulla data / ora in cui è stata aggiunta la voce ...)

SQL 2005 e versioni successive hanno questa funzione integrata. Utilizzare la funzione ROW_NUMBER (). È eccellente per le pagine Web con uno stile << Prec. E Succ. >>:

Sintassi:

SELECT
    *
FROM
    (
        SELECT
            ROW_NUMBER () OVER (ORDER BY MyColumnToOrderBy) AS RowNum,
            *
        FROM
            Table_1
    ) sub
WHERE
    RowNum = 23

Sospetto che sia estremamente inefficiente, ma è un approccio piuttosto semplice, che ha funzionato su un piccolo set di dati su cui l'ho provato.

select top 1 field
from table
where field in (select top 5 field from table order by field asc)
order by field desc

Questo otterrebbe il 5 ° oggetto, cambierebbe il secondo numero in alto per ottenere un altro n-esimo elemento

Solo server SQL (credo) ma dovrebbe funzionare su versioni precedenti che non supportano ROW_NUMBER ().

1 piccola modifica: n-1 anziché n.

select *
from thetable
limit n-1, 1

Verifica su SQL Server:

Select top 10 * From emp 
EXCEPT
Select top 9 * From emp

Questo ti darà la decima riga della tabella emp!

Contrariamente a quanto sostengono alcune delle risposte, lo standard SQL non tace su questo argomento.

Da SQL: 2003, è stato possibile utilizzare le "funzioni finestra" per saltare le righe e limitare i set di risultati.

E in SQL: 2008, è stato aggiunto un approccio leggermente più semplice, usando
OFFSET skip ROWS FETCH FIRST n ROWS ONLY

Personalmente, non penso che l'aggiunta di SQL: 2008 fosse davvero necessaria, quindi se fossi stato ISO, l'avrei tenuto fuori da uno standard già piuttosto grande.

Quando lavoravamo in MSSQL 2000, facevamo quello che chiamavamo "triple-flip":

MODIFICATO

DECLARE @InnerPageSize int
DECLARE @OuterPageSize int
DECLARE @Count int

SELECT @Count = COUNT(<column>) FROM <TABLE>
SET @InnerPageSize = @PageNum * @PageSize
SET @OuterPageSize = @Count - ((@PageNum - 1) * @PageSize)

IF (@OuterPageSize < 0)
    SET @OuterPageSize = 0
ELSE IF (@OuterPageSize > @PageSize)
    SET @OuterPageSize = @PageSize

DECLARE @sql NVARCHAR(8000)

SET @sql = 'SELECT * FROM
(
    SELECT TOP ' + CAST(@OuterPageSize AS nvarchar(5)) + ' * FROM
    (
        SELECT TOP ' + CAST(@InnerPageSize AS nvarchar(5)) + ' * FROM <TABLE> ORDER BY <column> ASC
    ) AS t1 ORDER BY <column> DESC
) AS t2 ORDER BY <column> ASC'

PRINT @sql
EXECUTE sp_executesql @sql

Non era elegante e non era veloce, ma ha funzionato.

SERVER SQL

Seleziona n ° record dall'alto

SELECT * FROM (
SELECT 
ID, NAME, ROW_NUMBER() OVER(ORDER BY ID) AS ROW
FROM TABLE 
) AS TMP 
WHERE ROW = n

seleziona n ° record dal basso

SELECT * FROM (
SELECT 
ID, NAME, ROW_NUMBER() OVER(ORDER BY ID DESC) AS ROW
FROM TABLE 
) AS TMP 
WHERE ROW = n

Oracolo:

select * from (select foo from bar order by foo) where ROWNUM = x

In Oracle 12c, è possibile utilizzare l' OFFSET..FETCH..ROWS opzione conORDER BY

Ad esempio, per ottenere il 3 ° record dall'alto:

SELECT * 
FROM   sometable
ORDER BY column_name
OFFSET 2 ROWS FETCH NEXT 1 ROWS ONLY;

Ecco una rapida soluzione della tua confusione.

SELECT * FROM table ORDER BY `id` DESC LIMIT N, 1

Qui puoi ottenere l'ultima riga riempiendo N = 0, la seconda ultima N = 1, la quarta ultima riempiendo N = 3 e così via.

Questa è una domanda molto comune durante l'intervista e questa è molto semplice.

Inoltre, se si desidera quantità, ID o un certo ordinamento numerico, è possibile utilizzare la funzione CAST in MySQL.

SELECT DISTINCT (`amount`) FROM cart ORDER BY CAST( `amount` AS SIGNED ) DESC LIMIT 4 , 1

Qui Compilando N = 4 Sarai in grado di ottenere il quinto ultimo record della quantità più alta dalla tabella CART. Puoi adattare il tuo campo e il nome della tabella e trovare una soluzione.

INSERISCI:

LIMIT n,1

Ciò limiterà i risultati a un risultato a partire dal risultato n.

Ad esempio, se si desidera selezionare ogni 10a riga in MSSQL, è possibile utilizzare;

SELECT * FROM (
  SELECT
    ROW_NUMBER() OVER (ORDER BY ColumnName1 ASC) AS rownumber, ColumnName1, ColumnName2
  FROM TableName
) AS foo
WHERE rownumber % 10 = 0

Basta prendere il MOD e cambiare il numero 10 qui qualsiasi numero desiderato.

Per SQL Server, un modo generico di andare per numero di riga è il seguente:

SET ROWCOUNT @row --@row = the row number you wish to work on.

Per esempio:

set rowcount 20   --sets row to 20th row

select meat, cheese from dbo.sandwich --select columns from table at 20th row

set rowcount 0   --sets rowcount back to all rows

Questo restituirà le informazioni sulla 20a fila. Assicurati di inserire il conteggio delle righe 0 in seguito.

LIMIT n, 1 non funziona in MS SQL Server. Penso che sia solo l'unico grande database che non supporta quella sintassi. Ad essere onesti, non fa parte dello standard SQL, anche se è così ampiamente supportato che dovrebbe essere. In tutto tranne SQL server LIMIT funziona alla grande. Per SQL Server, non sono stato in grado di trovare una soluzione elegante.

Ecco una versione generica di uno sproc che ho scritto di recente per Oracle che consente il paging / ordinamento dinamico - HTH

-- p_LowerBound = first row # in the returned set; if second page of 10 rows,
--                this would be 11 (-1 for unbounded/not set)
-- p_UpperBound = last row # in the returned set; if second page of 10 rows,
--                this would be 20 (-1 for unbounded/not set)

OPEN o_Cursor FOR
SELECT * FROM (
SELECT
    Column1,
    Column2
    rownum AS rn
FROM
(
    SELECT
        tbl.Column1,
        tbl.column2
    FROM MyTable tbl
    WHERE
        tbl.Column1 = p_PKParam OR
        tbl.Column1 = -1
    ORDER BY
        DECODE(p_sortOrder, 'A', DECODE(p_sortColumn, 1, Column1, 'X'),'X'),
        DECODE(p_sortOrder, 'D', DECODE(p_sortColumn, 1, Column1, 'X'),'X') DESC,
        DECODE(p_sortOrder, 'A', DECODE(p_sortColumn, 2, Column2, sysdate),sysdate),
        DECODE(p_sortOrder, 'D', DECODE(p_sortColumn, 2, Column2, sysdate),sysdate) DESC
))
WHERE
    (rn >= p_lowerBound OR p_lowerBound = -1) AND
    (rn <= p_upperBound OR p_upperBound = -1);

Ma davvero, non sono davvero solo trucchi da salotto per una buona progettazione del database? Le poche volte in cui ho avuto bisogno di funzionalità come questa è stato per una semplice query una tantum fare un rapporto rapido. Per qualsiasi lavoro reale, usare trucchi come questi è un problema invitante. Se è necessaria la selezione di una riga specifica, è sufficiente disporre di una colonna con un valore sequenziale e procedere con essa.

Per il server SQL, quanto segue restituirà la prima riga dalla tabella di assegnazione.

declare @rowNumber int = 1;
    select TOP(@rowNumber) * from [dbo].[someTable];
EXCEPT
    select TOP(@rowNumber - 1) * from [dbo].[someTable];

Puoi scorrere i valori con qualcosa del genere:

WHILE @constVar > 0
BEGIN
    declare @rowNumber int = @consVar;
       select TOP(@rowNumber) * from [dbo].[someTable];
    EXCEPT
       select TOP(@rowNumber - 1) * from [dbo].[someTable];  

       SET @constVar = @constVar - 1;    
END;

In Sybase SQL Anywhere:

SELECT TOP 1 START AT n * from table ORDER BY whatever

Non dimenticare ORDER BY o non ha senso.

T-SQL: selezione di N'th RecordNumber da una tabella

select * from
 (select row_number() over (order by Rand() desc) as Rno,* from TableName) T where T.Rno = RecordNumber

Where  RecordNumber --> Record Number to Select
       TableName --> To be Replaced with your Table Name

Ad esempio, per selezionare il 5 ° record da una tabella Employee, la query dovrebbe essere

select * from
 (select row_number() over (order by Rand() desc) as Rno,* from Employee) T where T.Rno = 5

SELECT * FROM emp a
WHERE  n = (SELECT COUNT( _rowid)
              FROM emp b
             WHERE a. _rowid >= b. _rowid);

SELECT
    top 1 *
FROM
    table_name
WHERE
    column_name IN (
        SELECT
            top N column_name
        FROM
            TABLE
        ORDER BY
            column_name
    )
ORDER BY
    column_name DESC

Ho scritto questa domanda per trovare l'ennesima riga. Esempio con questa query sarebbe

SELECT
    top 1 *
FROM
    Employee
WHERE
    emp_id IN (
        SELECT
            top 7 emp_id
        FROM
            Employee
        ORDER BY
            emp_id
    )
ORDER BY
    emp_id DESC

incredibile che puoi trovare un motore SQL che esegue questo ...

WITH sentence AS
(SELECT 
    stuff,
    row = ROW_NUMBER() OVER (ORDER BY Id)
FROM 
    SentenceType
    )
SELECT
    sen.stuff
FROM sentence sen
WHERE sen.row = (ABS(CHECKSUM(NEWID())) % 100) + 1

Niente di speciale, nessuna funzione speciale, nel caso in cui usi Caché come faccio io ...

SELECT TOP 1 * FROM (
  SELECT TOP n * FROM <table>
  ORDER BY ID Desc
)
ORDER BY ID ASC

Dato che hai una colonna ID o una colonna datestamp di cui ti puoi fidare.

È così che lo farei all'interno di DB2 SQL, credo che il RRN (numero record relativo) sia memorizzato nella tabella dall'O / S;

SELECT * FROM (                        
   SELECT RRN(FOO) AS RRN, FOO.*
   FROM FOO                         
   ORDER BY RRN(FOO)) BAR             
 WHERE BAR.RRN = recordnumber

select * from 
(select * from ordered order by order_id limit 100) x order by 
x.order_id desc limit 1;

Prima seleziona le prime 100 righe ordinando in ordine crescente, quindi seleziona l'ultima riga ordinando in ordine decrescente e limitando a 1. Tuttavia questa è una dichiarazione molto costosa in quanto accede ai dati due volte.

Mi sembra che, per essere efficiente, sia necessario 1) generare un numero casuale compreso tra 0 e uno in meno rispetto al numero di record del database e 2) essere in grado di selezionare la riga in quella posizione. Sfortunatamente, database diversi hanno generatori di numeri casuali diversi e modi diversi di selezionare una riga in una posizione in un set di risultati - di solito si specifica quante righe saltare e quante righe si desidera, ma viene fatto in modo diverso per database diversi. Ecco qualcosa che funziona per me in SQLite:

select * 
from Table 
limit abs(random()) % (select count(*) from Words), 1;

Dipende dal fatto di poter usare una sottoquery nella clausola limit (che in SQLite è LIMIT <recs da saltare>, <recs da prendere>) La selezione del numero di record in una tabella dovrebbe essere particolarmente efficiente, essendo parte del database metadati, ma ciò dipende dall'implementazione del database. Inoltre, non so se la query realizzerà effettivamente il set di risultati prima di recuperare l'ennesimo record, ma spero che non sia necessario. Nota che non sto specificando una clausola "ordina per". Potrebbe essere meglio "ordinare per" qualcosa come la chiave primaria, che avrà un indice - ottenere l'ennesimo record da un indice potrebbe essere più veloce se il database non può ottenere l'ennesimo record dal database stesso senza creare il set di risultati .

La risposta più adatta che ho visto in questo articolo per SQL Server

WITH myTableWithRows AS (
    SELECT (ROW_NUMBER() OVER (ORDER BY myTable.SomeField)) as row,*
    FROM myTable)
SELECT * FROM myTableWithRows WHERE row = 3