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

> Documentación de las funciones de tabla

# Funciones de tabla

Las funciones de tabla son métodos para crear tablas.

| Página                                                                                       | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| -------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [azureBlobStorage](/es/reference/functions/table-functions/azureBlobStorage)                 | Proporciona una interfaz de tipo tabla para seleccionar e insertar archivos en Azure Blob Storage. Es similar a la función `s3`.                                                                                                                                                                                                                                                                                                                                                        |
| [azureBlobStorageCluster](/es/reference/functions/table-functions/azureBlobStorageCluster)   | Permite procesar archivos de Azure Blob Storage en paralelo con muchos nodos en un clúster especificado.                                                                                                                                                                                                                                                                                                                                                                                |
| [clusterAllReplicas](/es/reference/functions/table-functions/cluster)                        | Permite acceder a todos los segmentos (configurados en la sección `remote_servers`) de un clúster sin crear una tabla distribuida.                                                                                                                                                                                                                                                                                                                                                      |
| [deltaLake](/es/reference/functions/table-functions/deltalake)                               | Proporciona una interfaz de tipo tabla de solo lectura para las tablas de Delta Lake en Amazon S3.                                                                                                                                                                                                                                                                                                                                                                                      |
| [deltaLakeCluster](/es/reference/functions/table-functions/deltalakeCluster)                 | Es una extensión de la función de tabla `deltaLake`.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [dictionary](/es/reference/functions/table-functions/dictionary)                             | Muestra los datos del diccionario como una tabla de ClickHouse. Funciona igual que el engine Dictionary.                                                                                                                                                                                                                                                                                                                                                                                |
| [executable](/es/reference/functions/table-functions/executable)                             | La función de tabla `executable` crea una tabla a partir de la salida de una función definida por el usuario (UDF) que defines en un script que envía filas a **stdout**.                                                                                                                                                                                                                                                                                                               |
| [file](/es/reference/functions/table-functions/file)                                         | Un motor de tabla que proporciona una interfaz de tipo tabla para `SELECT` desde archivos e `INSERT` en ellos, similar a la función de tabla S3. Usa `file()` al trabajar con archivos locales y `s3()` al trabajar con buckets en almacenamiento de objetos como S3, GCS o MinIO.                                                                                                                                                                                                      |
| [fileCluster](/es/reference/functions/table-functions/fileCluster)                           | Permite procesar simultáneamente archivos que coinciden con una ruta especificada en varios nodos de un clúster. El iniciador establece conexiones con los nodos worker, expande los globs de la ruta del archivo y delega las tareas de lectura de archivos a los nodos worker. Cada nodo worker consulta al iniciador cuál es el siguiente archivo que debe procesar, y repite este proceso hasta que se completan todas las tareas (es decir, hasta que se leen todos los archivos). |
| [filesystem](/es/reference/functions/table-functions/filesystem)                             | Proporciona acceso al sistema de archivos para listar archivos y devolver sus metadatos y contenido.                                                                                                                                                                                                                                                                                                                                                                                    |
| [format](/es/reference/functions/table-functions/format)                                     | Analiza los datos de los argumentos según el formato de entrada especificado. Si no se especifica el argumento de estructura, se extrae de los datos.                                                                                                                                                                                                                                                                                                                                   |
| [gcs](/es/reference/functions/table-functions/gcs)                                           | Proporciona una interfaz de tipo tabla para `SELECT` e `INSERT` de datos desde Google Cloud Storage. Requiere el rol de IAM `Storage Object User`.                                                                                                                                                                                                                                                                                                                                      |
| [fuzzQuery](/es/reference/functions/table-functions/fuzzQuery)                               | Altera la cadena de consulta dada con variaciones aleatorias.                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [fuzzJSON](/es/reference/functions/table-functions/fuzzJSON)                                 | Altera una cadena JSON con variaciones aleatorias.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [generateRandom](/es/reference/functions/table-functions/generate)                           | Genera datos aleatorios con un esquema dado. Permite rellenar tablas de prueba con esos datos. No se admiten todos los tipos.                                                                                                                                                                                                                                                                                                                                                           |
| [mergeTreeTextIndex](/es/reference/functions/table-functions/mergeTreeTextIndex)             | Representa el diccionario de un índice de texto en una tabla MergeTree. Puede usarse para introspección.                                                                                                                                                                                                                                                                                                                                                                                |
| [mergeTreeProjection](/es/reference/functions/table-functions/mergeTreeProjection)           | Representa el contenido de una proyección en tablas MergeTree. Puede usarse para introspección.                                                                                                                                                                                                                                                                                                                                                                                         |
| [mergeTreeIndex](/es/reference/functions/table-functions/mergeTreeIndex)                     | Representa el contenido de los archivos de índice y marcas de las tablas MergeTree. Puede usarse para introspección.                                                                                                                                                                                                                                                                                                                                                                    |
| [hdfs](/es/reference/functions/table-functions/hdfs)                                         | Crea una tabla a partir de archivos en HDFS. Esta función de tabla es similar a las funciones de tabla `url` y `file`.                                                                                                                                                                                                                                                                                                                                                                  |
| [hdfsCluster](/es/reference/functions/table-functions/hdfsCluster)                           | Permite procesar archivos de HDFS en paralelo desde muchos nodos en un clúster especificado.                                                                                                                                                                                                                                                                                                                                                                                            |
| [hudi](/es/reference/functions/table-functions/hudi)                                         | Proporciona una interfaz de tipo tabla de solo lectura para las tablas de Apache Hudi en Amazon S3.                                                                                                                                                                                                                                                                                                                                                                                     |
| [ytsaurus](/es/reference/functions/table-functions/ytsaurus)                                 | Esta función de tabla permite leer datos del clúster de YTsaurus.                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [hudiCluster Table Function](/es/reference/functions/table-functions/hudiCluster)            | Es una extensión de la función de tabla `hudi`. Permite procesar en paralelo archivos de tablas Apache Hudi en Amazon S3 con muchos nodos en un clúster especificado.                                                                                                                                                                                                                                                                                                                   |
| [iceberg](/es/reference/functions/table-functions/iceberg)                                   | Proporciona una interfaz de tipo tabla de solo lectura para tablas Apache Iceberg en Amazon S3, Azure, HDFS o almacenadas localmente.                                                                                                                                                                                                                                                                                                                                                   |
| [paimon](/es/reference/functions/table-functions/paimon)                                     | Proporciona una interfaz de tipo tabla de solo lectura para tablas Apache Paimon en Amazon S3, Azure, HDFS o almacenadas localmente.                                                                                                                                                                                                                                                                                                                                                    |
| [icebergCluster](/es/reference/functions/table-functions/icebergCluster)                     | Es una extensión de la función de tabla `iceberg` que permite procesar archivos de Apache Iceberg en paralelo desde muchos nodos en un clúster especificado.                                                                                                                                                                                                                                                                                                                            |
| [paimonCluster](/es/reference/functions/table-functions/paimonCluster)                       | Es una extensión de la función de tabla `paimon` que permite procesar archivos de Apache Paimon en paralelo desde muchos nodos en un clúster especificado.                                                                                                                                                                                                                                                                                                                              |
| [input](/es/reference/functions/table-functions/input)                                       | Función de tabla que permite convertir e insertar de forma eficiente datos enviados al servidor con una estructura dada en una tabla con otra estructura.                                                                                                                                                                                                                                                                                                                               |
| [jdbc](/es/reference/functions/table-functions/jdbc)                                         | Devuelve una tabla conectada mediante un driver JDBC.                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [merge](/es/reference/functions/table-functions/merge)                                       | Crea una tabla Merge temporal. La estructura se derivará de las tablas subyacentes usando una unión de sus columnas y tipos comunes derivados.                                                                                                                                                                                                                                                                                                                                          |
| [mongodb](/es/reference/functions/table-functions/mongodb)                                   | Permite realizar consultas `SELECT` sobre datos almacenados en un servidor remoto de MongoDB.                                                                                                                                                                                                                                                                                                                                                                                           |
| [mysql](/es/reference/functions/table-functions/mysql)                                       | Permite realizar consultas `SELECT` e `INSERT` sobre datos almacenados en un servidor remoto de MySQL.                                                                                                                                                                                                                                                                                                                                                                                  |
| [null](/es/reference/functions/table-functions/null)                                         | Crea una tabla temporal con la estructura especificada y el motor de tabla Null. La función se utiliza para facilitar la escritura de pruebas y demostraciones.                                                                                                                                                                                                                                                                                                                         |
| [timeSeriesMetrics](/es/reference/functions/table-functions/timeSeriesMetrics)               | timeSeriesMetrics devuelve la tabla de métricas utilizada por la tabla `db_name.time_series_table`, cuyo motor de tabla es TimeSeries.                                                                                                                                                                                                                                                                                                                                                  |
| [timeSeriesSelector](/es/reference/functions/table-functions/timeSeriesSelector)             | Lee series temporales de una tabla TimeSeries, filtradas por un selector y con marcas de tiempo dentro de un intervalo especificado.                                                                                                                                                                                                                                                                                                                                                    |
| [timeSeriesTags](/es/reference/functions/table-functions/timeSeriesTags)                     | La función de tabla timeSeriesTags devuelve la tabla de etiquetas utilizada por la tabla `db_name.time_series_table`, cuyo motor de tabla es TimeSeries.                                                                                                                                                                                                                                                                                                                                |
| [prometheusQueryRange](/es/reference/functions/table-functions/prometheusQueryRange)         | Evalúa una consulta de Prometheus utilizando datos de una tabla TimeSeries.                                                                                                                                                                                                                                                                                                                                                                                                             |
| [zeros](/es/reference/functions/table-functions/zeros)                                       | Se utiliza con fines de prueba como el método más rápido para generar muchas filas. Es similar a las tablas del sistema `system.zeros` y `system.zeros_mt`.                                                                                                                                                                                                                                                                                                                             |
| [primes](/es/reference/functions/table-functions/primes)                                     | Devuelve una tabla con una única columna `prime` que contiene números primos.                                                                                                                                                                                                                                                                                                                                                                                                           |
| [timeSeriesData](/es/reference/functions/table-functions/timeSeriesData)                     | timeSeriesData devuelve la tabla de datos utilizada por la tabla `db_name.time_series_table`, cuyo motor de tabla es TimeSeries.                                                                                                                                                                                                                                                                                                                                                        |
| [numbers](/es/reference/functions/table-functions/numbers)                                   | Devuelve una tabla con una única columna `number` que contiene una secuencia de enteros.                                                                                                                                                                                                                                                                                                                                                                                                |
| [prometheusQuery](/es/reference/functions/table-functions/prometheusQuery)                   | Evalúa una consulta de Prometheus utilizando datos de una tabla TimeSeries.                                                                                                                                                                                                                                                                                                                                                                                                             |
| [generate\_series (generateSeries)](/es/reference/functions/table-functions/generate_series) | Devuelve una tabla con una única columna, `generate_series` (UInt64), que contiene enteros de start a stop, ambos inclusive.                                                                                                                                                                                                                                                                                                                                                            |
| [odbc](/es/reference/functions/table-functions/odbc)                                         | Devuelve la tabla conectada mediante ODBC.                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [postgresql](/es/reference/functions/table-functions/postgresql)                             | Permite realizar consultas `SELECT` e `INSERT` sobre datos almacenados en un servidor remoto de PostgreSQL.                                                                                                                                                                                                                                                                                                                                                                             |
| [redis](/es/reference/functions/table-functions/redis)                                       | Esta función de tabla permite integrar ClickHouse con Redis.                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [remote, remoteSecure](/es/reference/functions/table-functions/remote)                       | La función de tabla `remote` permite acceder dinámicamente a servidores remotos, es decir, sin crear una tabla distribuida. La función de tabla `remoteSecure` es igual que `remote`, pero a través de una conexión segura.                                                                                                                                                                                                                                                             |
| [s3 Table Function](/es/reference/functions/table-functions/s3)                              | Proporciona una interfaz similar a una tabla para seleccionar o insertar archivos en Amazon S3 y Google Cloud Storage. Esta función de tabla es similar a la función hdfs, pero ofrece características específicas de S3.                                                                                                                                                                                                                                                               |
| [s3Cluster](/es/reference/functions/table-functions/s3Cluster)                               | Es una extensión de la función de tabla s3 que permite procesar archivos de Amazon S3 y Google Cloud Storage en paralelo con varios nodos de un clúster especificado.                                                                                                                                                                                                                                                                                                                   |
| [sqlite](/es/reference/functions/table-functions/sqlite)                                     | Permite realizar consultas sobre datos almacenados en una base de datos SQLite.                                                                                                                                                                                                                                                                                                                                                                                                         |
| [arrowFlight](/es/reference/functions/table-functions/arrowflight)                           | Permite realizar consultas sobre datos expuestos a través de un servidor Apache Arrow Flight.                                                                                                                                                                                                                                                                                                                                                                                           |
| [url](/es/reference/functions/table-functions/url)                                           | Crea una tabla a partir de la `URL` con el `format` y la `structure` especificados                                                                                                                                                                                                                                                                                                                                                                                                      |
| [urlCluster](/es/reference/functions/table-functions/urlCluster)                             | Permite procesar archivos desde una URL en paralelo con varios nodos de un clúster especificado.                                                                                                                                                                                                                                                                                                                                                                                        |
| [view](/es/reference/functions/table-functions/view)                                         | Convierte una subconsulta en una tabla. La función implementa vistas.                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [values](/es/reference/functions/table-functions/values)                                     | crea un almacenamiento temporal que rellena columnas con valores.                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [loop](/es/reference/functions/table-functions/loop)                                         | La función de tabla loop de ClickHouse se utiliza para devolver resultados de consultas en un bucle infinito.                                                                                                                                                                                                                                                                                                                                                                           |

