A partir de Oracle 12c R1 (12.1), hay is a cláusula de limitación de fila. No usa familiar LIMIT sintaxis, pero puede hacer mejor el trabajo con más opciones. Puedes encontrar el sintaxis completa aquí. (Lea también más sobre cómo funciona esto internamente en Oracle en esta respuesta).

Para responder a la pregunta original, aquí está la consulta:

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

(Para versiones anteriores de Oracle, consulte otras respuestas en esta pregunta)

Ejemplos:

Los siguientes ejemplos fueron citados de página vinculada, con la esperanza de prevenir la pudrición del enlace.

Preparar

CREATE TABLE rownum_order_test (
  val  NUMBER
);

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

COMMIT;

¿Qué hay en la 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.

Conseguir primero N filas

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

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

5 rows selected.

Conseguir primero N filas, si N^th la fila tiene corbatas, obtén todas las filas atadas

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.

Notable x% de filas

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

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

4 rows selected.

Usando un desplazamiento, muy útil para la paginación.

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.

Puede combinar la compensación con porcentajes

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.

Puede usar una subconsulta para esto como

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

Echa también un vistazo al tema. En ROWNUM y resultados limitados en Oracle / AskTom para obtener más información.

Actualizar: Para limitar el resultado con los límites superior e inferior, las cosas se vuelven un poco más infladas con

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 del artículo AskTom especificado)

actualización 2: A partir de Oracle 12c (12.1), hay una sintaxis disponible para limitar filas o comenzar en compensaciones.

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

Ver esta respuesta para más ejemplos. Gracias a Krumia por la pista.

Hice algunas pruebas de rendimiento para los siguientes enfoques:

Preguntar

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

Pruebas analíticas

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

Alternativa corta

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

Resultados

La tabla tenía 10 millones de registros, la ordenación estaba en una fila de fecha y hora no indexada:

• Explique que el plan mostró el mismo valor para las tres selecciones (323168)
• Pero el ganador es AskTom (con el seguimiento analítico de cerca)

Seleccionar las primeras 10 filas tomó:

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

Seleccionar filas entre 100,000 y 100,010:

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

Seleccionar filas entre 9,000,000 y 9,000,010:

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

Una solución analítica con solo una consulta anidada:

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

Rank() podría ser sustituido por Row_Number() pero puede devolver más registros de los que espera si hay valores duplicados para el nombre.

En Oracle 12c (consulte la cláusula de limitación de filas en Referencia SQL):

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

Estándar SQL

Desde la versión 12c, Oracle admite SQL: 2008 Standard, que proporciona la siguiente sintaxis para limitar el conjunto de resultados de SQL:

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

Oracle 11g y versiones anteriores

Antes de la versión 12c, para obtener el Top-N registros, tenías que usar una tabla derivada y el ROWNUM pseudocolumna:

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

Las consultas de paginación con ordenación son realmente complicadas en Oracle.

Oracle proporciona una pseudocolumna ROWNUM que devuelve un número que indica el orden en el que la base de datos selecciona la fila de una tabla o un conjunto de vistas unidas.

ROWNUM es una pseudocolumna que mete en problemas a mucha gente. Un valor ROWNUM no se asigna permanentemente a una fila (este es un malentendido común). Puede resultar confuso cuando se asigna realmente un valor ROWNUM. Se asigna un valor ROWNUM a una fila después de que pasa los predicados de filtro de la consulta pero antes de la agregación u ordenación de consultas.

Además, un valor ROWNUM se incrementa solo después de que se asigna.

Es por eso que la siguiente consulta no devuelve filas:

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

La primera fila del resultado de la consulta no pasa el predicado ROWNUM> 1, por lo que ROWNUM no se incrementa a 2. Por esta razón, ningún valor de ROWNUM es mayor que 1, por lo tanto, la consulta no devuelve filas.

La consulta correctamente definida debería verse así:

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

Obtenga más información sobre las consultas de paginación en mis artículos sobre vertabelo blog:

• Explicación de Oracle ROWNUM
• Consultas de paginación y Top-N

Como una extensión de respuesta aceptada Oracle utiliza internamente ROW_NUMBER/RANK funciones. OFFSET FETCH la sintaxis es un azúcar de sintaxis.

Podría observarse usando DBMS_UTILITY.EXPAND_SQL_TEXT procedimiento:

Preparando muestra:

CREATE TABLE rownum_order_test (
  val  NUMBER
);

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

consulta:

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

es 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 <> demostración de violín

Obteniendo 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 se expande 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

y compensar:

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"

Menos declaraciones SELECT. Además, consume menos rendimiento. Créditos 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;

Si no está en Oracle 12C, puede usar la consulta TOP N como se muestra a continuación.

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

Incluso puede mover esto de la cláusula a la cláusula de la siguiente manera

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

En realidad, aquí estamos creando una vista en línea y cambiando el nombre de rownum a rnum. Puede utilizar rnum en la consulta principal como criterio de filtrado.

Comencé a prepararme para el examen Oracle 1z0-047, validado contra 12c. Mientras me preparaba, encontré una mejora de 12c conocida como 'FETCH FIRST'. Le permite buscar filas / limitar filas según su conveniencia. Varias opciones están disponibles con él

- 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

Ejemplo:

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

mayores que los valores averigüen

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

menos que los valores averigüen

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

Para cada fila devuelta por una consulta, la pseudocolumna ROWNUM devuelve un número que indica el orden en el que Oracle selecciona la fila de una tabla o un conjunto de filas unidas. La primera fila seleccionada tiene un ROWNUM de 1, la segunda tiene 2 y así sucesivamente.

  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 

He implementado esto en oracle servidor 11.2.0.1.0

En el caso de SQL-Developer, obtiene automáticamente solo las primeras 50 filas. ¡Y si nos desplazamos hacia abajo, obtiene otras 50 filas y así sucesivamente!

Por lo tanto, no necesitamos definir, en el caso de la herramienta sql-developer.

(no probado) algo como esto puede hacer el trabajo

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

También está el rango de la función analítica, que puede usar para ordenar.