> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# primes

> Devuelve una tabla con una única columna `prime` que contiene números primos.

* `primes()` – Devuelve una tabla infinita con una única columna `prime` (UInt64) que contiene números primos en orden ascendente, a partir de 2. Use `LIMIT` (y, opcionalmente, `OFFSET`) para limitar el número de filas.

* `primes(N)` – Devuelve una tabla con una única columna `prime` (UInt64) que contiene los primeros `N` números primos, a partir de 2.

* `primes(N, M)` – Devuelve una tabla con una única columna `prime` (UInt64) que contiene `M` números primos a partir del primo en la posición `N` (base 0).

* `primes(N, M, S)` – Devuelve una tabla con una única columna `prime` (UInt64) que contiene `M` números primos a partir del primo en la posición `N` (base 0), con paso `S` según el índice de los primos. Los primos devueltos corresponden a los índices `N, N + S, N + 2S, ..., N + (M - 1)S`. `S` debe ser `>= 1`.

Esto es similar a la tabla del sistema [`system.primes`](/es/reference/system-tables/primes).

Las siguientes consultas son equivalentes:

```sql theme={null}
SELECT * FROM primes(10);
SELECT * FROM primes(0, 10);
SELECT * FROM primes() LIMIT 10;
SELECT * FROM system.primes LIMIT 10;
SELECT * FROM system.primes WHERE prime IN (2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
```

Las siguientes consultas también son equivalentes:

```sql theme={null}
SELECT * FROM primes(10, 10);
SELECT * FROM primes() LIMIT 10 OFFSET 10;
SELECT * FROM system.primes LIMIT 10 OFFSET 10;
```

<div id="examples">
  ### Ejemplos
</div>

Los 10 primeros números primos.

```sql theme={null}
SELECT * FROM primes(10);
```

```response theme={null}
  ┌─prime─┐
  │     2 │
  │     3 │
  │     5 │
  │     7 │
  │    11 │
  │    13 │
  │    17 │
  │    19 │
  │    23 │
  │    29 │
  └───────┘
```

El primer número primo mayor que 1e15.

```sql theme={null}
SELECT prime FROM primes() WHERE prime > 1e15 LIMIT 1;
```

```response theme={null}
  ┌────────────prime─┐
  │ 1000000000000037 │ -- 1.00 quadrillion
  └──────────────────┘
```

Resuelve una condición modular sobre números primos en un rango muy grande: encuentra el primer primo `p >= 10^15` tal que `p` módulo `65537` sea `1`.

```sql theme={null}
SELECT prime
FROM primes()
WHERE prime >= 1e15
  AND prime % 65537 = 1
LIMIT 1;
```

```response theme={null}
 ┌────────────prime─┐
 │ 1000000001218399 │ -- 1.00 quadrillón
 └──────────────────┘
```

Los primeros 7 números primos de Mersenne.

```sql theme={null}
SELECT prime
FROM primes()
WHERE bitAnd(prime, prime + 1) = 0
LIMIT 7;
```

```response theme={null}
  ┌──prime─┐
  │      3 │
  │      7 │
  │     31 │
  │    127 │
  │   8191 │
  │ 131071 │
  │ 524287 │
  └────────┘
```

<div id="notes">
  ### Notas
</div>

* Las formas más rápidas son las consultas simples de rango y de filtrado por punto que usan el paso predeterminado (`1`), por ejemplo, `primes(N)` o `primes() LIMIT N`. Estas formas usan un generador de números primos optimizado para calcular números primos muy grandes de manera eficiente.
* En las fuentes no acotadas (`primes()` / `system.primes`), se pueden aplicar durante la generación filtros simples por valor, como `prime BETWEEN ...`, `prime IN (...)` o `prime = ...`, para restringir los rangos de valores que se buscan. Por ejemplo, la siguiente consulta se ejecuta casi al instante:

```sql theme={null}
SELECT sum(prime)
FROM primes()
WHERE prime BETWEEN 1e6 AND 1e6 + 100
   OR prime BETWEEN 1e12 AND 1e12 + 100
   OR prime BETWEEN 1e15 AND 1e15 + 100
   OR prime IN (9999999967, 9999999971, 9999999973)
   OR prime = 1000000000000037;
```

```response theme={null}
  ┌───────sum(prime)─┐
  │ 2004010006000641 │ -- 2.00 cuatrillones
  └──────────────────┘

1 row in set. Elapsed: 0.090 sec. 
```

* Esta optimización del rango de valores no se aplica a las funciones de tabla acotadas (`primes(N)`, `primes(offset, count[, step])`) con `WHERE`, porque esas variantes definen una tabla finita en función del índice de números primos, y el filtro debe evaluarse después de generar esa tabla para preservar la semántica.
* Usar un offset distinto de cero y/o un step mayor que 1 (`primes(offset, count)` / `primes(offset, count, step)`) puede ser más lento, porque internamente puede ser necesario generar y omitir números primos adicionales. Si no necesita offset ni step, omítalos.