<div id="usage">
  ## Uso
</div>

Las funciones de tabla se pueden usar en la cláusula [`FROM`](/es/reference/statements/select/from)
de una consulta `SELECT`. Por ejemplo, puede usar `SELECT` para leer datos de un archivo en su máquina local
mediante la función de tabla `file`.

```bash title="Query" theme={null}
echo "1, 2, 3" > example.csv
```

```text title="Response" theme={null}
./clickhouse client
:) SELECT * FROM file('example.csv')
┌─c1─┬─c2─┬─c3─┐
│  1 │  2 │  3 │
└────┴────┴────┘
```

También puede usar funciones de tabla para crear una tabla temporal que solo está disponible
en la consulta actual. Por ejemplo:

```sql title="Query" theme={null}
SELECT * FROM generateSeries(1,5);
```

```response title="Response" theme={null}
┌─generate_series─┐
│               1 │
│               2 │
│               3 │
│               4 │
│               5 │
└─────────────────┘
```

La tabla se elimina cuando finaliza la consulta.

Las funciones de tabla pueden utilizarse para crear tablas, usando la siguiente sintaxis:

```sql title="Query" theme={null}
CREATE TABLE [IF NOT EXISTS] [db.]table_name AS table_function()
```

Por ejemplo:

```sql title="Query" theme={null}
CREATE TABLE series AS generateSeries(1, 5);
SELECT * FROM series;
```

```response title="Response" theme={null}
┌─generate_series─┐
│               1 │
│               2 │
│               3 │
│               4 │
│               5 │
└─────────────────┘
```

Por último, las funciones de tabla pueden utilizarse para `INSERT` datos en una tabla. Por ejemplo,
podríamos escribir el contenido de la tabla que creamos en el ejemplo anterior
en un archivo del disco usando de nuevo la función de tabla `file`:

```sql title="Query" theme={null}
INSERT INTO FUNCTION file('numbers.csv', 'CSV') SELECT * FROM series;
```

```bash title="Query" theme={null}
cat numbers.csv
1
2
3
4
5
```

<Note>
  No puedes usar funciones de tabla si la opción [allow\_ddl](/es/reference/settings/session-settings#allow_ddl) está deshabilitada.
</Note>
