> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-parallel-read-in-order-multi-part.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Documentación de la cláusula LIMIT

# LIMIT

La cláusula `LIMIT` controla cuántas filas se devuelven en los resultados de la consulta. Las filas pueden seleccionarse por cantidad y desplazamiento, o mediante las condiciones que abren y cierran un rango de filas con [`LIMIT ... AFTER ... UNTIL`](#limit-after-until).

## Sintaxis básica

**Seleccionar las primeras filas:**

```sql theme={null}
LIMIT m
```

Devuelve las primeras `m` filas del resultado, o todos los registros si hay menos de `m`.

**Sintaxis alternativa de TOP (compatible con MS SQL Server):**

```sql theme={null}
-- SELECT TOP number|percent column_name(s) FROM table_name
SELECT TOP 10 * FROM numbers(100);
SELECT TOP 0.1 * FROM numbers(100);
```

Esto equivale a `LIMIT m` y puede utilizarse por compatibilidad con consultas de Microsoft SQL Server.

**Selección con OFFSET:**

```sql theme={null}
LIMIT m OFFSET n
-- or equivalently:
LIMIT n, m
```

Omite las primeras `n` filas y devuelve las siguientes `m`.

En ambas formas, `n` y `m` deben ser enteros no negativos.

**Seleccionar un rango mediante condiciones:**

```sql theme={null}
LIMIT [n] AFTER start_expr [UNTIL end_expr]
LIMIT [n] UNTIL end_expr
```

Devuelve las filas desde la primera fila en la que `start_expr` es true, o desde el inicio del stream cuando se omite `AFTER`, hasta la primera fila situada en ese inicio o después de él en la que `end_expr` es true, sin incluirla; `n` limita la longitud de ese rango. `AFTER start_expr ALL` abre un rango en cada fila coincidente. Consulte [LIMIT ... AFTER ... UNTIL](#limit-after-until) más abajo.

## Límites negativos

Selecciona filas desde el *final* del conjunto de resultados utilizando valores negativos:

| Sintaxis | Resultado |
| - | - |
| `LIMIT -m` | Últimas `m` filas |
| `LIMIT -m OFFSET -n` | Últimas `m` filas tras omitir las últimas `n` filas |
| `LIMIT m OFFSET -n` | Primeras `m` filas tras omitir las últimas `n` filas |
| `LIMIT -m OFFSET n` | Últimas `m` filas tras omitir las primeras `n` filas |

La sintaxis `LIMIT -n, -m` equivale a `LIMIT -m OFFSET -n`.

## Límites fraccionarios

Usa valores decimales entre 0 y 1 para seleccionar un porcentaje de filas:

| Sintaxis | Resultado |
| - | - |
| `LIMIT 0.1` | El primer 10% de las filas |
| `LIMIT 1 OFFSET 0.5` | La fila central |
| `LIMIT 0.25 OFFSET 0.5` | El tercer cuartil (25% de las filas después de omitir el primer 50%) |

<Note>
  * Las fracciones deben ser valores [Float64](/es/reference/data-types/float) mayores que 0 y menores que 1.
  * Los recuentos fraccionarios de filas se redondean al siguiente número entero.
</Note>

## Combinación de tipos de LIMIT

Puede combinar enteros estándar con OFFSET fraccionarios o negativos:

```sql theme={null}
LIMIT 10 OFFSET 0.5    -- 10 rows starting from the halfway point
LIMIT 10 OFFSET -20    -- 10 rows after skipping the last 20
```

La [forma de rango](#limit-after-until) solo se combina con un recuento simple de filas: `LIMIT 3 AFTER start_expr` toma como máximo tres filas desde el punto en que se abre el rango. `OFFSET`, los recuentos fraccionarios y negativos, y `WITH TIES` se rechazan si se usan junto con `AFTER` o `UNTIL`. Una cláusula [`LIMIT BY`](/es/reference/statements/select/limit-by) puede preceder a un rango en la misma consulta, y el SETTING [`limit`](/es/reference/settings/session-settings/other#limit) sigue limitando el resultado.

## LIMIT ... WITH TIES

El modificador `WITH TIES` incluye filas adicionales que tienen los mismos valores de `ORDER BY` que la última fila incluida por el límite. Solo se aplica a los límites de recuento y de OFFSET, y no puede combinarse con la [forma de rango](#limit-after-until).

```sql theme={null}
SELECT * FROM (
    SELECT number % 50 AS n FROM numbers(100)
) ORDER BY n LIMIT 0, 5
```

```response theme={null}
┌─n─┐
│ 0 │
│ 0 │
│ 1 │
│ 1 │
│ 2 │
└───┘
```

Con `WITH TIES`, también se incluyen todas las filas que coinciden con el último valor:

```sql theme={null}
SELECT * FROM (
    SELECT number % 50 AS n FROM numbers(100)
) ORDER BY n LIMIT 0, 5 WITH TIES
```

```response theme={null}
┌─n─┐
│ 0 │
│ 0 │
│ 1 │
│ 1 │
│ 2 │
│ 2 │
└───┘
```

La fila 6 se incluye porque tiene el mismo valor (`2`) que la fila 5.

Lo mismo ocurre cuando el OFFSET se especifica con la palabra clave `OFFSET`:

```sql theme={null}
SELECT * FROM (
    SELECT number % 50 AS n FROM numbers(100)
) ORDER BY n LIMIT 3 OFFSET 2 WITH TIES
```

```response theme={null}
┌─n─┐
│ 1 │
│ 1 │
│ 2 │
│ 2 │
└───┘
```

Al omitir las primeras 2 filas y tomar 3, normalmente se devolvería `1, 1, 2`, pero se incluye el segundo `2` porque empata con la última fila.

`WITH TIES` también funciona con límites y OFFSET negativos. Incluye filas adicionales que tienen los mismos valores de `ORDER BY` que la primera fila seleccionada:

```sql theme={null}
SELECT number % 3 AS n FROM numbers(15)
ORDER BY n LIMIT -4 OFFSET -3 WITH TIES
```

```response theme={null}
┌─n─┐
│ 1 │
│ 1 │
│ 1 │
│ 1 │
│ 1 │
│ 2 │
│ 2 │
└───┘
```

Sin `WITH TIES`, el resultado sería `1, 1, 2, 2`. Con `WITH TIES`, se incluyen tres filas adicionales con el valor `1` porque empatan con la primera fila seleccionada.

Este modificador puede combinarse con el modificador [`ORDER BY ... WITH FILL`](/es/reference/statements/select/order-by#order-by-expr-with-fill-modifier).

## LIMIT ... AFTER ... UNTIL (rango por condiciones)

Puede limitar el resultado a un *rango* de filas comprendido entre dos condiciones de contorno:

```sql theme={null}
LIMIT [n] AFTER start_expr [UNTIL end_expr]
LIMIT [n] AFTER start_expr ALL [UNTIL end_expr]
LIMIT [n] UNTIL end_expr
```

* `AFTER start_expr`: comienza la salida desde la primera fila en la que `start_expr` es verdadera (esa fila se incluye).
* `AFTER start_expr ALL`: devuelve la unión de todos los rangos coincidentes que comienzan donde `start_expr` es verdadera, sin duplicar filas cuando los rangos se solapan.
* `UNTIL end_expr`: finaliza cada rango antes de la primera fila situada en su inicio o después de él en la que `end_expr` es verdadera (esa fila se excluye).
* `n`: recuento opcional de filas. Sin `ALL`, es la longitud máxima del único rango abierto. Con `AFTER ... ALL`, es la longitud de *cada* rango abierto, por lo que el resultado total puede superar `n` (por ejemplo, `LIMIT 2 AFTER number IN (2, 6) ALL` puede devolver hasta cuatro filas). Para limitar el número total de filas del resultado, utiliza el SETTING `limit`, que se aplica como límite global después del rango.

El orden del flujo (el orden en el que se leen las filas) determina cuál es la «primera» coincidencia; usa `ORDER BY` para controlarlo.

Las coincidencias de `UNTIL` anteriores al inicio de un rango no tienen efecto. Si ambas condiciones coinciden en la fila inicial, el rango queda vacío. Si no se produce ninguna coincidencia de `UNTIL` en el inicio o después de él, el rango continúa hasta alcanzar su recuento de filas `n` o el final del stream. Con `AFTER ... ALL`, las coincidencias posteriores de `AFTER` pueden abrir nuevos rangos una vez finalizado un rango anterior.

Con `AFTER` y sin `ALL`, el paso de rango evalúa `AFTER` hasta encontrar un fragmento que contenga una coincidencia de inicio. A continuación, evalúa `UNTIL` en ese fragmento y en los fragmentos siguientes mientras el rango permanezca abierto. Las expresiones se evalúan sobre fragmentos completos, por lo que `UNTIL` puede evaluarse incluso para filas anteriores al inicio dentro del fragmento inicial.

Si `UNTIL` contiene funciones con estado como `rowNumberInAllBlocks`, o funciones no deterministas dentro de la consulta, se evalúa desde el primer fragmento para preservar el comportamiento de dichas funciones. Sin `ALL`, `AFTER` se evalúa únicamente hasta el fragmento inicial; en los fragmentos siguientes solo se evalúa `UNTIL`. Las coincidencias de fin anteriores al inicio siguen sin tener efecto.

**Ejemplos:**

Las 3 primeras filas a partir de la primera fila en la que `number >= 3`:

```sql theme={null}
SELECT number FROM numbers(10) ORDER BY number LIMIT 3 AFTER number >= 3;
```

```response theme={null}
┌─number─┐
│      3 │
│      4 │
│      5 │
└────────┘
```

Filas desde la primera fila donde `number >= 2` hasta (sin incluirla) la primera fila donde `number >= 6`:

```sql theme={null}
SELECT number FROM numbers(10) ORDER BY number LIMIT 10 AFTER number >= 2 UNTIL number >= 6;
```

```response theme={null}
┌─number─┐
│      2 │
│      3 │
│      4 │
│      5 │
└────────┘
```

Sin `n`, se devuelven todas las filas desde la coincidencia de `AFTER` hasta el final del stream (o hasta `UNTIL`):

```sql theme={null}
SELECT number FROM numbers(10) ORDER BY number LIMIT AFTER number >= 7;
```

```response theme={null}
┌─number─┐
│      7 │
│      8 │
│      9 │
└────────┘
```

Sin `n` pero con `UNTIL`, el rango se extiende desde la primera coincidencia de `AFTER` hasta la primera coincidencia de `UNTIL` que se produzca en esa misma posición o después de ella:

```sql theme={null}
SELECT number FROM numbers(10) ORDER BY number LIMIT AFTER number >= 2 UNTIL number >= 6;
```

```response theme={null}
┌─number─┐
│      2 │
│      3 │
│      4 │
│      5 │
└────────┘
```

Una coincidencia de `UNTIL` anterior al inicio se ignora; aquí `number = 1` no tiene efecto y el rango termina antes de `number = 6`:

```sql theme={null}
SELECT number FROM numbers(10) ORDER BY number LIMIT AFTER number = 3 UNTIL number IN (1, 6);
```

```response theme={null}
┌─number─┐
│      3 │
│      4 │
│      5 │
└────────┘
```

Emite 2 filas después de cada fila coincidente, sin duplicar los solapamientos:

```sql theme={null}
SELECT number FROM numbers(10) ORDER BY number LIMIT 2 AFTER number IN (2, 3, 6) ALL;
```

```response theme={null}
┌─number─┐
│      2 │
│      3 │
│      4 │
│      6 │
│      7 │
└────────┘
```

Con `ALL` y `UNTIL`, cada rango abierto termina al alcanzar sus `n` filas o en la siguiente coincidencia de `UNTIL`, lo que ocurra primero; aquí el rango abierto en 6 queda cortado por `number = 7`:

```sql theme={null}
SELECT number FROM numbers(10) ORDER BY number LIMIT 2 AFTER number IN (2, 6) ALL UNTIL number = 7;
```

```response theme={null}
┌─number─┐
│      2 │
│      3 │
│      6 │
└────────┘
```

Sin `n`, una coincidencia de `UNTIL` cierra el rango actual y una coincidencia posterior de `AFTER` abre uno nuevo, que se extiende hasta el final cuando no le sigue ninguna otra coincidencia de `UNTIL`:

```sql theme={null}
SELECT number FROM numbers(10) ORDER BY number LIMIT AFTER number IN (2, 6) ALL UNTIL number = 4;
```

```response theme={null}
┌─number─┐
│      2 │
│      3 │
│      6 │
│      7 │
│      8 │
│      9 │
└────────┘
```

Sin `n` y sin `UNTIL`, cada rango abierto se extiende hasta el final del stream, por lo que `AFTER start_expr ALL` devuelve las mismas filas que `AFTER start_expr`.

<Note>
  * `WITH TIES`, los valores fraccionarios o negativos de `LIMIT`/`OFFSET`, y `OFFSET` no son compatibles junto con `AFTER`/`UNTIL`.
  * El pushdown preliminar de `LIMIT` se deshabilita cuando se usa `AFTER`/`UNTIL`.
  * `AFTER` y `UNTIL` solo se reconocen como palabras clave cuando les sigue una expresión de límite, por lo que un identificador llamado `after` o `until` sigue funcionando como recuento de filas (`LIMIT after`, `LIMIT after BY x`). Cuando ambas lecturas son posibles, prevalece la palabra clave: `LIMIT after(2)` corresponde al rango `LIMIT AFTER (2)`; escriba `LIMIT (after(2))` para llamar a una función denominada `after`.
</Note>

`UNTIL` por sí solo devuelve las filas desde el inicio del stream hasta la primera fila en la que la condición es true:

```sql theme={null}
SELECT number FROM numbers(10) ORDER BY number LIMIT UNTIL number >= 3;
```

```response theme={null}
┌─number─┐
│      0 │
│      1 │
│      2 │
└────────┘
```

Con `n`, `UNTIL` por sí solo devuelve como máximo `n` filas desde el inicio del stream, deteniéndose igualmente en la primera coincidencia:

```sql theme={null}
SELECT number FROM numbers(10) ORDER BY number LIMIT 2 UNTIL number >= 3;
```

```response theme={null}
┌─number─┐
│      0 │
│      1 │
└────────┘
```

Un rango puede ir después de [`LIMIT BY`](/es/reference/statements/select/limit-by), en cuyo caso se aplica a las filas que `LIMIT BY` conserva:

```sql theme={null}
SELECT number % 4 AS k, number FROM numbers(12) ORDER BY k, number LIMIT 2 BY k LIMIT 3 AFTER k >= 1;
```

```response theme={null}
┌─k─┬─number─┐
│ 1 │      1 │
│ 1 │      5 │
│ 2 │      2 │
└───┴────────┘
```

## Consideraciones

**Resultados no deterministas:** Sin una cláusula [`ORDER BY`](/es/reference/statements/select/order-by), las filas devueltas pueden ser arbitrarias y variar de una ejecución de la consulta a otra.

**Límite del servidor:** La cantidad de filas devueltas también puede verse afectada por la configuración [limit](/es/reference/settings/session-settings/other#limit).

## Véase también

* [LIMIT BY](/es/reference/statements/select/limit-by) — Limita el número de filas por cada grupo de valores; resulta útil para obtener los N resultados principales dentro de cada categoría.