C'è un modo per far funzionare una Oraclequery come se contenesse una MySQL limitclausola?

In MySQL, posso fare questo:

select * 
from sometable
order by name
limit 20,10

per ottenere dalla 21a alla 30a fila (salta le prime 20, dai le successive 10). Le righe sono selezionate dopo il order by, quindi inizia davvero il 20 ° nome in ordine alfabetico.

In Oracle, l'unica cosa che la gente menziona è la rownumpseudo-colonna, ma viene valutata prima order by , il che significa che:

select * 
from sometable
where rownum <= 10
order by name

restituirà un set casuale di dieci righe ordinate per nome, che di solito non è quello che voglio. Inoltre, non consente di specificare un offset.

Partendo da Oracle 12c R1 (12.1), non v'è una fila clausola limitativa . Non utilizza una LIMITsintassi familiare , ma può fare meglio il lavoro con più opzioni. Puoi trovare la sintassi completa qui . (Leggi anche di più su come funziona internamente in Oracle in questa risposta ).

Per rispondere alla domanda originale, ecco la query:

SELECT * 
FROM   sometable
ORDER BY name
OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY;

(Per le versioni precedenti di Oracle, fare riferimento ad altre risposte in questa domanda)

Esempi:

I seguenti esempi sono stati citati dalla pagina collegata , nella speranza di prevenire la putrefazione dei collegamenti.

Impostare

CREATE TABLE rownum_order_test (
  val  NUMBER
);

INSERT ALL
  INTO rownum_order_test
SELECT level
FROM   dual
CONNECT BY level <= 10;

COMMIT;

Cosa c'è nel tavolo?

SELECT val
FROM   rownum_order_test
ORDER BY val;

       VAL
----------
         1
         1
         2
         2
         3
         3
         4
         4
         5
         5
         6
         6
         7
         7
         8
         8
         9
         9
        10
        10

20 rows selected.

Ottieni le prime Nfile

SELECT val
FROM   rownum_order_test
ORDER BY val DESC
FETCH FIRST 5 ROWS ONLY;

       VAL
----------
        10
        10
         9
         9
         8

5 rows selected.

Ottenere prime Nrighe, se N^esima fila ha legami, ottenere tutte le righe legate

SELECT val
FROM   rownum_order_test
ORDER BY val DESC
FETCH FIRST 5 ROWS WITH TIES;

       VAL
----------
        10
        10
         9
         9
         8
         8

6 rows selected.

Top x% delle righe

SELECT val
FROM   rownum_order_test
ORDER BY val
FETCH FIRST 20 PERCENT ROWS ONLY;

       VAL
----------
         1
         1
         2
         2

4 rows selected.

Utilizzando un offset, molto utile per l'impaginazione

SELECT val
FROM   rownum_order_test
ORDER BY val
OFFSET 4 ROWS FETCH NEXT 4 ROWS ONLY;

       VAL
----------
         3
         3
         4
         4

4 rows selected.

È possibile combinare offset e percentuali

SELECT val
FROM   rownum_order_test
ORDER BY val
OFFSET 4 ROWS FETCH NEXT 20 PERCENT ROWS ONLY;

       VAL
----------
         3
         3
         4
         4

4 rows selected.

Puoi usare una subquery per questo tipo

select *
from  
( select * 
  from emp 
  order by sal desc ) 
where ROWNUM <= 5;

Dai anche un'occhiata all'argomento Su ROWNUM e limita i risultati su Oracle / AskTom per maggiori informazioni.

Aggiornamento : per limitare il risultato con entrambi i limiti inferiore e superiore, le cose diventano un po 'più gonfie

select * from 
( select a.*, ROWNUM rnum from 
  ( <your_query_goes_here, with order by> ) a 
  where ROWNUM <= :MAX_ROW_TO_FETCH )
where rnum  >= :MIN_ROW_TO_FETCH;

