Existe uma maneira de fazer uma Oracleconsulta se comportar como se contenha uma MySQL limitcláusula?

Em MySQL, eu posso fazer isso:

select * 
from sometable
order by name
limit 20,10

para obter as linhas 21 a 30 (pule as 20 primeiras, dê as 10 seguintes). As linhas são selecionadas após o order by, então ele realmente começa com o vigésimo nome em ordem alfabética.

Em Oracle, a única coisa que as pessoas mencionam é a rownumpseudo-coluna, mas ela é avaliada antes order by , o que significa isso:

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

retornará um conjunto aleatório de dez linhas ordenadas por nome, que geralmente não é o que eu quero. Também não permite especificar um deslocamento.

A partir da Oracle 12c R1 (12,1), não é uma linha limitar a cláusula . Ele não usa LIMITsintaxe familiar , mas pode fazer o trabalho melhor com mais opções. Você pode encontrar a sintaxe completa aqui . (Leia também mais sobre como isso funciona internamente no Oracle nesta resposta ).

Para responder à pergunta original, aqui está a consulta:

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

(Para versões anteriores do Oracle, consulte outras respostas nesta pergunta)

Exemplos:

Os exemplos a seguir foram citados na página vinculada , na esperança de impedir a podridão do link.

Configuração

CREATE TABLE rownum_order_test (
  val  NUMBER
);

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

COMMIT;

O que há na mesa?

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.

Obter primeiras Nlinhas

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

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

5 rows selected.

Obter primeiras Nlinhas, se N^a linha tiver vínculos, obter todas as linhas vinculadas

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.

x% Superior de linhas

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

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

4 rows selected.

Usando um deslocamento, muito útil para paginação

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.

Você pode combinar o deslocamento com porcentagens

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.

Você pode usar uma subconsulta para isso como

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

Consulte também o tópico On ROWNUM e limite de resultados no Oracle / AskTom para obter mais informações.

Atualização : para limitar o resultado com limites inferior e superior, as coisas ficam um pouco mais inchadas com

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;

(Copiado do artigo AskTom especificado)

Atualização 2 : A partir do Oracle 12c (12.1), há uma sintaxe disponível para limitar linhas ou iniciar com compensações.

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

Veja esta resposta para mais exemplos. Obrigado a Krumia pela dica.

Fiz alguns testes de desempenho para as seguintes abordagens:

Asktom

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

Analítico

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

Alternativa curta

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

Resultados

A tabela tinha 10 milhões de registros, a classificação estava em uma linha de data e hora não indexada:

• O plano de explicação mostrou o mesmo valor para todas as três seleções (323168)
• Mas o vencedor é o AskTom (com acompanhamento analítico logo atrás)

A seleção das 10 primeiras linhas levou:

• AskTom: 28-30 segundos
• Analítico: 33-37 segundos
• Alternativa curta: 110-140 segundos

Selecionando linhas entre 100.000 e 100.010:

• AskTom: 60 segundos
• Analítico: 100 segundos

Selecionando linhas entre 9.000.000 e 9.000.010:

• AskTom: 130 segundos
• Analítico: 150 segundos

Uma solução analítica com apenas uma consulta aninhada:

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

Rank()pode ser substituído, Row_Number()mas pode retornar mais registros do que o esperado, se houver valores duplicados para o nome.

No Oracle 12c (consulte a cláusula de limitação de linha na referência SQL ):

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

As consultas de paginação com pedidos são realmente complicadas no Oracle.

O Oracle fornece uma pseudocoluna ROWNUM que retorna um número indicando a ordem na qual o banco de dados seleciona a linha de uma tabela ou conjunto de visualizações unidas.

ROWNUM é uma pseudocoluna que coloca muitas pessoas em problemas. Um valor ROWNUM não é atribuído permanentemente a uma linha (esse é um mal-entendido comum). Pode ser confuso quando um valor ROWNUM é realmente atribuído. Um valor ROWNUM é atribuído a uma linha depois de passar os predicados de filtro da consulta, mas antes da agregação ou classificação da consulta .

Além disso, um valor ROWNUM é incrementado somente depois de ser atribuído.

É por isso que a consulta a seguir não retorna linhas:

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

A primeira linha do resultado da consulta não passa o predicado ROWNUM> 1; portanto, o ROWNUM não aumenta para 2. Por esse motivo, nenhum valor de ROWNUM fica maior que 1, consequentemente, a consulta não retorna linhas.

A consulta definida corretamente deve ficar assim:

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

Saiba mais sobre consultas de paginação em meus artigos no blog Vertabelo :

• Oracle ROWNUM Explained
• Consultas principais de N e de paginação

Padrão SQL

Como expliquei neste artigo , o SQL: 2008 Standard fornece a seguinte sintaxe para limitar o conjunto de resultados do SQL:

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

Oracle 11g e versões anteriores

Antes da versão 12c, para buscar os registros Top-N, era necessário usar uma tabela derivada e a pseudocoluna ROWNUM:

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

Menos instruções SELECT. Além disso, consome menos desempenho. Créditos para: anibal@upf.br

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

Como uma extensão da resposta aceita, a Oracle usa internamente ROW_NUMBER/RANKfunções. OFFSET FETCHsintaxe é um açúcar de sintaxe.

Isso pode ser observado usando o DBMS_UTILITY.EXPAND_SQL_TEXTprocedimento:

Preparando a amostra:

CREATE TABLE rownum_order_test (
  val  NUMBER
);

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

Inquerir:

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

é regular:

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 de violino

Buscando texto SQL expandido:

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é expandido como 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 deslocamento:

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 você não estiver no Oracle 12C, poderá usar a consulta TOP N como abaixo.

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

Você pode até mover isso da cláusula com a cláusula da seguinte maneira

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

Aqui, na verdade, estamos criando uma exibição em linha e renomeando rownum como rnum. Você pode usar rnum na consulta principal como critério de filtro.

Comecei a me preparar para o exame Oracle 1z0-047, validado contra 12c. Ao me preparar para isso, deparei-me com um aprimoramento 12c conhecido como 'FETCH FIRST'. Ele permite que você busque linhas / limite linhas conforme sua conveniência. Várias opções estão disponíveis com ele

- 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

Exemplo:

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

maior que os valores descobrem

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

menos que os valores descobrem

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

Para cada linha retornada por uma consulta, a pseudocoluna ROWNUM retorna um número indicando a ordem na qual o Oracle seleciona a linha de uma tabela ou conjunto de linhas unidas. A primeira linha selecionada tem um ROWNUM de 1, a segunda tem 2 e assim por diante.

  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 

Eu implementei isso no oracleservidor11.2.0.1.0

No caso do SQL-Developer, ele busca automaticamente apenas as primeiras 50 linhas. E se rolarmos para baixo, ele buscará outras 50 linhas e assim por diante!

Portanto, não precisamos definir, no caso da ferramenta sql-developer!

No oracle

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

VAL

    10
    10
     9
     9
     8

5 linhas selecionadas.

SQL>

(não testado) algo assim pode fazer o trabalho

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

Há também a classificação da função analítica, que você pode usar para ordenar.

O mesmo que acima com correções. Funciona, mas definitivamente não é bonito.

   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

Honestamente, é melhor usar as respostas acima.