> ## 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.

> Documentação sobre Funções de tabela

# Funções de tabela

Funções de tabela são usadas para construir tabelas.

| Página                                                                                          | Descrição                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ----------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [azureBlobStorage](/pt-BR/reference/functions/table-functions/azureBlobStorage)                 | Fornece uma interface semelhante a uma tabela para selecionar/inserir arquivos no Azure Blob Storage. Semelhante à função s3.                                                                                                                                                                                                                                                                                                                              |
| [azureBlobStorageCluster](/pt-BR/reference/functions/table-functions/azureBlobStorageCluster)   | Permite processar arquivos do Azure Blob Storage em paralelo em vários nós de um cluster especificado.                                                                                                                                                                                                                                                                                                                                                     |
| [clusterAllReplicas](/pt-BR/reference/functions/table-functions/cluster)                        | Permite acessar todos os shards (configurados na seção `remote_servers`) de um cluster sem criar uma tabela Distributed.                                                                                                                                                                                                                                                                                                                                   |
| [deltaLake](/pt-BR/reference/functions/table-functions/deltalake)                               | Fornece uma interface semelhante a uma tabela, somente leitura, para tabelas Delta Lake no Amazon S3.                                                                                                                                                                                                                                                                                                                                                      |
| [deltaLakeCluster](/pt-BR/reference/functions/table-functions/deltalakeCluster)                 | Esta é uma extensão da função de tabela deltaLake.                                                                                                                                                                                                                                                                                                                                                                                                         |
| [dictionary](/pt-BR/reference/functions/table-functions/dictionary)                             | Exibe os dados do dicionário como uma tabela do ClickHouse. Funciona da mesma forma que o engine Dictionary.                                                                                                                                                                                                                                                                                                                                               |
| [executable](/pt-BR/reference/functions/table-functions/executable)                             | A função de tabela `executable` cria uma tabela com base na saída de uma função definida pelo usuário (UDF) que você define em um script que envia linhas para **stdout**.                                                                                                                                                                                                                                                                                 |
| [file](/pt-BR/reference/functions/table-functions/file)                                         | Um engine de tabela que fornece uma interface semelhante a uma tabela para `SELECT` de arquivos e `INSERT` em arquivos, semelhante à função de tabela s3. Use `file()` ao trabalhar com arquivos locais e `s3()` ao trabalhar com buckets em armazenamento de objetos como S3, GCS ou MinIO.                                                                                                                                                               |
| [fileCluster](/pt-BR/reference/functions/table-functions/fileCluster)                           | Permite o processamento simultâneo de arquivos que correspondem a um caminho especificado em vários nós de um cluster. O iniciador estabelece conexões com os nós de worker, expande globs no caminho do arquivo e delega tarefas de leitura de arquivos aos nós de worker. Cada nó de worker consulta o iniciador em busca do próximo arquivo a ser processado, repetindo isso até que todas as tarefas sejam concluídas (todos os arquivos sejam lidos). |
| [filesystem](/pt-BR/reference/functions/table-functions/filesystem)                             | Fornece acesso ao sistema de arquivos para listar arquivos e retornar seus metadados e conteúdo.                                                                                                                                                                                                                                                                                                                                                           |
| [format](/pt-BR/reference/functions/table-functions/format)                                     | Analisa os dados dos argumentos de acordo com o formato de entrada especificado. Se o argumento de estrutura não for especificado, ele será extraído dos dados.                                                                                                                                                                                                                                                                                            |
| [gcs](/pt-BR/reference/functions/table-functions/gcs)                                           | Fornece uma interface semelhante a uma tabela para `SELECT` e `INSERT` de dados do Google Cloud Storage. Requer a IAM role `Storage Object User`.                                                                                                                                                                                                                                                                                                          |
| [fuzzQuery](/pt-BR/reference/functions/table-functions/fuzzQuery)                               | Perturba a string de consulta fornecida com variações aleatórias.                                                                                                                                                                                                                                                                                                                                                                                          |
| [fuzzJSON](/pt-BR/reference/functions/table-functions/fuzzJSON)                                 | Perturba uma string JSON com variações aleatórias.                                                                                                                                                                                                                                                                                                                                                                                                         |
| [generateRandom](/pt-BR/reference/functions/table-functions/generate)                           | Gera dados aleatórios com um schema especificado. Permite preencher tabelas de teste com esses dados. Nem todos os tipos são compatíveis.                                                                                                                                                                                                                                                                                                                  |
| [mergeTreeTextIndex](/pt-BR/reference/functions/table-functions/mergeTreeTextIndex)             | Representa o dicionário de um índice de texto em uma tabela MergeTree. Pode ser usado para introspecção.                                                                                                                                                                                                                                                                                                                                                   |
| [mergeTreeProjection](/pt-BR/reference/functions/table-functions/mergeTreeProjection)           | Representa o conteúdo de uma projeção em tabelas MergeTree. Pode ser usado para introspecção.                                                                                                                                                                                                                                                                                                                                                              |
| [mergeTreeIndex](/pt-BR/reference/functions/table-functions/mergeTreeIndex)                     | Representa o conteúdo dos arquivos de índice e de marcas de tabelas MergeTree. Pode ser usado para introspecção.                                                                                                                                                                                                                                                                                                                                           |
| [hdfs](/pt-BR/reference/functions/table-functions/hdfs)                                         | Cria uma tabela a partir de arquivos no HDFS. Esta função de tabela é semelhante às funções de tabela url e file.                                                                                                                                                                                                                                                                                                                                          |
| [hdfsCluster](/pt-BR/reference/functions/table-functions/hdfsCluster)                           | Permite processar arquivos do HDFS em paralelo em vários nós de um cluster especificado.                                                                                                                                                                                                                                                                                                                                                                   |
| [hudi](/pt-BR/reference/functions/table-functions/hudi)                                         | Fornece uma interface semelhante a uma tabela, somente leitura, para tabelas Apache Hudi no Amazon S3.                                                                                                                                                                                                                                                                                                                                                     |
| [ytsaurus](/pt-BR/reference/functions/table-functions/ytsaurus)                                 | A função de tabela permite ler dados do cluster YTsaurus.                                                                                                                                                                                                                                                                                                                                                                                                  |
| [hudiCluster Table Function](/pt-BR/reference/functions/table-functions/hudiCluster)            | Uma extensão da função de tabela hudi. Permite processar arquivos de tabelas Apache Hudi no Amazon S3 em paralelo em vários nós de um cluster especificado.                                                                                                                                                                                                                                                                                                |
| [iceberg](/pt-BR/reference/functions/table-functions/iceberg)                                   | Fornece uma interface semelhante a uma tabela, somente leitura, para tabelas Apache Iceberg no Amazon S3, Azure, HDFS ou armazenadas localmente.                                                                                                                                                                                                                                                                                                           |
| [paimon](/pt-BR/reference/functions/table-functions/paimon)                                     | Fornece uma interface semelhante a uma tabela, somente leitura, para tabelas Apache Paimon no Amazon S3, Azure, HDFS ou armazenadas localmente.                                                                                                                                                                                                                                                                                                            |
| [icebergCluster](/pt-BR/reference/functions/table-functions/icebergCluster)                     | Uma extensão da função de tabela iceberg que permite processar arquivos do Apache Iceberg em paralelo em vários nós de um cluster especificado.                                                                                                                                                                                                                                                                                                            |
| [paimonCluster](/pt-BR/reference/functions/table-functions/paimonCluster)                       | Uma extensão da função de tabela paimon que permite processar arquivos do Apache Paimon em paralelo em vários nós de um cluster especificado.                                                                                                                                                                                                                                                                                                              |
| [input](/pt-BR/reference/functions/table-functions/input)                                       | Função de tabela que permite converter e inserir com eficiência dados enviados ao servidor com uma determinada estrutura em uma tabela com outra estrutura.                                                                                                                                                                                                                                                                                                |
| [jdbc](/pt-BR/reference/functions/table-functions/jdbc)                                         | Retorna uma tabela conectada por um JDBC driver.                                                                                                                                                                                                                                                                                                                                                                                                           |
| [merge](/pt-BR/reference/functions/table-functions/merge)                                       | Cria uma tabela Merge temporária. A estrutura será derivada das tabelas subjacentes usando uma união de suas colunas e inferindo tipos comuns.                                                                                                                                                                                                                                                                                                             |
| [mongodb](/pt-BR/reference/functions/table-functions/mongodb)                                   | Permite executar consultas `SELECT` em dados armazenados em um servidor MongoDB remoto.                                                                                                                                                                                                                                                                                                                                                                    |
| [mysql](/pt-BR/reference/functions/table-functions/mysql)                                       | Permite executar consultas `SELECT` e `INSERT` em dados armazenados em um servidor MySQL remoto.                                                                                                                                                                                                                                                                                                                                                           |
| [null](/pt-BR/reference/functions/table-functions/null)                                         | Cria uma tabela temporária com a estrutura especificada usando o mecanismo de tabela Null. A função é usada para facilitar a escrita de testes e demonstrações.                                                                                                                                                                                                                                                                                            |
| [timeSeriesMetrics](/pt-BR/reference/functions/table-functions/timeSeriesMetrics)               | timeSeriesMetrics retorna a tabela de métricas usada pela tabela `db_name.time_series_table`, cujo mecanismo de tabela é TimeSeries.                                                                                                                                                                                                                                                                                                                       |
| [timeSeriesSelector](/pt-BR/reference/functions/table-functions/timeSeriesSelector)             | Lê séries temporais de uma tabela TimeSeries, filtradas por um seletor e com timestamps em um intervalo especificado.                                                                                                                                                                                                                                                                                                                                      |
| [timeSeriesTags](/pt-BR/reference/functions/table-functions/timeSeriesTags)                     | A função de tabela timeSeriesTags retorna a tabela de tags usada pela tabela `db_name.time_series_table`, cujo mecanismo de tabela é TimeSeries.                                                                                                                                                                                                                                                                                                           |
| [prometheusQueryRange](/pt-BR/reference/functions/table-functions/prometheusQueryRange)         | Avalia uma consulta Prometheus usando dados de uma tabela TimeSeries.                                                                                                                                                                                                                                                                                                                                                                                      |
| [zeros](/pt-BR/reference/functions/table-functions/zeros)                                       | Usada para fins de teste como o método mais rápido de gerar muitas linhas. Semelhante às tabelas de sistema `system.zeros` e `system.zeros_mt`.                                                                                                                                                                                                                                                                                                            |
| [primes](/pt-BR/reference/functions/table-functions/primes)                                     | Retorna uma tabela com uma única coluna `prime` que contém números primos.                                                                                                                                                                                                                                                                                                                                                                                 |
| [timeSeriesData](/pt-BR/reference/functions/table-functions/timeSeriesData)                     | timeSeriesData retorna a tabela de dados usada pela tabela `db_name.time_series_table`, cujo mecanismo de tabela é TimeSeries.                                                                                                                                                                                                                                                                                                                             |
| [numbers](/pt-BR/reference/functions/table-functions/numbers)                                   | Retorna uma tabela com uma única coluna `number` que contém uma sequência de números inteiros.                                                                                                                                                                                                                                                                                                                                                             |
| [prometheusQuery](/pt-BR/reference/functions/table-functions/prometheusQuery)                   | Avalia uma consulta Prometheus usando dados de uma tabela TimeSeries.                                                                                                                                                                                                                                                                                                                                                                                      |
| [generate\_series (generateSeries)](/pt-BR/reference/functions/table-functions/generate_series) | Retorna uma tabela com a única coluna `generate_series` (UInt64), que contém números inteiros de start a stop, inclusive.                                                                                                                                                                                                                                                                                                                                  |
| [odbc](/pt-BR/reference/functions/table-functions/odbc)                                         | Retorna a tabela conectada via ODBC.                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [postgresql](/pt-BR/reference/functions/table-functions/postgresql)                             | Permite executar consultas `SELECT` e `INSERT` em dados armazenados em um servidor PostgreSQL remoto.                                                                                                                                                                                                                                                                                                                                                      |
| [redis](/pt-BR/reference/functions/table-functions/redis)                                       | Esta função de tabela permite integrar o ClickHouse ao Redis.                                                                                                                                                                                                                                                                                                                                                                                              |
| [remote, remoteSecure](/pt-BR/reference/functions/table-functions/remote)                       | A função de tabela `remote` permite acessar servidores remotos dinamicamente, ou seja, sem criar uma tabela distribuída. A função de tabela `remoteSecure` é igual à `remote`, mas usa uma conexão segura.                                                                                                                                                                                                                                                 |
| [s3 Table Function](/pt-BR/reference/functions/table-functions/s3)                              | Fornece uma interface semelhante a uma tabela para selecionar/inserir arquivos no Amazon S3 e no Google Cloud Storage. Esta função de tabela é semelhante à função hdfs, mas oferece recursos específicos do S3.                                                                                                                                                                                                                                           |
| [s3Cluster](/pt-BR/reference/functions/table-functions/s3Cluster)                               | Uma extensão da função de tabela s3, que permite processar arquivos do Amazon S3 e do Google Cloud Storage em paralelo em vários nós de um cluster especificado.                                                                                                                                                                                                                                                                                           |
| [sqlite](/pt-BR/reference/functions/table-functions/sqlite)                                     | Permite executar consultas em dados armazenados em um banco de dados SQLite.                                                                                                                                                                                                                                                                                                                                                                               |
| [arrowFlight](/pt-BR/reference/functions/table-functions/arrowflight)                           | Permite executar consultas em dados expostos por meio de um servidor Apache Arrow Flight.                                                                                                                                                                                                                                                                                                                                                                  |
| [url](/pt-BR/reference/functions/table-functions/url)                                           | Cria uma tabela a partir da `URL` com o `format` e a `structure` especificados                                                                                                                                                                                                                                                                                                                                                                             |
| [urlCluster](/pt-BR/reference/functions/table-functions/urlCluster)                             | Permite processar arquivos de uma URL em paralelo a partir de vários nós em um cluster especificado.                                                                                                                                                                                                                                                                                                                                                       |
| [view](/pt-BR/reference/functions/table-functions/view)                                         | Transforma uma subconsulta em uma tabela. A função implementa views.                                                                                                                                                                                                                                                                                                                                                                                       |
| [values](/pt-BR/reference/functions/table-functions/values)                                     | cria um armazenamento temporário que preenche colunas com valores.                                                                                                                                                                                                                                                                                                                                                                                         |
| [loop](/pt-BR/reference/functions/table-functions/loop)                                         | A função de tabela loop no ClickHouse é usada para retornar resultados de consulta em um loop infinito.                                                                                                                                                                                                                                                                                                                                                    |

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

Funções de tabela podem ser usadas na cláusula [`FROM`](/pt-BR/reference/statements/select/from)
de uma consulta `SELECT`. Por exemplo, você pode usar `SELECT` para selecionar dados de um arquivo na sua máquina local
usando a função de tabela `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 │
└────┴────┴────┘
```

Você também pode usar funções de tabela para criar uma tabela temporária disponível
apenas na consulta atual. Por exemplo:

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

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

A tabela é excluída quando a consulta é concluída.

As funções de tabela podem ser usadas para criar tabelas, usando a seguinte sintaxe:

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

Por exemplo:

```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 fim, funções de tabela podem ser usadas para inserir dados em uma tabela. Por exemplo,
poderíamos gravar o conteúdo da tabela que criamos no exemplo anterior
em um arquivo no disco usando novamente a função de tabela `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>
  Você não pode usar funções de tabela se a configuração [allow\_ddl](/pt-BR/reference/settings/session-settings#allow_ddl) estiver desativada.
</Note>