(Copiato dall'articolo AskTom specificato)

Aggiornamento 2 : a partire da Oracle 12c (12.1) è disponibile una sintassi per limitare le righe o iniziare dagli offset.

SELECT * 
FROM   sometable
ORDER BY name
OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY;

Vedi questa risposta per altri esempi. Grazie a Krumia per il suggerimento.

Ho eseguito alcuni test delle prestazioni per i seguenti approcci:

Asktom

select * from (
  select a.*, ROWNUM rnum from (
    <select statement with order by clause>
  ) a where rownum <= MAX_ROW
) where rnum >= MIN_ROW

Analitico

select * from (
  <select statement with order by clause>
) where myrow between MIN_ROW and MAX_ROW

Breve alternativa

select * from (
  select statement, rownum as RN with order by clause
) where a.rn >= MIN_ROW and a.rn <= MAX_ROW

risultati

La tabella aveva 10 milioni di record, l'ordinamento era su una riga datetime non indicizzata:

• Il piano di spiegazione ha mostrato lo stesso valore per tutte e tre le selezioni (323168)
• Ma il vincitore è AskTom (con analitica che segue da vicino)

La selezione delle prime 10 righe ha richiesto:

• AskTom: 28-30 secondi
• Analitico: 33-37 secondi
• Alternativa breve: 110-140 secondi

Selezione di righe tra 100.000 e 100.010:

• AskTom: 60 secondi
• Analitico: 100 secondi

Selezione di righe tra 9.000.000 e 9.000.010:

• AskTom: 130 secondi
• Analitico: 150 secondi

Una soluzione analitica con una sola query nidificata:

SELECT * FROM
(
   SELECT t.*, Row_Number() OVER (ORDER BY name) MyRow FROM sometable t
) 
WHERE MyRow BETWEEN 10 AND 20;

Rank()potrebbe essere sostituito Row_Number()ma potrebbe restituire più record di quanto ti aspetti se ci sono valori duplicati per nome.

Su Oracle 12c (vedere la clausola di limitazione delle righe nel riferimento SQL ):

SELECT * 
FROM sometable
ORDER BY name
OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY;

Le query di impaginazione con l'ordinamento sono davvero complicate in Oracle.

Oracle fornisce una pseudocolonna ROWNUM che restituisce un numero che indica l'ordine in cui il database seleziona la riga da una tabella o da una serie di viste unite.

ROWNUM è una pseudocolonna che mette molte persone nei guai. Un valore ROWNUM non viene assegnato in modo permanente a una riga (questo è un malinteso comune). Potrebbe essere fonte di confusione quando un valore ROWNUM è effettivamente assegnato. Un valore ROWNUM viene assegnato a una riga dopo aver superato i predicati del filtro della query ma prima dell'aggregazione o dell'ordinamento della query .

Inoltre, un valore ROWNUM viene incrementato solo dopo che è stato assegnato.

Questo è il motivo per cui la query seguente non restituisce righe:

 select * 
 from (select *
       from some_table
       order by some_column)
 where ROWNUM <= 4 and ROWNUM > 1; 

La prima riga del risultato della query non passa il predicato ROWNUM> 1, quindi ROWNUM non aumenta a 2. Per questo motivo, nessun valore ROWNUM diventa maggiore di 1, di conseguenza la query non restituisce righe.

La query definita correttamente dovrebbe apparire così:

select *
from (select *, ROWNUM rnum
      from (select *
            from skijump_results
            order by points)
      where ROWNUM <= 4)
where rnum > 1; 

Scopri di più sulle query di impaginazione nei miei articoli sul blog di Vertabelo :

• Oracle ROWNUM spiegato
• Top-N e query di impaginazione

SQL Standard

Come ho spiegato in questo articolo , lo standard SQL: 2008 fornisce la sintassi seguente per limitare il set di risultati SQL:

SELECT
    title
FROM
    post
ORDER BY
    id DESC
FETCH FIRST 50 ROWS ONLY

Oracle 11g e versioni precedenti

Prima della versione 12c, per recuperare i record Top-N, era necessario utilizzare una tabella derivata e la pseudocolonna ROWNUM:

SELECT *
FROM (
    SELECT
        title
    FROM
        post
    ORDER BY
        id DESC
)
WHERE ROWNUM <= 50

Meno istruzioni SELECT. Inoltre, meno consumo di prestazioni. Crediti a: anibal@upf.br

SELECT *
    FROM   (SELECT t.*,
                   rownum AS rn
            FROM   shhospede t) a
    WHERE  a.rn >= in_first
    AND    a.rn <= in_first;

Come estensione della risposta accettata, Oracle utilizza internamente le ROW_NUMBER/RANKfunzioni. OFFSET FETCHla sintassi è uno zucchero sintattico.

Si potrebbe osservare usando la DBMS_UTILITY.EXPAND_SQL_TEXTprocedura:

Preparazione del campione:

CREATE TABLE rownum_order_test (
  val  NUMBER
);

INSERT ALL
  INTO rownum_order_test
SELECT level
FROM   dual
CONNECT BY level <= 10;
COMMIT;

Query:

SELECT val
FROM   rownum_order_test
ORDER BY val DESC
FETCH FIRST 5 ROWS ONLY;

è regolare:

SELECT "A1"."VAL" "VAL" 
FROM  (SELECT "A2"."VAL" "VAL","A2"."VAL" "rowlimit_$_0",
               ROW_NUMBER() OVER ( ORDER BY "A2"."VAL" DESC ) "rowlimit_$$_rownumber" 
      FROM "ROWNUM_ORDER_TEST" "A2") "A1" 
WHERE "A1"."rowlimit_$$_rownumber"<=5 ORDER BY "A1"."rowlimit_$_0" DESC;

db <> demo violino

Recupero del testo SQL espanso:

declare
  x VARCHAR2(1000);
begin
 dbms_utility.expand_sql_text(
        input_sql_text => '
          SELECT val
          FROM   rownum_order_test
          ORDER BY val DESC
          FETCH FIRST 5 ROWS ONLY',
        output_sql_text => x);

  dbms_output.put_line(x);
end;
/

WITH TIESè espanso come RANK:

declare
  x VARCHAR2(1000);
begin
 dbms_utility.expand_sql_text(
        input_sql_text => '
          SELECT val
          FROM   rownum_order_test
          ORDER BY val DESC
          FETCH FIRST 5 ROWS WITH TIES',
        output_sql_text => x);

  dbms_output.put_line(x);
end;
/

SELECT "A1"."VAL" "VAL" 
FROM  (SELECT "A2"."VAL" "VAL","A2"."VAL" "rowlimit_$_0",
              RANK() OVER ( ORDER BY "A2"."VAL" DESC ) "rowlimit_$$_rank" 
       FROM "ROWNUM_ORDER_TEST" "A2") "A1" 
WHERE "A1"."rowlimit_$$_rank"<=5 ORDER BY "A1"."rowlimit_$_0" DESC

e offset:

declare
  x VARCHAR2(1000);
begin
 dbms_utility.expand_sql_text(
        input_sql_text => '
          SELECT val
FROM   rownum_order_test
ORDER BY val
OFFSET 4 ROWS FETCH NEXT 4 ROWS ONLY',
        output_sql_text => x);

  dbms_output.put_line(x);
end;
/


SELECT "A1"."VAL" "VAL" 
FROM  (SELECT "A2"."VAL" "VAL","A2"."VAL" "rowlimit_$_0",
             ROW_NUMBER() OVER ( ORDER BY "A2"."VAL") "rowlimit_$$_rownumber" 
       FROM "ROWNUM_ORDER_TEST" "A2") "A1" 
       WHERE "A1"."rowlimit_$$_rownumber"<=CASE  WHEN (4>=0) THEN FLOOR(TO_NUMBER(4)) 
             ELSE 0 END +4 AND "A1"."rowlimit_$$_rownumber">4 
ORDER BY "A1"."rowlimit_$_0"

Se non si utilizza Oracle 12C, è possibile utilizzare la query TOP N come di seguito.

SELECT *
 FROM
   ( SELECT rownum rnum
          , a.*
       FROM sometable a 
   ORDER BY name
   )
WHERE rnum BETWEEN 10 AND 20;

Puoi anche spostare questo dalla clausola con la clausola come segue

WITH b AS
( SELECT rownum rnum
      , a.* 
   FROM sometable a ORDER BY name
) 
SELECT * FROM b 
WHERE rnum BETWEEN 10 AND 20;

Qui in realtà stiamo creando una vista inline e rinominando rownum come rnum. È possibile utilizzare rnum nella query principale come criterio di filtro.

Ho iniziato a prepararmi per l'esame Oracle 1z0-047, convalidato contro 12c Mentre mi preparavo per questo mi sono imbattuto in un miglioramento 12c noto come 'FETCH FIRST' che ti consente di recuperare le righe / limitare le righe secondo la tua convenienza. Diverse opzioni sono disponibili con esso

- FETCH FIRST n ROWS ONLY
 - OFFSET n ROWS FETCH NEXT N1 ROWS ONLY // leave the n rows and display next N1 rows
 - n % rows via FETCH FIRST N PERCENT ROWS ONLY

Esempio:

Select * from XYZ a
order by a.pqr
FETCH FIRST 10 ROWS ONLY

select * FROM (SELECT 
   ROW_NUMBER() OVER (ORDER BY sal desc),* AS ROWID, 
 FROM EMP ) EMP  where ROWID=5

maggiori quindi i valori scoprono

select * FROM (SELECT 
       ROW_NUMBER() OVER (ORDER BY sal desc),* AS ROWID, 
     FROM EMP ) EMP  where ROWID>5

meno di valori scoprono

select * FROM (SELECT 
       ROW_NUMBER() OVER (ORDER BY sal desc),* AS ROWID, 
     FROM EMP ) EMP  where ROWID=5

Per ogni riga restituita da una query, la pseudocolonna ROWNUM restituisce un numero che indica l'ordine in cui Oracle seleziona la riga da una tabella o da un insieme di righe unite. La prima riga selezionata ha un ROWNUM di 1, la seconda ha 2 e così via.

  SELECT * FROM sometable1 so
    WHERE so.id IN (
    SELECT so2.id from sometable2 so2
    WHERE ROWNUM <=5
    )
    AND ORDER BY so.somefield AND ROWNUM <= 100 

Ho implementato questo nel oracleserver11.2.0.1.0

Nel caso di SQL-Developer, recupera automaticamente solo le prime 50 righe. E se scorriamo verso il basso, recupera altre 50 righe e così via!

Quindi non è necessario definire, in caso di strumento di sviluppo sql!

In oracolo

SELECT val FROM   rownum_order_test ORDER BY val DESC FETCH FIRST 5 ROWS ONLY;

VAL

    10
    10
     9
     9
     8

5 righe selezionate.

SQL>

(non testato) qualcosa del genere potrebbe fare il lavoro

WITH
base AS
(
    select *                   -- get the table
    from sometable
    order by name              -- in the desired order
),
twenty AS
(
    select *                   -- get the first 30 rows
    from base
    where rownum < 30
    order by name              -- in the desired order
)
select *                       -- then get rows 21 .. 30
from twenty
where rownum > 20
order by name                  -- in the desired order

C'è anche il rango della funzione analitica, che puoi usare per ordinare.

Come sopra con correzioni. Funziona ma sicuramente non è carino.

   WITH
    base AS
    (
        select *                   -- get the table
        from sometable
        order by name              -- in the desired order
    ),
    twenty AS
    (
        select *                   -- get the first 30 rows
        from base
        where rownum <= 30
        order by name              -- in the desired order
    )
    select *                       -- then get rows 21 .. 30
    from twenty
    where rownum < 20
    order by name                  -- in the desired order

Onestamente, meglio usare le risposte di cui sopra.